ct-rich-text-editor 1.3.18 → 1.3.19

package/dist/{index-dbb526cd.js → index-23abcbd9.js}

@@ -24,14 +24,14 @@ import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
 import { TableNode, TableCellNode, TableRowNode, $createTableNodeWithDimensions, $isTableRowNode, $isTableCellNode, TableCellHeaderStates, $isTableNode, $isTableSelection, $getTableCellNodeFromLexicalNode, $getTableNodeFromLexicalNodeOrThrow, getTableElement, getTableObserverFromTableElement, $getTableRowIndexFromTableCellNode, $getNodeTriplet, $insertTableRow__EXPERIMENTAL, $getTableColumnIndexFromTableCellNode, $insertTableColumn__EXPERIMENTAL, $deleteTableRow__EXPERIMENTAL, $deleteTableColumn__EXPERIMENTAL, $unmergeCell, $computeTableMapSkipCellCheck, getDOMCellFromTarget, $getTableAndElementByKey } from "@lexical/table";
 import { mergeRegister, $wrapNodeInElement, $findMatchingParent, $getNearestNodeOfType, $getNearestBlockElementAncestorOrThrow, $insertNodeToNearestRoot, $isEditorIsNestedEditor, mediaFileReader, isMimeType, calculateZoomLevel, CAN_USE_DOM } from "@lexical/utils";
 import Stack from "@mui/material/Stack";
-import { createCommand, DecoratorNode, createEditor, $applyNodeReplacement, $insertNodes, $isRootOrShadowRoot, $createParagraphNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $getSelection, $isRangeSelection, $getNearestNodeFromDOMNode, $setSelection, isHTMLElement as isHTMLElement$1, TextNode, $getRoot, $createTextNode, $getNodeByKey, $isParagraphNode, $isTextNode, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, $isElementNode, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, UNDO_COMMAND, REDO_COMMAND, $createRangeSelection, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, KEY_ENTER_COMMAND, $createNodeSelection, $isNodeSelection, getDOMSelection, CLICK_COMMAND, COMMAND_PRIORITY_HIGH, $isLineBreakNode, PASTE_COMMAND, isDOMNode } from "lexical";
+import { createCommand, DecoratorNode, createEditor, $applyNodeReplacement, $insertNodes, $isRootOrShadowRoot, $createParagraphNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $getSelection, $isRangeSelection, $getNearestNodeFromDOMNode, $setSelection, isHTMLElement as isHTMLElement$1, TextNode, $getRoot, $createTextNode, $getNodeByKey, $isParagraphNode, $isTextNode, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, $isElementNode, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, UNDO_COMMAND, REDO_COMMAND, $createRangeSelection, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, KEY_ENTER_COMMAND, $createNodeSelection, $isNodeSelection, getDOMSelection, CLICK_COMMAND, COMMAND_PRIORITY_HIGH, $isLineBreakNode, PASTE_COMMAND, ParagraphNode, $createLineBreakNode, isDOMNode } from "lexical";
 import * as ReactDOM from "react-dom";
 import ReactDOM__default, { createPortal } from "react-dom";
 import { $isCodeNode, CodeNode, normalizeCodeLang, getLanguageFriendlyName, CodeHighlightNode, CODE_LANGUAGE_MAP, $createCodeNode, registerCodeHighlighting, $isCodeHighlightNode } from "@lexical/code";
 import { LinkNode, $isLinkNode, TOGGLE_LINK_COMMAND, $isAutoLinkNode, $createLinkNode } from "@lexical/link";
 import { ListNode, ListItemNode, $isListNode, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, $createListNode, $createListItemNode } from "@lexical/list";
 import { HeadingNode, QuoteNode, $isHeadingNode, $createHeadingNode, $createQuoteNode, DRAG_DROP_PASTE } from "@lexical/rich-text";
-import { $isAtNodeEnd, $selectAll, $patchStyleText, $setBlocksType, $isParentElementRTL, $getSelectionStyleValueForProperty } from "@lexical/selection";
+import { $isAtNodeEnd, $selectAll, $patchStyleText, $setBlocksType, $getSelectionStyleValueForProperty, $isParentElementRTL } from "@lexical/selection";
 import { HorizontalRuleNode } from "@lexical/react/LexicalHorizontalRuleNode";
 import DescriptionIcon from "@mui/icons-material/Description";
 import FolderZipIcon from "@mui/icons-material/FolderZip";
@@ -1479,7 +1479,7 @@ const AiTextTransform = async ({ content, apiKey }) => {
 const AI_ACTION_COMMAND = createCommand(
   "AI_ACTION_COMMAND"
 );
-const ImageView = React__default.lazy(() => import("./index-2bc5ccbc.js"));
+const ImageView = React__default.lazy(() => import("./index-913b3634.js"));
 function isGoogleDocCheckboxImg(img) {
   return img.parentElement != null && img.parentElement.tagName === "LI" && img.previousSibling === null && img.getAttribute("aria-roledescription") === "checkbox";
 }
@@ -1489,11 +1489,16 @@ function $convertImageElement(domNode) {
     return null;
   }
   const { alt: altText, src, width, height } = img;
-  const node = $createImageNode({ altText, height, src, width });
+  const positionAttr = img.getAttribute("data-position");
+  let position = "none";
+  if (positionAttr === "left" || positionAttr === "right" || positionAttr === "full") {
+    position = positionAttr;
+  }
+  const node = $createImageNode({ altText, height, src, width, position });
   return { node };
 }
 class ImageNode extends DecoratorNode {
-  constructor(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, originalPrompt, key) {
+  constructor(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, originalPrompt, position, key) {
     super(key);
     __publicField(this, "__src");
     __publicField(this, "__altText");
@@ -1505,6 +1510,7 @@ class ImageNode extends DecoratorNode {
     // Captions cannot yet be used within editor cells
     __publicField(this, "__captionsEnabled");
     __publicField(this, "__originalPrompt");
+    __publicField(this, "__position");
     this.__src = src;
     this.__altText = altText;
     this.__maxWidth = maxWidth;
@@ -1516,6 +1522,7 @@ class ImageNode extends DecoratorNode {
     });
     this.__captionsEnabled = captionsEnabled || captionsEnabled === void 0;
     this.__originalPrompt = originalPrompt || "";
+    this.__position = position || "none";
   }
   // to identify the image node and must unique too
   static getType() {
@@ -1533,12 +1540,13 @@ class ImageNode extends DecoratorNode {
       node.__caption,
       node.__captionsEnabled,
       node.__originalPrompt,
+      node.__position,
       node.__key
     );
   }
   // importing to json format
   static importJSON(serializedNode) {
-    const { altText, height, width, maxWidth, caption, src, showCaption, originalPrompt } = serializedNode;
+    const { altText, height, width, maxWidth, caption, src, showCaption, originalPrompt, position } = serializedNode;
     const node = $createImageNode({
       altText,
       height,
@@ -1546,8 +1554,9 @@ class ImageNode extends DecoratorNode {
       showCaption,
       src,
       width,
-      originalPrompt: originalPrompt || ""
+      originalPrompt: originalPrompt || "",
       // Default to empty string if undefined
+      position: position || "none"
     });
     const nestedEditor = node.__caption;
     const editorState = nestedEditor.parseEditorState(caption.editorState);
@@ -1558,12 +1567,15 @@ class ImageNode extends DecoratorNode {
   }
   // Exports this node as an actual <img> tag in the DOM when needed
   exportDOM() {
-    const element = document.createElement("img");
-    element.setAttribute("src", this.__src);
-    element.setAttribute("alt", this.__altText);
-    element.setAttribute("width", this.__width.toString());
-    element.setAttribute("height", this.__height.toString());
-    return { element };
+    const img = document.createElement("img");
+    img.setAttribute("src", this.__src);
+    img.setAttribute("alt", this.__altText);
+    img.setAttribute("width", this.__width.toString());
+    img.setAttribute("height", this.__height.toString());
+    if (this.__position && this.__position !== "none") {
+      img.setAttribute("data-position", this.__position);
+    }
+    return { element: img };
   }
   // convert img tag into image node in the editor using convertImageElement func
   static importDOM() {
@@ -1585,7 +1597,8 @@ class ImageNode extends DecoratorNode {
       type: "image",
       version: 1,
       width: this.__width === "inherit" ? 0 : this.__width,
-      originalPrompt: this.__originalPrompt
+      originalPrompt: this.__originalPrompt,
+      position: this.__position
     };
   }
   // setting width and height when resizing
@@ -1607,9 +1620,26 @@ class ImageNode extends DecoratorNode {
     if (className !== void 0) {
       span.className = className;
     }
+    if (this.__position === "left") {
+      span.style.cssText = "float: left; margin-right: 1em; margin-bottom: 0.5em; max-width: 50%; display: block;";
+    } else if (this.__position === "right") {
+      span.style.cssText = "float: right; margin-left: 1em; margin-bottom: 0.5em; max-width: 50%; display: block;";
+    } else if (this.__position === "full") {
+      span.style.cssText = "display: block; width: 100%; margin: 1em 0;";
+    }
     return span;
   }
-  updateDOM() {
+  updateDOM(prevNode, dom) {
+    if (prevNode.__position !== this.__position) {
+      dom.style.cssText = "";
+      if (this.__position === "left") {
+        dom.style.cssText = "float: left; margin-right: 1em; margin-bottom: 0.5em; max-width: 50%; display: block;";
+      } else if (this.__position === "right") {
+        dom.style.cssText = "float: right; margin-left: 1em; margin-bottom: 0.5em; max-width: 50%; display: block;";
+      } else if (this.__position === "full") {
+        dom.style.cssText = "display: block; width: 100%; margin: 1em 0;";
+      }
+    }
     return false;
   }
   // to get the image src
@@ -1633,6 +1663,15 @@ class ImageNode extends DecoratorNode {
     const writable = this.getWritable();
     writable.__originalPrompt = prompt;
   }
+  // to get the image position (float)
+  getPosition() {
+    return this.__position;
+  }
+  // to set the image position (float)
+  setPosition(position) {
+    const writable = this.getWritable();
+    writable.__position = position;
+  }
   // to render the image tag
   decorate() {
     return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
@@ -1648,7 +1687,8 @@ class ImageNode extends DecoratorNode {
         caption: this.__caption,
         captionsEnabled: this.__captionsEnabled,
         resizable: true,
-        originalPrompt: this.__originalPrompt
+        originalPrompt: this.__originalPrompt,
+        position: this.__position
       }
     ) });
   }
@@ -1663,7 +1703,8 @@ function $createImageNode({
   showCaption,
   caption,
   key,
-  originalPrompt
+  originalPrompt,
+  position
 }) {
   return $applyNodeReplacement(
     new ImageNode(
@@ -1676,6 +1717,7 @@ function $createImageNode({
       caption,
       captionsEnabled,
       originalPrompt,
+      position,
       key
     )
   );
@@ -7551,6 +7593,17 @@ const Minimize2 = createLucideIcon("Minimize2", [
  * See the LICENSE file in the root directory of this source tree.
  */
 const Minus = createLucideIcon("Minus", [["path", { d: "M5 12h14", key: "1ays0h" }]]);
+/**
+ * @license lucide-react v0.344.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const PanelBottomOpen = createLucideIcon("PanelBottomOpen", [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M3 15h18", key: "5xshup" }],
+  ["path", { d: "m9 10 3-3 3 3", key: "11gsxs" }]
+]);
 /**
  * @license lucide-react v0.344.0 - ISC
  *
@@ -7660,6 +7713,16 @@ const Search = createLucideIcon("Search", [
   ["circle", { cx: "11", cy: "11", r: "8", key: "4ej97u" }],
   ["path", { d: "m21 21-4.3-4.3", key: "1qie3q" }]
 ]);
+/**
+ * @license lucide-react v0.344.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Send = createLucideIcon("Send", [
+  ["path", { d: "m22 2-7 20-4-9-9-4Z", key: "1q3vgg" }],
+  ["path", { d: "M22 2 11 13", key: "nzbqef" }]
+]);
 /**
  * @license lucide-react v0.344.0 - ISC
  *
@@ -15282,7 +15345,7 @@ const EmbedComponent = ({ url, displayType, alignment, nodeKey }) => {
     }
   );
 };
-const FileComponent = React$1.lazy(() => import("./index-7ddd4fcc.js"));
+const FileComponent = React$1.lazy(() => import("./index-afa4eda8.js"));
 function convertFileElement(domNode) {
   if (domNode instanceof HTMLDivElement) {
     const dataUrl = domNode.getAttribute("data-lexical-file-src");
@@ -18577,7 +18640,7 @@ const formatMenuItems = [
   }
 ];
 const LOWEST_PRIORITY = 1;
-const DEFAULT_FONT_SIZE = 15;
+const DEFAULT_FONT_SIZE$1 = 15;
 const INITIAL_TOOLBAR_STATE = {
   bgColor: "#fff",
   blockType: "paragraph",
@@ -18588,9 +18651,9 @@ const INITIAL_TOOLBAR_STATE = {
   fontColor: "#000",
   fontFamily: "Arial",
   // Current font size in px
-  fontSize: `${DEFAULT_FONT_SIZE}px`,
+  fontSize: `${DEFAULT_FONT_SIZE$1}px`,
   // Font size input value - for controlled input
-  fontSizeInputValue: `${DEFAULT_FONT_SIZE}`,
+  fontSizeInputValue: `${DEFAULT_FONT_SIZE$1}`,
   isBold: false,
   isCode: false,
   isHighlight: false,
@@ -19061,12 +19124,15 @@ const useVoiceToText = ({ onTranscriptUpdate }) => {
   };
 };
 const TOGGLE_AI_CHAT_COMMAND = createCommand();
+const SHOW_INLINE_AI_PROMPT_COMMAND = createCommand();
 function AIChatDialog({
   open,
   onOpenChange,
   editor,
   apiKey,
-  initialText
+  initialText,
+  onShowInEditor,
+  selectedTextForInline
 }) {
   const [inputValue, setInputValue] = useState$1("");
   const [isLoading, setIsLoading] = useState$1(false);
@@ -19330,6 +19396,24 @@ function AIChatDialog({
           children: "Cancel"
         }
       ),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "outline",
+          onClick: () => {
+            if (onShowInEditor) {
+              onShowInEditor(provider, selectedTextForInline);
+              handleClose();
+            }
+          },
+          disabled: isLoading,
+          title: "Show AI prompt in the editor text area",
+          children: [
+            /* @__PURE__ */ jsx(PanelBottomOpen, { size: 16 }),
+            "Show in Editor"
+          ]
+        }
+      ),
       /* @__PURE__ */ jsx(
         Button,
         {
@@ -19347,10 +19431,257 @@ function AIChatDialog({
     ] })
   ] }) }) });
 }
-function useAIChatToolbar(editor, apiKey) {
+function InlineAIPrompt({
+  editor,
+  apiKey,
+  initialProvider,
+  selectedText: initialSelectedText,
+  onClose,
+  anchorElem
+}) {
+  const [provider, setProvider] = useState$1(initialProvider);
+  const [inputValue, setInputValue] = useState$1("");
+  const [isLoading, setIsLoading] = useState$1(false);
+  const inputRef = useRef(null);
+  const [selectedText, setSelectedText] = useState$1(initialSelectedText);
+  useEffect$1(() => {
+    const unregister = editor.registerUpdateListener(({ editorState }) => {
+      editorState.read(() => {
+        const selection = $getSelection();
+        if (selection && selection.getTextContent().trim()) {
+          const newSelectedText = selection.getTextContent();
+          if (newSelectedText.trim() !== "") {
+            setSelectedText(newSelectedText);
+          }
+        }
+      });
+    });
+    return () => {
+      unregister();
+    };
+  }, [editor]);
+  useEffect$1(() => {
+    if (inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, []);
+  const handleSubmit = async () => {
+    var _a, _b;
+    if (!inputValue.trim() || isLoading)
+      return;
+    if (!selectedText || selectedText.trim() === "") {
+      toast.error("Please select some text first");
+      return;
+    }
+    setIsLoading(true);
+    const fullPrompt = `${inputValue}
+
+IMPORTANT: Return ONLY the modified/transformed text. Do NOT include any labels, prefixes, explanations, or formatting like "Simplified:", "Result:", "Here is", etc. Just return the pure result text.
+
+Text to transform:
+"${selectedText}"`;
+    try {
+      const response = await AiEditorAction({ content: fullPrompt, provider, apiKey });
+      let htmlString = response.data;
+      if (typeof htmlString === "string") {
+        htmlString = htmlString.trim();
+        if (htmlString.startsWith('"') && htmlString.endsWith('"') || htmlString.startsWith("'") && htmlString.endsWith("'")) {
+          htmlString = htmlString.slice(1, -1);
+        }
+      }
+      editor.update(() => {
+        const parser = new DOMParser();
+        const dom = parser.parseFromString(htmlString.trim(), "text/html");
+        const nodes = $generateNodesFromDOM(editor, dom);
+        const currentSelection = $getSelection();
+        if (currentSelection) {
+          $insertNodes(nodes);
+        }
+      });
+      setInputValue("");
+      setSelectedText("");
+    } catch (error) {
+      console.error("Error processing AI action:", error);
+      const apiMessage = ((_b = (_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) ?? (error instanceof Error ? error.message : null);
+      const safeMessage = apiMessage && !/^Request failed with status code \d+/.test(apiMessage) ? apiMessage : "Error processing your request. Please try again.";
+      toast.error(safeMessage);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey && !isLoading && inputValue.trim()) {
+      e.preventDefault();
+      handleSubmit();
+    }
+    if (e.key === "Escape") {
+      onClose();
+    }
+  };
+  const hasSelectedText = selectedText && selectedText.trim() !== "";
+  const displayText = hasSelectedText ? selectedText.length > 50 ? selectedText.substring(0, 50) + "..." : selectedText : "";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        bottom: "12px",
+        left: "50%",
+        transform: "translateX(-50%)",
+        display: "flex",
+        flexDirection: "column",
+        gap: "8px",
+        backgroundColor: "#1a1a1a",
+        padding: "12px 16px",
+        borderRadius: "12px",
+        border: "1px solid #333",
+        boxShadow: "0 8px 24px rgba(0,0,0,0.4)",
+        zIndex: 10,
+        maxWidth: "500px"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "8px",
+              padding: "6px 10px",
+              backgroundColor: hasSelectedText ? "#2a2a2a" : "#3a2a2a",
+              borderRadius: "6px",
+              fontSize: "12px",
+              color: "#999",
+              border: hasSelectedText ? "none" : "1px solid #5a3a3a"
+            },
+            children: hasSelectedText ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("span", { style: { color: "#666" }, children: "Selected:" }),
+              /* @__PURE__ */ jsxs("span", { style: { color: "#ccc", fontStyle: "italic" }, children: [
+                '"',
+                displayText,
+                '"'
+              ] })
+            ] }) : /* @__PURE__ */ jsx("span", { style: { color: "#f87171" }, children: "⚠ Please select some text in the editor first" })
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "10px" }, children: [
+          /* @__PURE__ */ jsx(Sparkles, { size: 16, style: { color: "#fff", flexShrink: 0 } }),
+          /* @__PURE__ */ jsxs(
+            "select",
+            {
+              value: provider,
+              onChange: (e) => setProvider(e.target.value),
+              style: {
+                width: "100px",
+                height: "32px",
+                padding: "0 8px",
+                fontSize: "13px",
+                fontWeight: 500,
+                border: "1px solid #444",
+                borderRadius: "6px",
+                outline: "none",
+                backgroundColor: "#2a2a2a",
+                color: "#fff",
+                cursor: "pointer"
+              },
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "chatgpt", children: "ChatGPT" }),
+                /* @__PURE__ */ jsx("option", { value: "claude", children: "Claude" }),
+                /* @__PURE__ */ jsx("option", { value: "grok", children: "Grok" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              ref: inputRef,
+              type: "text",
+              value: inputValue,
+              onChange: (e) => setInputValue(e.target.value),
+              onKeyDown: handleKeyDown,
+              placeholder: hasSelectedText ? "What do you want to do with this text?" : "Select text first...",
+              disabled: isLoading,
+              style: {
+                width: "280px",
+                height: "32px",
+                padding: "0 12px",
+                fontSize: "13px",
+                border: "1px solid #444",
+                borderRadius: "6px",
+                outline: "none",
+                backgroundColor: "#2a2a2a",
+                color: "#fff"
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: handleSubmit,
+              disabled: isLoading || !inputValue.trim(),
+              style: {
+                height: "32px",
+                width: "32px",
+                backgroundColor: "#fff",
+                color: "#1a1a1a",
+                borderRadius: "6px",
+                border: "none",
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                cursor: isLoading || !inputValue.trim() ? "not-allowed" : "pointer",
+                opacity: isLoading || !inputValue.trim() ? 0.5 : 1,
+                flexShrink: 0,
+                transition: "background-color 0.2s"
+              },
+              children: isLoading ? /* @__PURE__ */ jsx("div", { style: {
+                height: "14px",
+                width: "14px",
+                border: "2px solid #1a1a1a",
+                borderTopColor: "transparent",
+                borderRadius: "50%",
+                animation: "spin 1s linear infinite"
+              } }) : /* @__PURE__ */ jsx(Send, { size: 14 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: onClose,
+              style: {
+                height: "32px",
+                width: "32px",
+                backgroundColor: "transparent",
+                color: "#888",
+                borderRadius: "6px",
+                border: "none",
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                cursor: "pointer",
+                flexShrink: 0,
+                transition: "color 0.2s"
+              },
+              title: "Close (Esc)",
+              onMouseEnter: (e) => e.currentTarget.style.color = "#fff",
+              onMouseLeave: (e) => e.currentTarget.style.color = "#888",
+              children: /* @__PURE__ */ jsx(X$1, { size: 16 })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function useAIChatToolbar(editor, apiKey, anchorElem) {
   const [isVisible, setIsVisible] = useState$1(false);
   const [selectedText, setSelectedText] = useState$1(void 0);
   const savedSelectionRef = useRef(null);
+  const [showInlinePrompt, setShowInlinePrompt] = useState$1(false);
+  const [inlineProvider, setInlineProvider] = useState$1("chatgpt");
+  const [inlineSelectedText, setInlineSelectedText] = useState$1("");
   const toggleAIChat = useCallback((text) => {
     editor.getEditorState().read(() => {
       const selection = $getSelection();
@@ -19361,8 +19692,17 @@ function useAIChatToolbar(editor, apiKey) {
     setSelectedText(text);
     setIsVisible((prevState) => !prevState);
   }, [editor]);
+  const handleShowInEditor = useCallback((provider, textFromDialog) => {
+    setInlineProvider(provider);
+    setInlineSelectedText(textFromDialog || selectedText || "");
+    setShowInlinePrompt(true);
+  }, [selectedText]);
+  const handleCloseInlinePrompt = useCallback(() => {
+    setShowInlinePrompt(false);
+    setInlineSelectedText("");
+  }, []);
   useEffect$1(() => {
-    return editor.registerCommand(
+    const unregisterToggle = editor.registerCommand(
       TOGGLE_AI_CHAT_COMMAND,
       (text) => {
         toggleAIChat(text);
@@ -19370,18 +19710,55 @@ function useAIChatToolbar(editor, apiKey) {
       },
       COMMAND_PRIORITY_LOW
     );
+    const unregisterInline = editor.registerCommand(
+      SHOW_INLINE_AI_PROMPT_COMMAND,
+      (payload) => {
+        let currentSelectedText = "";
+        editor.getEditorState().read(() => {
+          const selection = $getSelection();
+          if (selection) {
+            currentSelectedText = selection.getTextContent();
+          }
+        });
+        setInlineProvider((payload == null ? void 0 : payload.provider) || "chatgpt");
+        setInlineSelectedText((payload == null ? void 0 : payload.initialText) || currentSelectedText);
+        setShowInlinePrompt(true);
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+    return () => {
+      unregisterToggle();
+      unregisterInline();
+    };
   }, [editor, toggleAIChat]);
-  return /* @__PURE__ */ jsx(Fragment, { children: isVisible && /* @__PURE__ */ jsx(
-    AIChatDialog,
-    {
-      open: isVisible,
-      onOpenChange: setIsVisible,
-      editor,
-      apiKey,
-      initialText: selectedText,
-      savedSelection: savedSelectionRef.current
-    }
-  ) });
+  const editorRootElement = editor.getRootElement();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    isVisible && /* @__PURE__ */ jsx(
+      AIChatDialog,
+      {
+        open: isVisible,
+        onOpenChange: setIsVisible,
+        editor,
+        apiKey,
+        initialText: selectedText,
+        savedSelection: savedSelectionRef.current,
+        onShowInEditor: handleShowInEditor,
+        selectedTextForInline: selectedText
+      }
+    ),
+    showInlinePrompt && /* @__PURE__ */ jsx(
+      InlineAIPrompt,
+      {
+        editor,
+        apiKey,
+        initialProvider: inlineProvider,
+        selectedText: inlineSelectedText,
+        onClose: handleCloseInlinePrompt,
+        anchorElem: editorRootElement
+      }
+    )
+  ] });
 }
 function AIChatPlugin({
   apiKey
@@ -19991,10 +20368,10 @@ const PDF_CONFIG = {
 };
 const loadHtml2Pdf = async () => {
   try {
-    const mod = await import("./html2pdf.bundle.min-db02af80.js").then((n) => n.h);
+    const mod = await import("./html2pdf.bundle.min-f1b4a78e.js").then((n) => n.h);
     return (mod == null ? void 0 : mod.default) || mod;
   } catch {
-    const mod2 = await import("./html2pdf.bundle-0a42a49f.js").then((n) => n.h);
+    const mod2 = await import("./html2pdf.bundle-a30dde70.js").then((n) => n.h);
     return (mod2 == null ? void 0 : mod2.default) || mod2;
   }
 };
@@ -23236,92 +23613,123 @@ const FontFamilyMenu = ({
   activeEditor
 }) => {
   const [selectedFont, setSelectedFont] = useState$1("Arial");
+  const [detectedFonts, setDetectedFonts] = useState$1(/* @__PURE__ */ new Set());
+  const allFonts = useMemo(() => {
+    const fontSet = new Set(fonts);
+    detectedFonts.forEach((font) => fontSet.add(font));
+    return Array.from(fontSet);
+  }, [fonts, detectedFonts]);
   useEffect$1(() => {
     return activeEditor.registerUpdateListener(({ editorState }) => {
       editorState.read(() => {
-        var _a;
         const selection = $getSelection();
         if ($isRangeSelection(selection)) {
-          const anchorNode = selection.anchor.getNode();
-          if ($isTextNode(anchorNode)) {
-            const fontFamily = (_a = anchorNode.getStyle().match(/font-family:\s*([^;]+)/)) == null ? void 0 : _a[1];
-            if (fontFamily) {
-              setSelectedFont(fontFamily);
-            }
+          const fontFamily = $getSelectionStyleValueForProperty(
+            selection,
+            "font-family",
+            "Arial"
+          );
+          const cleanedFont = fontFamily.replace(/^["']|["']$/g, "").trim();
+          setSelectedFont(cleanedFont);
+          if (cleanedFont && cleanedFont !== "Arial" && !fonts.includes(cleanedFont)) {
+            setDetectedFonts((prev) => {
+              if (prev.has(cleanedFont))
+                return prev;
+              const newSet = new Set(prev);
+              newSet.add(cleanedFont);
+              return newSet;
+            });
           }
         }
       });
     });
-  }, [activeEditor]);
-  const applyFontFamily = (fontFamily) => {
-    activeEditor.update(() => {
-      const selection = $getSelection();
-      if ($isRangeSelection(selection)) {
-        $patchStyleText(selection, { "font-family": fontFamily });
-      }
-    });
-  };
+  }, [activeEditor, fonts]);
+  const applyFontFamily = useCallback(
+    (fontFamily) => {
+      activeEditor.update(() => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          $patchStyleText(selection, { "font-family": fontFamily });
+        }
+      });
+    },
+    [activeEditor]
+  );
   const handleFontChange = (value) => {
     setSelectedFont(value);
     applyFontFamily(value);
   };
   return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Select, { value: selectedFont, onValueChange: handleFontChange, children: [
     /* @__PURE__ */ jsx(SelectTrigger, { className: "!cteditor-h-7 md:!cteditor-bg-secondary !cteditor-bg-foreground/5 cteditor-text-foreground md:!cteditor-w-[120px] cteditor-text-xs max-md:cteditor-w-full", children: /* @__PURE__ */ jsx(SelectValue, { placeholder: "Select font" }) }),
-    /* @__PURE__ */ jsx(SelectContent, { children: fonts.map((font) => /* @__PURE__ */ jsx(SelectItem, { value: font, style: { fontFamily: font }, children: font }, font)) })
+    /* @__PURE__ */ jsx(SelectContent, { children: allFonts.map((font) => /* @__PURE__ */ jsx(SelectItem, { value: font, style: { fontFamily: font }, children: font }, font)) })
   ] }) });
 };
 const MIN_FONT_SIZE = 8;
 const MAX_FONT_SIZE = 72;
+const DEFAULT_FONT_SIZE = 16;
 const STEP_SIZE = 2;
 const FontSizeControl = () => {
   const [editor] = useLexicalComposerContext();
-  const [fontSize, setFontSize] = useState$1(16);
-  const [inputValue, setInputValue] = useState$1("16");
+  const [fontSize, setFontSize] = useState$1(DEFAULT_FONT_SIZE);
+  const [inputValue, setInputValue] = useState$1(DEFAULT_FONT_SIZE.toString());
+  const pendingFontSizeRef = React__default.useRef(null);
   useEffect$1(() => {
     return editor.registerUpdateListener(({ editorState }) => {
       editorState.read(() => {
-        var _a;
         const selection = $getSelection();
-        if ($isRangeSelection(selection) && !selection.isCollapsed()) {
-          const anchorNode = selection.anchor.getNode();
-          if ($isTextNode(anchorNode)) {
-            const detectedSize = (_a = anchorNode.getStyle().match(/font-size:\s*(\d+)/)) == null ? void 0 : _a[1];
-            if (detectedSize) {
-              const size2 = parseInt(detectedSize, 10);
-              setFontSize(size2);
-              setInputValue(size2.toString());
-            }
+        if ($isRangeSelection(selection)) {
+          const fontSizeStr = $getSelectionStyleValueForProperty(
+            selection,
+            "font-size",
+            `${DEFAULT_FONT_SIZE}px`
+          );
+          const size2 = parseInt(fontSizeStr, 10) || DEFAULT_FONT_SIZE;
+          if (pendingFontSizeRef.current !== null && size2 === pendingFontSizeRef.current) {
+            pendingFontSizeRef.current = null;
+          }
+          if (pendingFontSizeRef.current === null) {
+            setFontSize(size2);
+            setInputValue(size2.toString());
           }
         }
       });
     });
   }, [editor]);
+  useEffect$1(() => {
+    const rootElement = editor.getRootElement();
+    if (!rootElement)
+      return;
+    const handleFocus = () => {
+      if (pendingFontSizeRef.current !== null) {
+        const pendingSize = pendingFontSizeRef.current;
+        editor.update(() => {
+          const selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            $patchStyleText(selection, { "font-size": `${pendingSize}px` });
+          }
+        });
+      }
+    };
+    rootElement.addEventListener("focus", handleFocus);
+    return () => {
+      rootElement.removeEventListener("focus", handleFocus);
+    };
+  }, [editor]);
   const applyFontSize = useCallback(
     (size2) => {
+      pendingFontSizeRef.current = size2;
       editor.update(() => {
         const selection = $getSelection();
         if ($isRangeSelection(selection)) {
           $patchStyleText(selection, { "font-size": `${size2}px` });
         }
       });
-      setFontSize(size2);
-      setInputValue(size2.toString());
     },
     [editor]
   );
-  useEffect$1(() => {
-    applyFontSize(fontSize);
-  }, [fontSize, applyFontSize]);
   const handleFontSizeChange = (event) => {
     const value = event.target.value.replace(/\D/g, "");
     setInputValue(value);
-    if (value !== "") {
-      const newSize = Math.max(
-        MIN_FONT_SIZE,
-        Math.min(Number(value), MAX_FONT_SIZE)
-      );
-      setFontSize(newSize);
-    }
   };
   const handleFontSizeBlur = () => {
     if (inputValue === "" || isNaN(Number(inputValue))) {
@@ -23332,15 +23740,28 @@ const FontSizeControl = () => {
         Math.min(Number(inputValue), MAX_FONT_SIZE)
       );
       setFontSize(newSize);
+      setInputValue(newSize.toString());
+      applyFontSize(newSize);
+    }
+  };
+  const handleKeyDown = (event) => {
+    if (event.key === "Enter") {
+      event.preventDefault();
+      handleFontSizeBlur();
+      editor.focus();
     }
   };
   const increaseFontSize = () => {
     const newSize = Math.min(fontSize + STEP_SIZE, MAX_FONT_SIZE);
     setFontSize(newSize);
+    setInputValue(newSize.toString());
+    applyFontSize(newSize);
   };
   const decreaseFontSize = () => {
     const newSize = Math.max(fontSize - STEP_SIZE, MIN_FONT_SIZE);
     setFontSize(newSize);
+    setInputValue(newSize.toString());
+    applyFontSize(newSize);
   };
   return /* @__PURE__ */ jsxs("div", { className: "cteditor-flex cteditor-items-center cteditor-gap-1", children: [
     /* @__PURE__ */ jsx(TooltipProvider, { delayDuration: 200, children: /* @__PURE__ */ jsxs(Tooltip, { children: [
@@ -23362,7 +23783,8 @@ const FontSizeControl = () => {
         className: "!cteditor-w-9 !cteditor-h-6 !cteditor-p-0 !cteditor-text-center !cteditor-bg-secondary",
         value: inputValue,
         onChange: handleFontSizeChange,
-        onBlur: handleFontSizeBlur
+        onBlur: handleFontSizeBlur,
+        onKeyDown: handleKeyDown
       }
     ),
     /* @__PURE__ */ jsx(TooltipProvider, { delayDuration: 200, children: /* @__PURE__ */ jsxs(Tooltip, { children: [
@@ -25735,7 +26157,15 @@ const Toolbar = ({
     });
   }, [editor]);
   const toggleAIChat = useCallback(() => {
-    editor.dispatchCommand(TOGGLE_AI_CHAT_COMMAND, void 0);
+    editor.getEditorState().read(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        const selectedText = selection.getTextContent();
+        editor.dispatchCommand(TOGGLE_AI_CHAT_COMMAND, selectedText || void 0);
+      } else {
+        editor.dispatchCommand(TOGGLE_AI_CHAT_COMMAND, void 0);
+      }
+    });
   }, [editor]);
   const createTodo = useCallback(() => {
     editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, void 0);
@@ -28381,26 +28811,6 @@ function DragDropPaste() {
           return;
         }
       }
-      const html = clipboardData.getData("text/html");
-      if (html) {
-        const tempDiv = document.createElement("div");
-        tempDiv.innerHTML = html;
-        const images = tempDiv.querySelectorAll("img");
-        if (images.length > 0) {
-          e.preventDefault();
-          images.forEach((img) => {
-            if (img.src) {
-              editor.dispatchCommand(INSERT_IMAGE_COMMAND, {
-                altText: img.alt || "Pasted image",
-                src: img.src,
-                width: img.width || void 0,
-                height: img.height || void 0
-              });
-            }
-          });
-          return;
-        }
-      }
     };
     const editorElement = editor.getRootElement();
     if (editorElement) {
@@ -31074,6 +31484,827 @@ function NewMentionsPlugin({
     }
   );
 }
+function detectCSSAlignment(element) {
+  let current = element;
+  while (current && current !== document.body) {
+    const style = current.style;
+    const computedStyle = window.getComputedStyle(current);
+    const textAlign = style.textAlign || computedStyle.textAlign;
+    if (textAlign === "center")
+      return "center";
+    if (textAlign === "right")
+      return "right";
+    if (textAlign === "justify")
+      return "justify";
+    const display = computedStyle.display;
+    const justifyContent = computedStyle.justifyContent;
+    if (display === "flex" && (justifyContent === "center" || justifyContent === "space-around")) {
+      return "center";
+    }
+    const marginLeft = computedStyle.marginLeft;
+    const marginRight = computedStyle.marginRight;
+    if (marginLeft === "auto" && marginRight === "auto") {
+      return "center";
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+function getImageDimensions(imgElement) {
+  let width = parseInt(imgElement.getAttribute("width") || "0");
+  let height = parseInt(imgElement.getAttribute("height") || "0");
+  if (width === 0) {
+    const styleWidth = imgElement.style.width;
+    if (styleWidth && styleWidth.endsWith("px")) {
+      width = parseInt(styleWidth);
+    }
+  }
+  if (height === 0) {
+    const styleHeight = imgElement.style.height;
+    if (styleHeight && styleHeight.endsWith("px")) {
+      height = parseInt(styleHeight);
+    }
+  }
+  if (width === 0 || height === 0) {
+    try {
+      const computed = window.getComputedStyle(imgElement);
+      if (width === 0 && computed.width && computed.width !== "auto") {
+        width = parseInt(computed.width);
+      }
+      if (height === 0 && computed.height && computed.height !== "auto") {
+        height = parseInt(computed.height);
+      }
+    } catch {
+    }
+  }
+  if (imgElement instanceof HTMLImageElement) {
+    if (width === 0 && imgElement.naturalWidth) {
+      width = imgElement.naturalWidth;
+    }
+    if (height === 0 && imgElement.naturalHeight) {
+      height = imgElement.naturalHeight;
+    }
+  }
+  return { width, height };
+}
+function shouldCenterImage(imgElement) {
+  var _a;
+  const { width, height } = getImageDimensions(imgElement);
+  if (width >= 500) {
+    return true;
+  }
+  const parent = imgElement.parentElement;
+  if (parent) {
+    const siblings = Array.from(parent.childNodes);
+    const meaningfulSiblings = siblings.filter((node) => {
+      var _a2, _b;
+      if (node === imgElement)
+        return false;
+      if (node.nodeType === Node.TEXT_NODE) {
+        return ((_a2 = node.textContent) == null ? void 0 : _a2.trim().length) !== 0;
+      }
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const el = node;
+        if (el.tagName.toLowerCase() === "br")
+          return false;
+        return ((_b = el.textContent) == null ? void 0 : _b.trim().length) !== 0;
+      }
+      return false;
+    });
+    if (meaningfulSiblings.length === 0) {
+      return true;
+    }
+  }
+  if (width > 0 && height > 0 && width > height * 1.5 && width >= 300) {
+    return true;
+  }
+  let current = imgElement.parentElement;
+  while (current && current !== document.body) {
+    const tagName = current.tagName.toLowerCase();
+    if (tagName === "figure" || tagName === "article" || tagName === "section") {
+      if (width >= 200 || width === 0) {
+        return true;
+      }
+    }
+    current = current.parentElement;
+  }
+  try {
+    const computed = window.getComputedStyle(imgElement);
+    if (computed.display === "block") {
+      if (width >= 200 || width === 0) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  if (width === 0) {
+    const parentTag = parent == null ? void 0 : parent.tagName.toLowerCase();
+    if (parentTag === "p" || parentTag === "div") {
+      const textContent = ((_a = parent == null ? void 0 : parent.textContent) == null ? void 0 : _a.trim()) || "";
+      if (textContent === "") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function detectClassBasedAlignment(element) {
+  let current = element;
+  while (current && current !== document.body) {
+    const className = current.className || "";
+    if (className.includes("image-style-align-right") || className.includes("image-style-side")) {
+      return "right";
+    }
+    if (className.includes("image-style-align-left")) {
+      return "left";
+    }
+    if (className.includes("image-style-align-center") || className.includes("image_resized") && !className.includes("align"))
+      ;
+    if (className.includes("align-right")) {
+      return "right";
+    }
+    if (className.includes("align-left")) {
+      return "left";
+    }
+    if (className.includes("align-center")) {
+      return "center";
+    }
+    if (className.includes("float-right") || className.includes("pull-right")) {
+      return "right";
+    }
+    if (className.includes("float-left") || className.includes("pull-left")) {
+      return "left";
+    }
+    try {
+      const computed = window.getComputedStyle(current);
+      if (computed.float === "right") {
+        return "right";
+      }
+      if (computed.float === "left") {
+        return "left";
+      }
+    } catch {
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+function detectImageAlignment(imgElement) {
+  const classAlignment = detectClassBasedAlignment(imgElement);
+  if (classAlignment) {
+    return classAlignment;
+  }
+  const cssAlignment = detectCSSAlignment(imgElement);
+  if (cssAlignment) {
+    return cssAlignment;
+  }
+  if (shouldCenterImage(imgElement)) {
+    return "center";
+  }
+  return "left";
+}
+function alignmentToPosition(alignment) {
+  switch (alignment) {
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    default:
+      return "none";
+  }
+}
+function isFloatAlignment(alignment) {
+  return alignment === "left" || alignment === "right";
+}
+const IS_BOLD = 1;
+const IS_ITALIC = 2;
+const IS_STRIKETHROUGH = 4;
+const IS_UNDERLINE = 8;
+const IS_CODE = 16;
+const IS_SUBSCRIPT = 32;
+const IS_SUPERSCRIPT = 64;
+const IS_HIGHLIGHT = 128;
+function detectCKEditorSource(html) {
+  return html.includes('class="image"') || // CKEditor's figure class for images
+  html.includes('class="image ') || html.includes("image-style-") || // CKEditor's image alignment classes
+  html.includes("ck-") || // CKEditor's internal classes
+  html.includes("data-cke-");
+}
+const DEFAULT_HEADING_STYLES = {
+  h1: { fontSize: "36px", lineHeight: "1.2" },
+  h2: { fontSize: "29px", lineHeight: "1.25" },
+  h3: { fontSize: "24px", lineHeight: "1.3" },
+  h4: { fontSize: "20px", lineHeight: "1.35" },
+  h5: { fontSize: "17px", lineHeight: "1.4" },
+  h6: { fontSize: "15px", lineHeight: "1.45" }
+};
+const DEFAULT_PARAGRAPH_FONT_SIZE = "16px";
+const DEFAULT_PARAGRAPH_LINE_HEIGHT = "1.6";
+const MIN_HEADING_FONT_SIZES = {
+  h1: 24,
+  h2: 20,
+  h3: 18,
+  h4: 16,
+  h5: 14,
+  h6: 12
+};
+function parseStyleString(styleStr) {
+  const result = {};
+  if (!styleStr)
+    return result;
+  const parts = styleStr.split(";");
+  for (const part of parts) {
+    const colonIndex = part.indexOf(":");
+    if (colonIndex > 0) {
+      const key = part.substring(0, colonIndex).trim().toLowerCase();
+      const value = part.substring(colonIndex + 1).trim();
+      if (key && value) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function getStyleInfoFromElement(element) {
+  const result = {
+    format: 0,
+    fontFamily: "",
+    fontSize: "",
+    lineHeight: "",
+    letterSpacing: "",
+    wordSpacing: "",
+    color: "",
+    backgroundColor: ""
+  };
+  let current = element;
+  const elementsStack = [];
+  while (current && current !== document.body) {
+    elementsStack.push(current);
+    current = current.parentElement;
+  }
+  for (let i2 = elementsStack.length - 1; i2 >= 0; i2--) {
+    const el = elementsStack[i2];
+    const tag = el.tagName.toLowerCase();
+    if (tag === "strong" || tag === "b")
+      result.format |= IS_BOLD;
+    if (tag === "em" || tag === "i")
+      result.format |= IS_ITALIC;
+    if (tag === "u")
+      result.format |= IS_UNDERLINE;
+    if (tag === "s" || tag === "strike" || tag === "del")
+      result.format |= IS_STRIKETHROUGH;
+    if (tag === "code")
+      result.format |= IS_CODE;
+    if (tag === "sub")
+      result.format |= IS_SUBSCRIPT;
+    if (tag === "sup")
+      result.format |= IS_SUPERSCRIPT;
+    if (tag === "mark")
+      result.format |= IS_HIGHLIGHT;
+    const styleAttr = el.getAttribute("style") || "";
+    const parsedStyle = parseStyleString(styleAttr);
+    const style = el.style;
+    const fontWeight = parsedStyle["font-weight"] || style.fontWeight;
+    if (fontWeight === "bold" || fontWeight === "700" || parseInt(fontWeight || "0") >= 700) {
+      result.format |= IS_BOLD;
+    }
+    const fontStyle = parsedStyle["font-style"] || style.fontStyle;
+    if (fontStyle === "italic") {
+      result.format |= IS_ITALIC;
+    }
+    const textDecoration = parsedStyle["text-decoration"] || style.textDecoration || "";
+    if (textDecoration.includes("underline")) {
+      result.format |= IS_UNDERLINE;
+    }
+    if (textDecoration.includes("line-through")) {
+      result.format |= IS_STRIKETHROUGH;
+    }
+    const fontFamily = parsedStyle["font-family"] || style.fontFamily;
+    if (fontFamily) {
+      const family = fontFamily.split(",")[0].trim().replace(/["']/g, "");
+      if (family && family !== "inherit" && family !== "initial") {
+        result.fontFamily = family;
+      }
+    }
+    const fontSize = parsedStyle["font-size"] || style.fontSize;
+    if (fontSize && fontSize !== "inherit" && fontSize !== "initial") {
+      result.fontSize = fontSize;
+    }
+    const lineHeight = parsedStyle["line-height"] || style.lineHeight;
+    if (lineHeight && lineHeight !== "inherit" && lineHeight !== "initial" && lineHeight !== "normal") {
+      result.lineHeight = lineHeight;
+    }
+    const letterSpacing = parsedStyle["letter-spacing"] || style.letterSpacing;
+    if (letterSpacing && letterSpacing !== "inherit" && letterSpacing !== "initial" && letterSpacing !== "normal") {
+      result.letterSpacing = letterSpacing;
+    }
+    const wordSpacing = parsedStyle["word-spacing"] || style.wordSpacing;
+    if (wordSpacing && wordSpacing !== "inherit" && wordSpacing !== "initial" && wordSpacing !== "normal") {
+      result.wordSpacing = wordSpacing;
+    }
+    const color = parsedStyle["color"] || style.color;
+    if (color && color !== "inherit" && color !== "initial") {
+      result.color = color;
+    }
+    const bgColor = parsedStyle["background-color"] || parsedStyle["background"] || style.backgroundColor;
+    if (bgColor && bgColor !== "inherit" && bgColor !== "initial" && bgColor !== "transparent" && bgColor !== "rgba(0, 0, 0, 0)") {
+      result.backgroundColor = bgColor;
+    }
+  }
+  try {
+    const computedStyle = window.getComputedStyle(element);
+    if (!result.fontFamily && computedStyle.fontFamily) {
+      const fontFamily = computedStyle.fontFamily.split(",")[0].trim().replace(/["']/g, "");
+      const genericFonts = ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "-apple-system", "BlinkMacSystemFont"];
+      if (fontFamily && !genericFonts.includes(fontFamily)) {
+        result.fontFamily = fontFamily;
+      }
+    }
+    if (!result.fontSize && computedStyle.fontSize && computedStyle.fontSize !== "16px") {
+      result.fontSize = computedStyle.fontSize;
+    }
+    if (!result.lineHeight && computedStyle.lineHeight && computedStyle.lineHeight !== "normal") {
+      const lineHeightValue = computedStyle.lineHeight;
+      if (lineHeightValue && !lineHeightValue.endsWith("px")) {
+        result.lineHeight = lineHeightValue;
+      } else if (lineHeightValue && result.fontSize) {
+        result.lineHeight = lineHeightValue;
+      } else if (lineHeightValue) {
+        result.lineHeight = lineHeightValue;
+      }
+    }
+    if (!result.letterSpacing && computedStyle.letterSpacing && computedStyle.letterSpacing !== "normal" && computedStyle.letterSpacing !== "0px") {
+      result.letterSpacing = computedStyle.letterSpacing;
+    }
+    if (!result.wordSpacing && computedStyle.wordSpacing && computedStyle.wordSpacing !== "normal" && computedStyle.wordSpacing !== "0px") {
+      result.wordSpacing = computedStyle.wordSpacing;
+    }
+    if (!result.color && computedStyle.color) {
+      const color = computedStyle.color;
+      if (color !== "rgb(0, 0, 0)" && color !== "#000000" && color !== "black") {
+        result.color = color;
+      }
+    }
+    if (!result.backgroundColor && computedStyle.backgroundColor) {
+      const bgColor = computedStyle.backgroundColor;
+      if (bgColor !== "rgba(0, 0, 0, 0)" && bgColor !== "transparent") {
+        result.backgroundColor = bgColor;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function buildStyleString(info) {
+  const styles = [];
+  if (info.fontFamily)
+    styles.push(`font-family: ${info.fontFamily}`);
+  if (info.fontSize)
+    styles.push(`font-size: ${info.fontSize}`);
+  if (info.lineHeight)
+    styles.push(`line-height: ${info.lineHeight}`);
+  if (info.letterSpacing)
+    styles.push(`letter-spacing: ${info.letterSpacing}`);
+  if (info.wordSpacing)
+    styles.push(`word-spacing: ${info.wordSpacing}`);
+  if (info.color)
+    styles.push(`color: ${info.color}`);
+  if (info.backgroundColor)
+    styles.push(`background-color: ${info.backgroundColor}`);
+  return styles.join("; ");
+}
+function createStyledTextNode(text, parentElement) {
+  const textNode = $createTextNode(text);
+  const styleInfo = getStyleInfoFromElement(parentElement);
+  if (styleInfo.format) {
+    textNode.setFormat(styleInfo.format);
+  }
+  const styleString = buildStyleString(styleInfo);
+  if (styleString) {
+    textNode.setStyle(styleString);
+  }
+  return textNode;
+}
+const defaultPasteContext = {
+  isCKEditor: false
+};
+let currentPasteContext = defaultPasteContext;
+function processNode(domNode, parentElement = null) {
+  var _a;
+  const results = [];
+  if (domNode.nodeType === Node.TEXT_NODE) {
+    const text = domNode.textContent || "";
+    if (text && parentElement) {
+      const hasNonWhitespace = text.trim().length > 0;
+      const isSignificantWhitespace = /\s/.test(text) && !hasNonWhitespace;
+      if (hasNonWhitespace || isSignificantWhitespace) {
+        const normalizedText = text.replace(/\s+/g, " ");
+        const textNode = createStyledTextNode(normalizedText, parentElement);
+        results.push(textNode);
+      }
+    }
+    return results;
+  }
+  if (domNode.nodeType !== Node.ELEMENT_NODE) {
+    return results;
+  }
+  const element = domNode;
+  const tagName = element.tagName.toLowerCase();
+  switch (tagName) {
+    case "p":
+    case "div": {
+      const paragraph = $createParagraphNode();
+      const styleInfo = getStyleInfoFromElement(element);
+      const hasExplicitFontSize = styleInfo.fontSize && styleInfo.fontSize !== "16px";
+      if (!hasExplicitFontSize && currentPasteContext.isCKEditor) {
+        processChildrenWithStyle(element, paragraph, {
+          fontSize: DEFAULT_PARAGRAPH_FONT_SIZE,
+          lineHeight: DEFAULT_PARAGRAPH_LINE_HEIGHT
+        });
+      } else {
+        processChildren(element, paragraph);
+      }
+      if (paragraph.getChildrenSize() > 0 || tagName === "p") {
+        results.push(paragraph);
+      }
+      break;
+    }
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6": {
+      const heading = $createHeadingNode(tagName);
+      const styleInfo = getStyleInfoFromElement(element);
+      let hasAppropriateFontSize = false;
+      if (styleInfo.fontSize) {
+        const fontSizeValue = parseFloat(styleInfo.fontSize);
+        const minExpectedSize = MIN_HEADING_FONT_SIZES[tagName] || 14;
+        if (fontSizeValue >= minExpectedSize) {
+          hasAppropriateFontSize = true;
+        }
+      }
+      if (!hasAppropriateFontSize) {
+        const defaultStyles = DEFAULT_HEADING_STYLES[tagName];
+        if (defaultStyles) {
+          processChildrenWithStyle(element, heading, defaultStyles);
+        } else {
+          processChildren(element, heading);
+        }
+      } else {
+        processChildren(element, heading);
+      }
+      results.push(heading);
+      break;
+    }
+    case "ul":
+    case "ol": {
+      const listType = tagName === "ul" ? "bullet" : "number";
+      const list = $createListNode(listType);
+      const listItems = element.querySelectorAll(":scope > li");
+      listItems.forEach((li) => {
+        const listItem = $createListItemNode();
+        processChildren(li, listItem);
+        list.append(listItem);
+      });
+      if (list.getChildrenSize() > 0) {
+        results.push(list);
+      }
+      break;
+    }
+    case "li": {
+      const list = $createListNode("bullet");
+      const listItem = $createListItemNode();
+      processChildren(element, listItem);
+      list.append(listItem);
+      results.push(list);
+      break;
+    }
+    case "blockquote": {
+      const quote = $createQuoteNode();
+      processChildren(element, quote);
+      results.push(quote);
+      break;
+    }
+    case "a": {
+      const href = element.getAttribute("href") || "";
+      if (href) {
+        const linkNode = $createLinkNode(href, { target: "_blank", rel: "noopener" });
+        processChildren(element, linkNode);
+        results.push(linkNode);
+      } else {
+        const children = processChildren(element);
+        results.push(...children);
+      }
+      break;
+    }
+    case "img": {
+      const src = element.getAttribute("src") || "";
+      if (src && !src.startsWith("file:///")) {
+        const alt = element.getAttribute("alt") || "";
+        const width = parseInt(element.getAttribute("width") || "0") || void 0;
+        const height = parseInt(element.getAttribute("height") || "0") || void 0;
+        const alignment = detectImageAlignment(element);
+        const position = alignmentToPosition(alignment);
+        const imageNode = $createImageNode({
+          src,
+          altText: alt,
+          width,
+          height,
+          position: isFloatAlignment(alignment) ? position : "none"
+        });
+        if (alignment === "center") {
+          const paragraph = $createParagraphNode();
+          paragraph.setFormat("center");
+          paragraph.append(imageNode);
+          results.push(paragraph);
+        } else {
+          results.push(imageNode);
+        }
+      }
+      break;
+    }
+    case "br": {
+      results.push($createLineBreakNode());
+      break;
+    }
+    case "figure": {
+      const img = element.querySelector("img");
+      const figureAlignment = detectClassBasedAlignment(element);
+      const alignment = figureAlignment || (img ? detectImageAlignment(img) : "left");
+      const position = alignmentToPosition(alignment);
+      const isFloat = isFloatAlignment(alignment);
+      const figcaption = element.querySelector("figcaption");
+      const captionText = ((_a = figcaption == null ? void 0 : figcaption.textContent) == null ? void 0 : _a.trim()) || "";
+      if (img) {
+        const src = img.getAttribute("src") || "";
+        if (src && !src.startsWith("file:///")) {
+          const alt = img.getAttribute("alt") || "";
+          const width = parseInt(img.getAttribute("width") || "0") || void 0;
+          const height = parseInt(img.getAttribute("height") || "0") || void 0;
+          const imageNode = $createImageNode({
+            src,
+            altText: alt,
+            width,
+            height,
+            position: isFloat ? position : "none"
+          });
+          if (alignment === "center") {
+            const paragraph = $createParagraphNode();
+            paragraph.setFormat("center");
+            paragraph.append(imageNode);
+            results.push(paragraph);
+            if (captionText) {
+              const captionPara = $createParagraphNode();
+              captionPara.setFormat("center");
+              const textNode = $createTextNode(captionText);
+              textNode.setFormat(IS_ITALIC);
+              captionPara.append(textNode);
+              results.push(captionPara);
+            }
+          } else {
+            if (captionText) {
+              const paragraph = $createParagraphNode();
+              paragraph.setFormat(alignment === "right" ? "right" : "left");
+              paragraph.append(imageNode);
+              paragraph.append($createLineBreakNode());
+              const captionNode = $createTextNode(captionText);
+              captionNode.setFormat(IS_ITALIC);
+              paragraph.append(captionNode);
+              results.push(paragraph);
+            } else {
+              results.push(imageNode);
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "strong":
+    case "b":
+    case "em":
+    case "i":
+    case "u":
+    case "s":
+    case "strike":
+    case "del":
+    case "code":
+    case "sub":
+    case "sup":
+    case "mark":
+    case "span":
+    case "font": {
+      const children = processChildren(element);
+      results.push(...children);
+      break;
+    }
+    case "script":
+    case "style":
+    case "meta":
+    case "link":
+    case "head":
+    case "title":
+    case "noscript":
+      break;
+    case "table":
+    case "tbody":
+    case "thead":
+    case "tfoot":
+    case "tr":
+    case "td":
+    case "th": {
+      break;
+    }
+    default: {
+      const children = processChildren(element);
+      results.push(...children);
+    }
+  }
+  return results;
+}
+function processChildren(element, parentNode) {
+  const results = [];
+  const childNodes = element.childNodes;
+  for (let i2 = 0; i2 < childNodes.length; i2++) {
+    const child = childNodes[i2];
+    const nodes = processNode(child, element);
+    if (parentNode) {
+      nodes.forEach((node) => parentNode.append(node));
+    } else {
+      results.push(...nodes);
+    }
+  }
+  return results;
+}
+function processChildrenWithStyle(element, parentNode, defaultStyles) {
+  const childNodes = element.childNodes;
+  for (let i2 = 0; i2 < childNodes.length; i2++) {
+    const child = childNodes[i2];
+    if (child.nodeType === Node.TEXT_NODE) {
+      const text = child.textContent || "";
+      if (text) {
+        const hasNonWhitespace = text.trim().length > 0;
+        const isSignificantWhitespace = /\s/.test(text) && !hasNonWhitespace;
+        if (hasNonWhitespace || isSignificantWhitespace) {
+          const normalizedText = text.replace(/\s+/g, " ");
+          const textNode = $createTextNode(normalizedText);
+          const styleInfo = getStyleInfoFromElement(element);
+          if (styleInfo.format) {
+            textNode.setFormat(styleInfo.format);
+          }
+          const styles = [];
+          if (styleInfo.fontFamily) {
+            styles.push(`font-family: ${styleInfo.fontFamily}`);
+          }
+          const usingDefaultFontSize = !styleInfo.fontSize && defaultStyles.fontSize;
+          if (styleInfo.fontSize) {
+            styles.push(`font-size: ${styleInfo.fontSize}`);
+          } else if (defaultStyles.fontSize) {
+            styles.push(`font-size: ${defaultStyles.fontSize}`);
+          }
+          if (styleInfo.lineHeight) {
+            const isAbsoluteLineHeight = styleInfo.lineHeight.endsWith("px");
+            if (usingDefaultFontSize && isAbsoluteLineHeight) {
+              styles.push(`line-height: ${defaultStyles.lineHeight}`);
+            } else {
+              styles.push(`line-height: ${styleInfo.lineHeight}`);
+            }
+          } else if (defaultStyles.lineHeight) {
+            styles.push(`line-height: ${defaultStyles.lineHeight}`);
+          }
+          if (styleInfo.letterSpacing) {
+            styles.push(`letter-spacing: ${styleInfo.letterSpacing}`);
+          }
+          if (styleInfo.wordSpacing) {
+            styles.push(`word-spacing: ${styleInfo.wordSpacing}`);
+          }
+          if (styleInfo.color) {
+            styles.push(`color: ${styleInfo.color}`);
+          }
+          if (styleInfo.backgroundColor) {
+            styles.push(`background-color: ${styleInfo.backgroundColor}`);
+          }
+          if (styles.length > 0) {
+            textNode.setStyle(styles.join("; "));
+          }
+          parentNode.append(textNode);
+        }
+      }
+    } else {
+      const nodes = processNode(child, element);
+      nodes.forEach((node) => {
+        if ($isTextNode(node)) {
+          const currentStyle = node.getStyle();
+          const hasFontSize = currentStyle.includes("font-size");
+          const hasLineHeight = currentStyle.includes("line-height");
+          if (!hasFontSize || !hasLineHeight) {
+            const newStyles = currentStyle ? [currentStyle] : [];
+            if (!hasFontSize && defaultStyles.fontSize) {
+              newStyles.push(`font-size: ${defaultStyles.fontSize}`);
+            }
+            if (!hasFontSize && hasLineHeight) {
+              const lineHeightMatch = currentStyle.match(/line-height:\s*([^;]+)/);
+              if (lineHeightMatch && lineHeightMatch[1].trim().endsWith("px")) {
+                const filteredStyles = newStyles.filter((s2) => !s2.includes("line-height"));
+                filteredStyles.push(`line-height: ${defaultStyles.lineHeight}`);
+                node.setStyle(filteredStyles.join("; "));
+                parentNode.append(node);
+                return;
+              }
+            }
+            if (!hasLineHeight && defaultStyles.lineHeight) {
+              newStyles.push(`line-height: ${defaultStyles.lineHeight}`);
+            }
+            node.setStyle(newStyles.join("; "));
+          }
+        }
+        parentNode.append(node);
+      });
+    }
+  }
+}
+function wrapFloatedImagesInParagraphs(nodes) {
+  return nodes.map((node) => {
+    if ($isImageNode(node)) {
+      const position = node.getPosition();
+      if (position === "left" || position === "right") {
+        const wrapper = $createParagraphNode();
+        wrapper.append(node);
+        return wrapper;
+      }
+    }
+    return node;
+  });
+}
+function createStyledDocument(html) {
+  const container = document.createElement("div");
+  container.style.cssText = "position: absolute; left: -9999px; top: -9999px; visibility: hidden;";
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const styleTags = doc.querySelectorAll("style");
+  const injectedStyles = [];
+  styleTags.forEach((styleTag) => {
+    const newStyle = document.createElement("style");
+    newStyle.textContent = styleTag.textContent;
+    document.head.appendChild(newStyle);
+    injectedStyles.push(newStyle);
+  });
+  container.innerHTML = doc.body.innerHTML;
+  document.body.appendChild(container);
+  const cleanup = () => {
+    injectedStyles.forEach((style) => style.remove());
+    container.remove();
+  };
+  return { container, cleanup };
+}
+function convertHTMLToNodesWithStyles(html, editor) {
+  const isCKEditor = detectCKEditorSource(html);
+  currentPasteContext = {
+    isCKEditor
+  };
+  const { container, cleanup } = createStyledDocument(html);
+  try {
+    const customNodes = processNode(container, null);
+    const filteredCustomNodes = customNodes.filter((node) => {
+      if (node instanceof ParagraphNode) {
+        return node.getTextContent().trim().length > 0 || node.getChildrenSize() > 0;
+      }
+      return true;
+    });
+    if (filteredCustomNodes.length > 0) {
+      const hasTables = html.includes("<table");
+      if (hasTables) {
+        const parser2 = new DOMParser();
+        const doc2 = parser2.parseFromString(html, "text/html");
+        const lexicalNodes = $generateNodesFromDOM(editor, doc2);
+        const mergedNodes = [];
+        let customIndex = 0;
+        lexicalNodes.forEach((lexicalNode) => {
+          const nodeType = lexicalNode.getType();
+          if (nodeType === "table") {
+            mergedNodes.push(lexicalNode);
+          } else if (customIndex < filteredCustomNodes.length) {
+            mergedNodes.push(filteredCustomNodes[customIndex]);
+            customIndex++;
+          }
+        });
+        while (customIndex < filteredCustomNodes.length) {
+          mergedNodes.push(filteredCustomNodes[customIndex]);
+          customIndex++;
+        }
+        return wrapFloatedImagesInParagraphs(mergedNodes.length > 0 ? mergedNodes : filteredCustomNodes);
+      }
+      return wrapFloatedImagesInParagraphs(filteredCustomNodes);
+    }
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    return $generateNodesFromDOM(editor, doc);
+  } finally {
+    cleanup();
+    currentPasteContext = defaultPasteContext;
+  }
+}
 function RichTextPastePlugin() {
   const [editor] = useLexicalComposerContext();
   useEffect$1(() => {
@@ -31083,192 +32314,55 @@ function RichTextPastePlugin() {
         const clipboardData = event.clipboardData;
         if (!clipboardData)
           return false;
+        const files = clipboardData.files;
+        if (files && files.length > 0) {
+          const hasImages = Array.from(files).some(
+            (file) => file.type.startsWith("image/")
+          );
+          if (hasImages) {
+            return false;
+          }
+        }
         const htmlContent = clipboardData.getData("text/html");
         const plainText = clipboardData.getData("text/plain");
         if (htmlContent) {
           event.preventDefault();
-          handleHtmlPaste(htmlContent);
-          return true;
-        } else if (plainText) {
-          event.preventDefault();
-          handleMarkdownPaste(plainText);
-          return true;
-        }
-        return false;
-      },
-      COMMAND_PRIORITY_LOW
-    );
-  }, [editor]);
-  const handleHtmlPaste = (htmlContent) => {
-    editor.update(() => {
-      const selection = $getSelection();
-      if ($isRangeSelection(selection)) {
-        const tempDiv = document.createElement("div");
-        tempDiv.innerHTML = htmlContent;
-        const processNode = (node) => {
-          if (node.nodeType === Node.TEXT_NODE) {
-            const text = node.textContent || "";
-            const textNode = $createTextNode(text);
-            if (node.parentElement) {
-              if (node.parentElement.tagName === "STRONG" || node.parentElement.tagName === "B") {
-                textNode.setFormat("bold");
-              }
-              if (node.parentElement.tagName === "EM" || node.parentElement.tagName === "I") {
-                textNode.setFormat("italic");
-              }
-              if (node.parentElement.tagName === "U") {
-                textNode.setFormat("underline");
-              }
-              if (node.parentElement.tagName === "CODE") {
-                textNode.setFormat("code");
-              }
-              if (node.parentElement.tagName === "STRIKE" || node.parentElement.tagName === "S") {
-                textNode.setFormat("strikethrough");
-              }
-              if (node.parentElement.tagName === "SUB") {
-                textNode.setFormat("subscript");
-              }
-              if (node.parentElement.tagName === "SUP") {
-                textNode.setFormat("superscript");
-              }
-            }
-            return textNode;
-          }
-          if (node.nodeType === Node.ELEMENT_NODE) {
-            const element = node;
-            if (element.tagName === "UL" || element.tagName === "OL") {
-              const listNode = $createListNode(
-                element.tagName === "UL" ? "bullet" : "number"
-              );
-              Array.from(element.childNodes).forEach((child) => {
-                if (child.nodeType === Node.ELEMENT_NODE && child.tagName === "LI") {
-                  const listItemNode = $createListItemNode();
-                  Array.from(child.childNodes).forEach((grandChild) => {
-                    const processedNode = processNode(grandChild);
-                    if (processedNode) {
-                      if (Array.isArray(processedNode)) {
-                        processedNode.forEach(
-                          (node2) => listItemNode.append(node2)
-                        );
-                      } else {
-                        listItemNode.append(processedNode);
-                      }
+          editor.update(
+            () => {
+              const selection = $getSelection();
+              if (!$isRangeSelection(selection))
+                return;
+              try {
+                const nodes = convertHTMLToNodesWithStyles(htmlContent, editor);
+                if (nodes.length > 0) {
+                  const filteredNodes = nodes.filter((node) => {
+                    if (node instanceof ParagraphNode) {
+                      const textContent = node.getTextContent();
+                      const hasChildren = node.getChildrenSize() > 0;
+                      return textContent.trim().length > 0 || hasChildren;
                     }
+                    return true;
                   });
-                  listNode.append(listItemNode);
-                }
-              });
-              return listNode;
-            }
-            if (element.tagName.match(/^H[1-6]$/)) {
-              const headingNode = $createHeadingNode(
-                element.tagName.toLowerCase()
-              );
-              Array.from(element.childNodes).forEach((child) => {
-                const processedNode = processNode(child);
-                if (processedNode) {
-                  if (Array.isArray(processedNode)) {
-                    processedNode.forEach((node2) => headingNode.append(node2));
-                  } else {
-                    headingNode.append(processedNode);
+                  if (filteredNodes.length > 0) {
+                    selection.insertNodes(filteredNodes);
                   }
                 }
-              });
-              return headingNode;
-            }
-            if (element.tagName === "P") {
-              const paragraphNode = $createParagraphNode();
-              Array.from(element.childNodes).forEach((child) => {
-                const processedNode = processNode(child);
-                if (processedNode) {
-                  if (Array.isArray(processedNode)) {
-                    processedNode.forEach((node2) => paragraphNode.append(node2));
-                  } else {
-                    paragraphNode.append(processedNode);
-                  }
-                }
-              });
-              return paragraphNode;
-            }
-            const nodes = [];
-            Array.from(element.childNodes).forEach((child) => {
-              const processedNode = processNode(child);
-              if (processedNode) {
-                if (Array.isArray(processedNode)) {
-                  nodes.push(...processedNode);
-                } else {
-                  nodes.push(processedNode);
+              } catch (error) {
+                console.error("Error during HTML paste:", error);
+                if (plainText) {
+                  selection.insertRawText(plainText);
                 }
               }
-            });
-            return nodes;
-          }
-          return null;
-        };
-        const processedNodes = processNode(tempDiv);
-        if (processedNodes) {
-          if (Array.isArray(processedNodes)) {
-            selection.insertNodes(processedNodes);
-          } else {
-            selection.insertNodes([processedNodes]);
-          }
+            },
+            { tag: "paste" }
+          );
+          return true;
         }
-      }
-    });
-  };
-  const handleMarkdownPaste = (text) => {
-    editor.update(() => {
-      const selection = $getSelection();
-      if ($isRangeSelection(selection)) {
-        const lines = text.split("\n");
-        const nodes = [];
-        lines.forEach((line) => {
-          const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-          if (headingMatch) {
-            const level = headingMatch[1].length;
-            const content = headingMatch[2];
-            const headingNode = $createHeadingNode(
-              `h${level}`
-            );
-            headingNode.append($createTextNode(content));
-            nodes.push(headingNode);
-            return;
-          }
-          const bulletMatch = line.match(/^-\s+(.+)$/);
-          if (bulletMatch) {
-            const listNode = $createListNode("bullet");
-            const listItemNode = $createListItemNode();
-            listItemNode.append($createTextNode(bulletMatch[1]));
-            listNode.append(listItemNode);
-            nodes.push(listNode);
-            return;
-          }
-          const numberedMatch = line.match(/^\d+\.\s+(.+)$/);
-          if (numberedMatch) {
-            const listNode = $createListNode("number");
-            const listItemNode = $createListItemNode();
-            listItemNode.append($createTextNode(numberedMatch[1]));
-            listNode.append(listItemNode);
-            nodes.push(listNode);
-            return;
-          }
-          const textNode = $createTextNode(line);
-          if (line.includes("**") || line.includes("__")) {
-            textNode.setFormat("bold");
-          }
-          if (line.includes("*") || line.includes("_")) {
-            textNode.setFormat("italic");
-          }
-          if (line.includes("***") || line.includes("___")) {
-            textNode.setFormat("bold");
-            textNode.setFormat("italic");
-          }
-          nodes.push(textNode);
-        });
-        selection.insertNodes(nodes);
-      }
-    });
-  };
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+  }, [editor]);
   return null;
 }
 function getOptionMeta(label) {
@@ -35248,6 +36342,95 @@ function TableImageAutoResizePlugin() {
   }, [editor]);
   return null;
 }
+const DEFAULT_SYNC_INTERVAL = 2 * 60 * 1e3;
+const UsageTrackingPlugin = ({
+  licenseKey,
+  syncIntervalMs = DEFAULT_SYNC_INTERVAL
+}) => {
+  const [editor] = useLexicalComposerContext();
+  const lastCountRef = useRef({ characters: 0, words: 0 });
+  const pendingDeltaRef = useRef({ characters: 0, words: 0 });
+  const isSyncingRef = useRef(false);
+  const syncToBackend = useCallback(async () => {
+    if (!licenseKey || isSyncingRef.current)
+      return;
+    const { characters, words } = pendingDeltaRef.current;
+    if (characters === 0 && words === 0)
+      return;
+    isSyncingRef.current = true;
+    try {
+      await backendAPI.post("/api/analytics/track-usage", {
+        licenseKey,
+        characters,
+        words
+      });
+      pendingDeltaRef.current = { characters: 0, words: 0 };
+    } catch (error) {
+      console.error("Failed to sync usage stats:", error);
+    } finally {
+      isSyncingRef.current = false;
+    }
+  }, [licenseKey]);
+  useEffect$1(() => {
+    if (!licenseKey)
+      return;
+    const unregister = editor.registerUpdateListener(({ editorState }) => {
+      editorState.read(() => {
+        const root2 = $getRoot();
+        const text = root2.getTextContent();
+        const currentWords = text.trim().split(/\s+/).filter((word) => word.length > 0).length;
+        const currentCharacters = text.replace(/\s/g, "").length;
+        const deltaCharacters = Math.max(
+          0,
+          currentCharacters - lastCountRef.current.characters
+        );
+        const deltaWords = Math.max(
+          0,
+          currentWords - lastCountRef.current.words
+        );
+        lastCountRef.current = {
+          characters: currentCharacters,
+          words: currentWords
+        };
+        if (deltaCharacters > 0 || deltaWords > 0) {
+          pendingDeltaRef.current.characters += deltaCharacters;
+          pendingDeltaRef.current.words += deltaWords;
+        }
+      });
+    });
+    const syncInterval = setInterval(syncToBackend, syncIntervalMs);
+    const handleBeforeUnload = () => {
+      const { characters, words } = pendingDeltaRef.current;
+      if (characters > 0 || words > 0) {
+        const data = JSON.stringify({
+          licenseKey,
+          characters,
+          words
+        });
+        const baseURL = backendAPI.defaults.baseURL || "";
+        navigator.sendBeacon(
+          `${baseURL}/api/analytics/track-usage`,
+          new Blob([data], { type: "application/json" })
+        );
+      }
+    };
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        syncToBackend();
+      }
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      unregister();
+      clearInterval(syncInterval);
+      syncToBackend();
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [editor, licenseKey, syncToBackend, syncIntervalMs]);
+  return null;
+};
 const WordCountPlugin = () => {
   const [editor] = useLexicalComposerContext();
   const [stats, setStats] = useState$1({
@@ -35485,11 +36668,12 @@ function applyGenericSafeStyles(container) {
       }
     });
   };
-  const fontReset = 'font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif; font-size: 14px; line-height: 1.5;';
-  addStyle(
-    "table, p, span, li, td, th, div, h1, h2, h3, h4, h5, h6",
-    fontReset
-  );
+  const defaultFontFamily = "Arial, sans-serif";
+  const selectors = "table, p, span, li, td, th, div, h1, h2, h3, h4, h5, h6";
+  addStyle(selectors, "line-height: 1.5;");
+  addStyleIfNotSet(selectors, "font-family", defaultFontFamily);
+  addStyleIfNotSet("table, p, span, li, td, th, div", "font-size", "16px");
+  addStyle("p", "margin: 0 0 1em 0;");
   addStyle("th p, td p", "margin: 0; padding: 0;");
   addStyle(
     "table",
@@ -35501,7 +36685,34 @@ function applyGenericSafeStyles(container) {
   );
   addStyleIfNotSet("th", "background-color", "#f8f9fa");
   addStyle("th", "font-weight: 600;");
-  addStyle("img", "max-width: 100%; height: auto; display: block;");
+  container.querySelectorAll("img").forEach((img) => {
+    const position = img.getAttribute("data-position");
+    const parent = img.parentElement;
+    img.style.cssText += "; max-width: 100%; height: auto;";
+    const hasCaption = parent && parent.tagName.toLowerCase() === "p" && parent.querySelector("em, i");
+    if (position === "left" || position === "right") {
+      const floatDir = position === "left" ? "left" : "right";
+      const marginDir = position === "left" ? "right" : "left";
+      if (hasCaption && parent) {
+        parent.style.cssText += `; float: ${floatDir}; clear: ${floatDir}; max-width: 50%; margin-${marginDir}: 1em; margin-bottom: 0.5em; text-align: center; background-color: #f5f5f5; padding: 0.5em; border-radius: 4px;`;
+        img.style.cssText += "; display: block; margin: 0 auto;";
+        const caption = parent.querySelector("em, i");
+        if (caption) {
+          caption.style.cssText += "; display: block; font-size: 0.85em; line-height: 1.4; color: #666; padding-top: 0.5em;";
+        }
+      } else {
+        img.style.cssText += `; float: ${floatDir}; clear: ${floatDir}; margin-${marginDir}: 1em; margin-bottom: 0.5em; max-width: 50%;`;
+      }
+    } else if (position === "full") {
+      img.style.cssText += "; display: block; width: 100%; margin: 1em 0;";
+    } else {
+      img.style.cssText += "; display: block;";
+      if (parent && parent.style.textAlign === "center") {
+        img.style.margin = "0 auto";
+      }
+    }
+    img.removeAttribute("data-position");
+  });
   addStyle("h1", "font-size: 2em; font-weight: bold; margin: 0.67em 0;");
   addStyle("h2", "font-size: 1.5em; font-weight: bold; margin: 0.75em 0;");
   addStyle("h3", "font-size: 1.17em; font-weight: bold; margin: 0.83em 0;");
@@ -35696,7 +36907,7 @@ function detectTableStylesFromInline(table) {
   return result;
 }
 function preprocessInitialContent(html) {
-  if (!html || !html.includes("<table")) {
+  if (!html) {
     return html;
   }
   const parser = new DOMParser();
@@ -35729,6 +36940,72 @@ function preprocessInitialContent(html) {
       table.classList.add("PlaygroundEditorTheme__table");
     }
   });
+  const images = doc.querySelectorAll("img");
+  images.forEach((img) => {
+    const parent = img.parentElement;
+    if (!parent)
+      return;
+    const imgFloat = img.style.float;
+    const parentFloat = parent.style.float;
+    const floatDir = imgFloat || parentFloat;
+    if (floatDir === "left" || floatDir === "right") {
+      img.setAttribute("data-position", floatDir);
+      if (parentFloat && parent.tagName.toLowerCase() === "p") {
+        parent.style.textAlign = floatDir;
+        parent.style.removeProperty("float");
+        parent.style.removeProperty("clear");
+        parent.style.removeProperty("max-width");
+        parent.style.removeProperty("background-color");
+        parent.style.removeProperty("padding");
+        parent.style.removeProperty("border-radius");
+      }
+    }
+  });
+  const styledElements = doc.querySelectorAll("span[style], b[style], strong[style], i[style], em[style]");
+  styledElements.forEach((el) => {
+    const htmlEl = el;
+    const style = htmlEl.style;
+    const relevantStyles = [];
+    if (style.fontFamily) {
+      const fontFamily = style.fontFamily.replace(/["']/g, "");
+      relevantStyles.push(`font-family: ${fontFamily}`);
+    }
+    if (style.fontSize) {
+      relevantStyles.push(`font-size: ${style.fontSize}`);
+    }
+    if (style.lineHeight) {
+      relevantStyles.push(`line-height: ${style.lineHeight}`);
+    }
+    if (style.color && style.color !== "rgb(0, 0, 0)") {
+      relevantStyles.push(`color: ${style.color}`);
+    }
+    if (style.backgroundColor && style.backgroundColor !== "rgba(0, 0, 0, 0)" && style.backgroundColor !== "transparent") {
+      relevantStyles.push(`background-color: ${style.backgroundColor}`);
+    }
+    if (style.letterSpacing && style.letterSpacing !== "normal") {
+      relevantStyles.push(`letter-spacing: ${style.letterSpacing}`);
+    }
+    if (style.wordSpacing && style.wordSpacing !== "normal") {
+      relevantStyles.push(`word-spacing: ${style.wordSpacing}`);
+    }
+    if (relevantStyles.length > 0) {
+      htmlEl.setAttribute("style", relevantStyles.join("; "));
+    }
+  });
+  const headings = doc.querySelectorAll("h1, h2, h3, h4, h5, h6");
+  headings.forEach((heading) => {
+    const tagName = heading.tagName.toLowerCase();
+    const className = `PlaygroundEditorTheme__${tagName}`;
+    if (!heading.classList.contains(className)) {
+      heading.classList.add(className);
+    }
+  });
+  const paragraphs = doc.querySelectorAll("p");
+  paragraphs.forEach((p2) => {
+    if (!p2.classList.contains("PlaygroundEditorTheme__paragraph")) {
+      p2.classList.add("PlaygroundEditorTheme__paragraph");
+    }
+  });
   return doc.body.innerHTML;
 }
 const useAutoExpandingHeight = ({
@@ -35799,6 +37076,8 @@ const useStyles = () => ({
     "cteditor-relative cteditor-min-h-[300px] cteditor-rounded-lg cteditor-p-3 !cteditor-h-auto cteditor-resize-none cteditor-outline-0 cteditor-content",
     // Ensure strong contrast in both themes
     "cteditor-text-foreground cteditor-bg-background",
+    // Default font: Arial 16px to match toolbar defaults and ensure WYSIWYG output
+    "cteditor-font-arial cteditor-text-base",
     // Caret and spacing
     "cteditor-caret-[#3b82f6] cteditor-p-0 cteditor-transition-all cteditor-duration-200",
     "cteditor-w-full ",
@@ -36137,7 +37416,8 @@ const ConfigurableEditor = ({
               ErrorBoundary: LexicalErrorBoundary
             }
           ),
-          /* @__PURE__ */ jsx(WordCountPlugin, {})
+          /* @__PURE__ */ jsx(WordCountPlugin, {}),
+          /* @__PURE__ */ jsx(UsageTrackingPlugin, { licenseKey: apiKey })
         ] }),
         /* @__PURE__ */ jsx(HtmlViewDisplay, {}),
         /* @__PURE__ */ jsx(AIRephrasePlugin, {}),
@@ -36227,9 +37507,9 @@ const ScopedEditorWrapper = ({
 }) => {
   return /* @__PURE__ */ jsx("div", { id: "ct-editor-f47ac10b", className: "cteditor-max-w-full", children: /* @__PURE__ */ jsx("div", { className: "cteditor-p-2 cteditor-w-full cteditor-relative", children }) });
 };
-const trackEditorLoad = async () => {
+const trackEditorLoad = async (licenseKey) => {
   try {
-    await backendAPI.post("/api/analytics/editor-load", {});
+    await backendAPI.post("/api/analytics/editor-load", { licenseKey });
   } catch {
   }
 };
@@ -36312,11 +37592,11 @@ const ConfigurableEditorWithAuth = ({
   }, [isAuthenticated, error]);
   useEffect$1(() => {
     console.log("isAuthenticated:", isAuthenticated);
-    if (isAuthenticated && !hasTrackedLoadRef.current) {
+    if (isAuthenticated && !hasTrackedLoadRef.current && apiKey) {
       hasTrackedLoadRef.current = true;
-      trackEditorLoad();
+      trackEditorLoad(apiKey);
     }
-  }, [isAuthenticated]);
+  }, [isAuthenticated, apiKey]);
   if (isLoading) {
     return /* @__PURE__ */ jsx(ScopedEditorWrapper, { children: /* @__PURE__ */ jsx(LoadingMessage, { children: /* @__PURE__ */ jsx("span", { children: "Loading editor..." }) }) });
   }
@@ -36375,4 +37655,4 @@ export {
   useHtmlView as u,
   verifyApiKey as v
 };
-//# sourceMappingURL=index-dbb526cd.js.map
+//# sourceMappingURL=index-23abcbd9.js.map