ct-rich-text-editor 1.3.27 → 1.3.28

package/dist/{index-d1d21414.js → index-0533674e.js}

@@ -24,15 +24,15 @@ 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, $getSelection, $isRangeSelection, ElementNode, $isRootOrShadowRoot, $createParagraphNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $insertNodes, $getNearestNodeFromDOMNode, isHTMLElement as isHTMLElement$1, TextNode, $getRoot, $createTextNode, $getNodeByKey, $isParagraphNode, $isTextNode, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, KEY_DOWN_COMMAND, COMMAND_PRIORITY_CRITICAL, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, $isElementNode, SELECTION_CHANGE_COMMAND, UNDO_COMMAND, REDO_COMMAND, KEY_SPACE_COMMAND, $isLineBreakNode, $createRangeSelection, $setSelection, COMMAND_PRIORITY_HIGH, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, KEY_ENTER_COMMAND, $createNodeSelection, $isNodeSelection, getDOMSelection, CLICK_COMMAND, PASTE_COMMAND, ParagraphNode, $createLineBreakNode, isDOMNode } from "lexical";
+import { createCommand, DecoratorNode, createEditor, $applyNodeReplacement, $insertNodes, $isRootOrShadowRoot, $createParagraphNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $getSelection, $isRangeSelection, $getNearestNodeFromDOMNode, isHTMLElement as isHTMLElement$1, TextNode, $getRoot, $createTextNode, $getNodeByKey, $isParagraphNode, $isTextNode, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, KEY_DOWN_COMMAND, COMMAND_PRIORITY_CRITICAL, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, $isElementNode, SELECTION_CHANGE_COMMAND, UNDO_COMMAND, REDO_COMMAND, KEY_SPACE_COMMAND, $isLineBreakNode, $createRangeSelection, $setSelection, COMMAND_PRIORITY_HIGH, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, KEY_ENTER_COMMAND, $createNodeSelection, $isNodeSelection, getDOMSelection, CLICK_COMMAND, KEY_BACKSPACE_COMMAND, 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 { ListNode, ListItemNode, $isListNode, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, $isListItemNode, $createListNode, $createListItemNode } from "@lexical/list";
 import { HeadingNode, QuoteNode, $isHeadingNode, $createHeadingNode, $createQuoteNode, DRAG_DROP_PASTE } from "@lexical/rich-text";
 import { $isAtNodeEnd, $selectAll, $patchStyleText, $setBlocksType, $getSelectionStyleValueForProperty, $isParentElementRTL } from "@lexical/selection";
-import { HorizontalRuleNode } from "@lexical/react/LexicalHorizontalRuleNode";
+import { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/react/LexicalHorizontalRuleNode";
 import DescriptionIcon from "@mui/icons-material/Description";
 import FolderZipIcon from "@mui/icons-material/FolderZip";
 import InsertChartIcon from "@mui/icons-material/InsertChart";
@@ -1481,7 +1481,7 @@ const AiTextTransform = async ({ content, apiKey }) => {
 const AI_ACTION_COMMAND = createCommand(
   "AI_ACTION_COMMAND"
 );
-const ImageView = React__default.lazy(() => import("./index-aa2e3927.js"));
+const ImageView = React__default.lazy(() => import("./index-c26337f6.js"));
 function isGoogleDocCheckboxImg(img) {
   return img.parentElement != null && img.parentElement.tagName === "LI" && img.previousSibling === null && img.getAttribute("aria-roledescription") === "checkbox";
 }
@@ -1493,14 +1493,14 @@ function $convertImageElement(domNode) {
   const { alt: altText, src, width, height } = img;
   const positionAttr = img.getAttribute("data-position");
   let position = "none";
-  if (positionAttr === "left" || positionAttr === "right" || positionAttr === "full") {
+  if (positionAttr === "left" || positionAttr === "right" || positionAttr === "full" || positionAttr === "inline-left" || positionAttr === "inline-center" || positionAttr === "inline-right") {
     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, position, key) {
+  constructor(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, originalPrompt, position, linkUrl, key) {
     super(key);
     __publicField(this, "__src");
     __publicField(this, "__altText");
@@ -1513,6 +1513,7 @@ class ImageNode extends DecoratorNode {
     __publicField(this, "__captionsEnabled");
     __publicField(this, "__originalPrompt");
     __publicField(this, "__position");
+    __publicField(this, "__linkUrl");
     this.__src = src;
     this.__altText = altText;
     this.__maxWidth = maxWidth;
@@ -1525,6 +1526,7 @@ class ImageNode extends DecoratorNode {
     this.__captionsEnabled = captionsEnabled || captionsEnabled === void 0;
     this.__originalPrompt = originalPrompt || "";
     this.__position = position || "none";
+    this.__linkUrl = linkUrl || "";
   }
   // to identify the image node and must unique too
   static getType() {
@@ -1543,12 +1545,13 @@ class ImageNode extends DecoratorNode {
       node.__captionsEnabled,
       node.__originalPrompt,
       node.__position,
+      node.__linkUrl,
       node.__key
     );
   }
   // importing to json format
   static importJSON(serializedNode) {
-    const { altText, height, width, maxWidth, caption, src, showCaption, originalPrompt, position } = serializedNode;
+    const { altText, height, width, maxWidth, caption, src, showCaption, originalPrompt, position, linkUrl } = serializedNode;
     const node = $createImageNode({
       altText,
       height,
@@ -1558,7 +1561,8 @@ class ImageNode extends DecoratorNode {
       width,
       originalPrompt: originalPrompt || "",
       // Default to empty string if undefined
-      position: position || "none"
+      position: position || "none",
+      linkUrl: linkUrl || ""
     });
     const nestedEditor = node.__caption;
     const editorState = nestedEditor.parseEditorState(caption.editorState);
@@ -1600,7 +1604,8 @@ class ImageNode extends DecoratorNode {
       version: 1,
       width: this.__width === "inherit" ? 0 : this.__width,
       originalPrompt: this.__originalPrompt,
-      position: this.__position
+      position: this.__position,
+      linkUrl: this.__linkUrl
     };
   }
   // setting width and height when resizing
@@ -1614,6 +1619,26 @@ class ImageNode extends DecoratorNode {
     const writable = this.getWritable();
     writable.__showCaption = showCaption;
   }
+  // Helper to get position-based CSS styles
+  getPositionStyles() {
+    const cursorStyle = "cursor: pointer;";
+    switch (this.__position) {
+      case "left":
+        return `float: left; margin-right: 1em; margin-bottom: 0.5em; max-width: 50%; display: block; ${cursorStyle}`;
+      case "right":
+        return `float: right; margin-left: 1em; margin-bottom: 0.5em; max-width: 50%; display: block; ${cursorStyle}`;
+      case "full":
+        return `display: block; width: 100%; margin: 1em 0; text-align: center; ${cursorStyle}`;
+      case "inline-left":
+        return `display: block; margin: 1em 0; text-align: left; ${cursorStyle}`;
+      case "inline-center":
+        return `display: block; margin: 1em 0; text-align: center; ${cursorStyle}`;
+      case "inline-right":
+        return `display: block; margin: 1em 0; text-align: right; ${cursorStyle}`;
+      default:
+        return "";
+    }
+  }
   // To create a dom representation of image view
   createDOM(config) {
     const span = document.createElement("span");
@@ -1622,24 +1647,18 @@ 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;";
+    const positionStyles = this.getPositionStyles();
+    if (positionStyles) {
+      span.style.cssText = positionStyles;
     }
     return span;
   }
   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;";
+      const positionStyles = this.getPositionStyles();
+      if (positionStyles) {
+        dom.style.cssText = positionStyles;
       }
     }
     return false;
@@ -1674,6 +1693,15 @@ class ImageNode extends DecoratorNode {
     const writable = this.getWritable();
     writable.__position = position;
   }
+  // to get the link URL (if image was wrapped in a link)
+  getLinkUrl() {
+    return this.__linkUrl;
+  }
+  // to set the link URL
+  setLinkUrl(linkUrl) {
+    const writable = this.getWritable();
+    writable.__linkUrl = linkUrl;
+  }
   // to render the image tag
   decorate() {
     return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
@@ -1690,7 +1718,8 @@ class ImageNode extends DecoratorNode {
         captionsEnabled: this.__captionsEnabled,
         resizable: true,
         originalPrompt: this.__originalPrompt,
-        position: this.__position
+        position: this.__position,
+        linkUrl: this.__linkUrl
       }
     ) });
   }
@@ -1706,7 +1735,8 @@ function $createImageNode({
   caption,
   key,
   originalPrompt,
-  position
+  position,
+  linkUrl
 }) {
   return $applyNodeReplacement(
     new ImageNode(
@@ -1720,6 +1750,7 @@ function $createImageNode({
       captionsEnabled,
       originalPrompt,
       position,
+      linkUrl,
       key
     )
   );
@@ -1741,37 +1772,7 @@ const ImagePlugin = ({
         INSERT_IMAGE_COMMAND,
         (payload) => {
           const imageNode = $createImageNode(payload);
-          const selection = $getSelection();
-          if ($isRangeSelection(selection)) {
-            const anchorNode = selection.anchor.getNode();
-            const anchorParent = anchorNode.getParent();
-            if (anchorParent instanceof ElementNode && !$isRootOrShadowRoot(anchorParent)) {
-              const parentType = anchorParent.getType();
-              if (parentType === "paragraph" || parentType === "listitem") {
-                const hasContent = anchorParent.getTextContent().trim().length > 0;
-                const isAtEnd = selection.anchor.offset === anchorNode.getTextContentSize();
-                const isAtStart = selection.anchor.offset === 0;
-                if (hasContent) {
-                  const imageParagraph = $createParagraphNode();
-                  imageParagraph.append(imageNode);
-                  if (isAtEnd) {
-                    anchorParent.insertAfter(imageParagraph);
-                  } else if (isAtStart) {
-                    anchorParent.insertBefore(imageParagraph);
-                  } else {
-                    anchorParent.insertAfter(imageParagraph);
-                  }
-                  const emptyParagraph = $createParagraphNode();
-                  imageParagraph.insertAfter(emptyParagraph);
-                  emptyParagraph.selectEnd();
-                  return true;
-                }
-              }
-            }
-          }
-          if ($isRangeSelection(selection)) {
-            selection.insertNodes([imageNode]);
-          }
+          $insertNodes([imageNode]);
           if ($isRootOrShadowRoot(imageNode.getParentOrThrow())) {
             $wrapNodeInElement(imageNode, $createParagraphNode).selectEnd();
           }
@@ -7344,6 +7345,19 @@ const FileSearch = createLucideIcon("FileSearch", [
   ["circle", { cx: "5", cy: "14", r: "3", key: "ufru5t" }],
   ["path", { d: "m9 18-1.5-1.5", key: "1j6qii" }]
 ]);
+/**
+ * @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 FileText = createLucideIcon("FileText", [
+  ["path", { d: "M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z", key: "1rqfz7" }],
+  ["path", { d: "M14 2v4a2 2 0 0 0 2 2h4", key: "tnqrlb" }],
+  ["path", { d: "M10 9H8", key: "b1mrlr" }],
+  ["path", { d: "M16 13H8", key: "t4e002" }],
+  ["path", { d: "M16 17H8", key: "z1uh3a" }]
+]);
 /**
  * @license lucide-react v0.344.0 - ISC
  *
@@ -7355,6 +7369,18 @@ const Globe = createLucideIcon("Globe", [
   ["path", { d: "M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20", key: "13o1zl" }],
   ["path", { d: "M2 12h20", key: "9i4pu4" }]
 ]);
+/**
+ * @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 Hash = createLucideIcon("Hash", [
+  ["line", { x1: "4", x2: "20", y1: "9", y2: "9", key: "4lhtct" }],
+  ["line", { x1: "4", x2: "20", y1: "15", y2: "15", key: "vyu0kd" }],
+  ["line", { x1: "10", x2: "8", y1: "3", y2: "21", key: "1ggp8o" }],
+  ["line", { x1: "16", x2: "14", y1: "3", y2: "21", key: "weycgp" }]
+]);
 /**
  * @license lucide-react v0.344.0 - ISC
  *
@@ -15403,7 +15429,7 @@ const EmbedComponent = ({ url, displayType, alignment, nodeKey }) => {
     }
   );
 };
-const FileComponent = React$1.lazy(() => import("./index-4edbb171.js"));
+const FileComponent = React$1.lazy(() => import("./index-03cae849.js"));
 function convertFileElement(domNode) {
   if (domNode instanceof HTMLDivElement) {
     const dataUrl = domNode.getAttribute("data-lexical-file-src");
@@ -20560,10 +20586,10 @@ const PDF_CONFIG = {
 };
 const loadHtml2Pdf = async () => {
   try {
-    const mod = await import("./html2pdf.bundle.min-382f2ad4.js").then((n) => n.h);
+    const mod = await import("./html2pdf.bundle.min-d2f5d9cb.js").then((n) => n.h);
     return (mod == null ? void 0 : mod.default) || mod;
   } catch {
-    const mod2 = await import("./html2pdf.bundle-08dfd2d4.js").then((n) => n.h);
+    const mod2 = await import("./html2pdf.bundle-0e71462c.js").then((n) => n.h);
     return (mod2 == null ? void 0 : mod2.default) || mod2;
   }
 };
@@ -31834,6 +31860,554 @@ const LocalStoragePlugin = ({ namespace }) => {
   return null;
 };
 const LocalStoragePlugin$1 = LocalStoragePlugin;
+const HORIZONTAL_RULE_PATTERNS = /^(---|___|\*\*\*)$/;
+const HEADING_PATTERN = /^(#{1,6})\s$/;
+const BULLET_LIST_PATTERN = /^(\*|-|\+)\s$/;
+const NUMBERED_LIST_PATTERN = /^(\d+)[\.\)]\s$/;
+const CHECKLIST_PATTERN = /^\[(x|\s)?\]\s$/i;
+const QUOTE_PATTERN = /^>\s$/;
+const CODE_BLOCK_PATTERN = /^```$/;
+function getLineTextBeforeCursor(editor) {
+  let text = null;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return;
+    }
+    const anchor = selection.anchor;
+    const anchorNode = anchor.getNode();
+    if (!$isTextNode(anchorNode)) {
+      return;
+    }
+    const textContent = anchorNode.getTextContent();
+    const offset2 = anchor.offset;
+    text = textContent.slice(0, offset2);
+  });
+  return text;
+}
+function isAtBlockStart(editor, triggerLength) {
+  let result = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return;
+    }
+    const anchor = selection.anchor;
+    const anchorNode = anchor.getNode();
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph") {
+      return;
+    }
+    const children = parent.getChildren();
+    if (children.length === 1 && children[0] === anchorNode) {
+      const textContent = anchorNode.getTextContent();
+      if (textContent.length === triggerLength) {
+        result = true;
+      }
+    }
+  });
+  return result;
+}
+function isInsideListItem(node) {
+  let current = node.getParent();
+  while (current !== null) {
+    if ($isListItemNode(current)) {
+      return true;
+    }
+    current = current.getParent();
+  }
+  return false;
+}
+function handleHorizontalRule(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !HORIZONTAL_RULE_PATTERNS.test(text)) {
+    return false;
+  }
+  if (!isAtBlockStart(editor, text.length)) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, void 0);
+      parent.remove();
+    }
+  });
+  return true;
+}
+function handleHeading(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text)
+    return false;
+  const match = text.match(HEADING_PATTERN);
+  if (!match)
+    return false;
+  let isValidContext = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph")
+      return;
+    if (isInsideListItem(parent))
+      return;
+    const children = parent.getChildren();
+    if (children.length !== 1 || children[0] !== anchorNode)
+      return;
+    const fullText = anchorNode.getTextContent();
+    const headingMatch = fullText.match(HEADING_PATTERN);
+    if (headingMatch && headingMatch.index === 0) {
+      isValidContext = true;
+    }
+  });
+  if (!isValidContext) {
+    return false;
+  }
+  const level = match[1].length;
+  const tag = `h${level}`;
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const fullText = anchorNode.getTextContent();
+      const remainingText = fullText.slice(match[0].length);
+      const headingNode = $createHeadingNode(tag);
+      if (remainingText) {
+        headingNode.append($createTextNode(remainingText));
+      }
+      parent.replace(headingNode);
+      headingNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleBulletList(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !BULLET_LIST_PATTERN.test(text)) {
+    return false;
+  }
+  let isValidContext = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph")
+      return;
+    if (isInsideListItem(parent))
+      return;
+    const children = parent.getChildren();
+    if (children.length !== 1 || children[0] !== anchorNode)
+      return;
+    const fullText = anchorNode.getTextContent();
+    const match = fullText.match(BULLET_LIST_PATTERN);
+    if (match && match.index === 0) {
+      isValidContext = true;
+    }
+  });
+  if (!isValidContext) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const fullText = anchorNode.getTextContent();
+      const match = text.match(BULLET_LIST_PATTERN);
+      const remainingText = match ? fullText.slice(match[0].length) : "";
+      const listNode = $createListNode("bullet");
+      const listItemNode = $createListItemNode();
+      if (remainingText) {
+        listItemNode.append($createTextNode(remainingText));
+      }
+      listNode.append(listItemNode);
+      parent.replace(listNode);
+      listItemNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleNumberedList(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !NUMBERED_LIST_PATTERN.test(text)) {
+    return false;
+  }
+  let isValidContext = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph")
+      return;
+    if (isInsideListItem(parent))
+      return;
+    const children = parent.getChildren();
+    if (children.length !== 1 || children[0] !== anchorNode)
+      return;
+    const fullText = anchorNode.getTextContent();
+    const match = fullText.match(NUMBERED_LIST_PATTERN);
+    if (match && match.index === 0) {
+      isValidContext = true;
+    }
+  });
+  if (!isValidContext) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const fullText = anchorNode.getTextContent();
+      const match = text.match(NUMBERED_LIST_PATTERN);
+      const remainingText = match ? fullText.slice(match[0].length) : "";
+      const listNode = $createListNode("number");
+      const listItemNode = $createListItemNode();
+      if (remainingText) {
+        listItemNode.append($createTextNode(remainingText));
+      }
+      listNode.append(listItemNode);
+      parent.replace(listNode);
+      listItemNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleChecklist(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !CHECKLIST_PATTERN.test(text)) {
+    return false;
+  }
+  let isValidContext = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph")
+      return;
+    if (isInsideListItem(parent))
+      return;
+    const children = parent.getChildren();
+    if (children.length !== 1 || children[0] !== anchorNode)
+      return;
+    const fullText = anchorNode.getTextContent();
+    const match = fullText.match(CHECKLIST_PATTERN);
+    if (match && match.index === 0) {
+      isValidContext = true;
+    }
+  });
+  if (!isValidContext) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const fullText = anchorNode.getTextContent();
+      const match = text.match(CHECKLIST_PATTERN);
+      const remainingText = match ? fullText.slice(match[0].length) : "";
+      const listNode = $createListNode("check");
+      const listItemNode = $createListItemNode();
+      if (remainingText) {
+        listItemNode.append($createTextNode(remainingText));
+      }
+      listNode.append(listItemNode);
+      parent.replace(listNode);
+      listItemNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleQuote(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !QUOTE_PATTERN.test(text)) {
+    return false;
+  }
+  let isValidContext = false;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (!parent || parent.getType() !== "paragraph")
+      return;
+    if (isInsideListItem(parent))
+      return;
+    const children = parent.getChildren();
+    if (children.length !== 1 || children[0] !== anchorNode)
+      return;
+    const fullText = anchorNode.getTextContent();
+    const match = fullText.match(QUOTE_PATTERN);
+    if (match && match.index === 0) {
+      isValidContext = true;
+    }
+  });
+  if (!isValidContext) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode))
+      return;
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const fullText = anchorNode.getTextContent();
+      const match = text.match(QUOTE_PATTERN);
+      const remainingText = match ? fullText.slice(match[0].length) : "";
+      const quoteNode = $createQuoteNode();
+      if (remainingText) {
+        quoteNode.append($createTextNode(remainingText));
+      }
+      parent.replace(quoteNode);
+      quoteNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleCodeBlock(editor) {
+  const text = getLineTextBeforeCursor(editor);
+  if (!text || !CODE_BLOCK_PATTERN.test(text)) {
+    return false;
+  }
+  if (!isAtBlockStart(editor, text.length)) {
+    return false;
+  }
+  editor.update(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+      return;
+    const anchorNode = selection.anchor.getNode();
+    const parent = anchorNode.getParent();
+    if (parent && parent.getType() === "paragraph") {
+      const codeNode = $createCodeNode();
+      parent.replace(codeNode);
+      const paragraphNode = $createParagraphNode();
+      codeNode.insertAfter(paragraphNode);
+      codeNode.selectEnd();
+    }
+  });
+  return true;
+}
+function handleMarkdownShortcuts(editor) {
+  if (handleHorizontalRule(editor))
+    return true;
+  if (handleHeading(editor))
+    return true;
+  if (handleBulletList(editor))
+    return true;
+  if (handleNumberedList(editor))
+    return true;
+  if (handleChecklist(editor))
+    return true;
+  if (handleQuote(editor))
+    return true;
+  if (handleCodeBlock(editor))
+    return true;
+  return false;
+}
+function MarkdownShortcutsPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect$1(() => {
+    const removeTextListener = editor.registerTextContentListener(() => {
+      const text = getLineTextBeforeCursor(editor);
+      if (text && HORIZONTAL_RULE_PATTERNS.test(text)) {
+        setTimeout(() => {
+          handleHorizontalRule(editor);
+        }, 0);
+      }
+    });
+    const removeEnterListener = editor.registerCommand(
+      KEY_ENTER_COMMAND,
+      (event) => {
+        const handled = handleMarkdownShortcuts(editor);
+        if (handled && event) {
+          event.preventDefault();
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+    const removeBackspaceListener = editor.registerCommand(
+      KEY_BACKSPACE_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        const anchor = selection.anchor;
+        const anchorNode = anchor.getNode();
+        if (anchor.offset !== 0) {
+          return false;
+        }
+        let listItem = null;
+        let current = anchorNode;
+        while (current !== null) {
+          if ($isListItemNode(current)) {
+            listItem = current;
+            break;
+          }
+          current = current.getParent();
+        }
+        if (!listItem) {
+          return false;
+        }
+        const listItemChildren = listItem.getChildren();
+        let isAtStart = false;
+        if (listItemChildren.length === 0) {
+          isAtStart = true;
+        } else {
+          const firstChild = listItemChildren[0];
+          if (firstChild === anchorNode) {
+            isAtStart = true;
+          } else {
+            const firstChildType = firstChild.getType();
+            if (firstChildType === "paragraph" || firstChildType === "heading") {
+              const parent = anchorNode.getParent();
+              if (parent && parent === firstChild) {
+                const siblings = parent.getChildren();
+                if (siblings.length > 0 && siblings[0] === anchorNode) {
+                  isAtStart = true;
+                } else if (siblings.length === 0) {
+                  isAtStart = true;
+                }
+              }
+            }
+          }
+        }
+        if (isAtStart) {
+          const listNode = listItem.getParent();
+          if (listNode && $isListNode(listNode)) {
+            const paragraphNode = $createParagraphNode();
+            const children = listItem.getChildren();
+            for (const child of children) {
+              const childType = child.getType();
+              if (childType === "paragraph" || childType === "heading") {
+                const elementChild = child;
+                const innerChildren = elementChild.getChildren();
+                for (const innerChild of innerChildren) {
+                  paragraphNode.append(innerChild);
+                }
+              } else {
+                paragraphNode.append(child);
+              }
+            }
+            const listChildren = listNode.getChildren();
+            const isFirstItem = listChildren.length > 0 && listChildren[0] === listItem;
+            if (isFirstItem) {
+              listNode.insertBefore(paragraphNode);
+            } else {
+              listItem.insertBefore(paragraphNode);
+            }
+            listItem.remove();
+            if (listNode.getChildrenSize() === 0) {
+              listNode.remove();
+            }
+            paragraphNode.selectEnd();
+          }
+          if (event) {
+            event.preventDefault();
+          }
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+    const removeUpdateListener = editor.registerUpdateListener(
+      ({ editorState, tags }) => {
+        if (tags.has("history-merge"))
+          return;
+        editorState.read(() => {
+          const selection = $getSelection();
+          if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+            return;
+          }
+          const text = getLineTextBeforeCursor(editor);
+          if (!text)
+            return;
+          if (text.endsWith(" ")) {
+            if (HEADING_PATTERN.test(text)) {
+              setTimeout(() => handleHeading(editor), 0);
+              return;
+            }
+            if (BULLET_LIST_PATTERN.test(text)) {
+              setTimeout(() => handleBulletList(editor), 0);
+              return;
+            }
+            if (NUMBERED_LIST_PATTERN.test(text)) {
+              setTimeout(() => handleNumberedList(editor), 0);
+              return;
+            }
+            if (CHECKLIST_PATTERN.test(text)) {
+              setTimeout(() => handleChecklist(editor), 0);
+              return;
+            }
+            if (QUOTE_PATTERN.test(text)) {
+              setTimeout(() => handleQuote(editor), 0);
+              return;
+            }
+          }
+          if (CODE_BLOCK_PATTERN.test(text)) {
+            setTimeout(() => handleCodeBlock(editor), 0);
+            return;
+          }
+        });
+      }
+    );
+    return () => {
+      removeTextListener();
+      removeEnterListener();
+      removeBackspaceListener();
+      removeUpdateListener();
+    };
+  }, [editor]);
+  return null;
+}
 const index$2 = "";
 const PUNCTUATION = `\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'"~=<>_:;`;
 const NAME = "\\b[A-Z][^\\s" + PUNCTUATION + "]";
@@ -32012,6 +32586,11 @@ function detectCSSAlignment(element) {
   while (current && current !== document.body) {
     const style = current.style;
     const computedStyle = window.getComputedStyle(current);
+    const floatValue = style.cssFloat || style.float || computedStyle.cssFloat || computedStyle.float;
+    if (floatValue === "left")
+      return "left";
+    if (floatValue === "right")
+      return "right";
     const textAlign = style.textAlign || computedStyle.textAlign;
     if (textAlign === "center")
       return "center";
@@ -32033,29 +32612,52 @@ function detectCSSAlignment(element) {
   }
   return null;
 }
+const DEFAULT_IMAGE_DIMENSIONS = {
+  // For side-by-side/floated images - smaller default since they share space with text
+  floated: { width: 300, height: 200 },
+  // For centered/standalone images - larger default for prominence
+  centered: { width: 600, height: 400 },
+  // For inline images without explicit layout
+  inline: { width: 400, height: 300 },
+  // Maximum reasonable dimensions to cap oversized images
+  maxWidth: 800,
+  maxHeight: 600
+};
 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 (styleWidth) {
+      const parsed = parseInt(styleWidth);
+      if (!isNaN(parsed) && parsed > 0) {
+        width = parsed;
+      }
     }
   }
   if (height === 0) {
     const styleHeight = imgElement.style.height;
-    if (styleHeight && styleHeight.endsWith("px")) {
-      height = parseInt(styleHeight);
+    if (styleHeight) {
+      const parsed = parseInt(styleHeight);
+      if (!isNaN(parsed) && parsed > 0) {
+        height = parsed;
+      }
     }
   }
   if (width === 0 || height === 0) {
     try {
       const computed = window.getComputedStyle(imgElement);
       if (width === 0 && computed.width && computed.width !== "auto") {
-        width = parseInt(computed.width);
+        const parsed = parseInt(computed.width);
+        if (!isNaN(parsed) && parsed > 0) {
+          width = parsed;
+        }
       }
       if (height === 0 && computed.height && computed.height !== "auto") {
-        height = parseInt(computed.height);
+        const parsed = parseInt(computed.height);
+        if (!isNaN(parsed) && parsed > 0) {
+          height = parsed;
+        }
       }
     } catch {
     }
@@ -32070,6 +32672,33 @@ function getImageDimensions(imgElement) {
   }
   return { width, height };
 }
+function getImageDimensionsWithDefaults(imgElement, layoutContext = "inline") {
+  const { width, height } = getImageDimensions(imgElement);
+  if (width > 0 && height > 0) {
+    const aspectRatio = width / height;
+    let finalWidth = width;
+    let finalHeight = height;
+    if (finalWidth > DEFAULT_IMAGE_DIMENSIONS.maxWidth) {
+      finalWidth = DEFAULT_IMAGE_DIMENSIONS.maxWidth;
+      finalHeight = Math.round(finalWidth / aspectRatio);
+    }
+    if (finalHeight > DEFAULT_IMAGE_DIMENSIONS.maxHeight) {
+      finalHeight = DEFAULT_IMAGE_DIMENSIONS.maxHeight;
+      finalWidth = Math.round(finalHeight * aspectRatio);
+    }
+    return { width: finalWidth, height: finalHeight };
+  }
+  if (width > 0) {
+    const cappedWidth = Math.min(width, DEFAULT_IMAGE_DIMENSIONS.maxWidth);
+    return { width: cappedWidth, height: Math.round(cappedWidth * 0.625) };
+  }
+  if (height > 0) {
+    const cappedHeight = Math.min(height, DEFAULT_IMAGE_DIMENSIONS.maxHeight);
+    return { width: Math.round(cappedHeight * 1.6), height: cappedHeight };
+  }
+  const defaults = DEFAULT_IMAGE_DIMENSIONS[layoutContext];
+  return { width: defaults.width, height: defaults.height };
+}
 function shouldCenterImage(imgElement) {
   var _a;
   const { width, height } = getImageDimensions(imgElement);
@@ -32172,15 +32801,205 @@ function detectClassBasedAlignment(element) {
   }
   return null;
 }
+function isImageContainerClass(className) {
+  const imagePatterns = [
+    "media",
+    "image",
+    "img",
+    "photo",
+    "picture",
+    "thumbnail",
+    "thumb",
+    "visual",
+    "graphic",
+    "illustration",
+    "figure",
+    "avatar",
+    "hero",
+    "banner",
+    "cover",
+    "poster",
+    "artwork",
+    "gallery",
+    "featured",
+    "wp-block-image",
+    "wp-image",
+    "attachment",
+    "featured-image"
+  ];
+  const lowerClass = className.toLowerCase();
+  return imagePatterns.some((pattern) => lowerClass.includes(pattern));
+}
+function detectWordPressAlignment(element) {
+  const className = element.className || "";
+  const lowerClass = className.toLowerCase();
+  if (lowerClass.includes("alignleft") || lowerClass.includes("align-left")) {
+    return "left";
+  }
+  if (lowerClass.includes("alignright") || lowerClass.includes("align-right")) {
+    return "right";
+  }
+  if (lowerClass.includes("aligncenter") || lowerClass.includes("align-center")) {
+    return "center";
+  }
+  if (lowerClass.includes("alignnone") || lowerClass.includes("align-none")) {
+    return "left";
+  }
+  let parent = element.parentElement;
+  let depth = 0;
+  while (parent && depth < 5) {
+    const parentClass = parent.className || "";
+    const parentLower = parentClass.toLowerCase();
+    if (parentLower.includes("alignleft") || parentLower.includes("align-left")) {
+      return "left";
+    }
+    if (parentLower.includes("alignright") || parentLower.includes("align-right")) {
+      return "right";
+    }
+    if (parentLower.includes("aligncenter") || parentLower.includes("align-center")) {
+      return "center";
+    }
+    parent = parent.parentElement;
+    depth++;
+  }
+  return null;
+}
+function isContentContainerClass(className) {
+  const contentPatterns = [
+    "content",
+    "text",
+    "body",
+    "copy",
+    "description",
+    "details",
+    "info",
+    "meta",
+    "caption",
+    "excerpt",
+    "summary",
+    "article",
+    "prose",
+    "entry",
+    "post",
+    "main",
+    "primary"
+  ];
+  const lowerClass = className.toLowerCase();
+  return contentPatterns.some((pattern) => lowerClass.includes(pattern));
+}
+function containsImage(element) {
+  return element.querySelector("img") !== null || element.tagName.toLowerCase() === "img";
+}
+function hasSubstantialTextContent(element) {
+  var _a;
+  const text = ((_a = element.textContent) == null ? void 0 : _a.trim()) || "";
+  return text.length > 30;
+}
+function detectBootstrapColumn(element) {
+  const className = element.className || "";
+  const colMatch = className.match(/\bcol(-[a-z]{2})?(-\d+)?\b/);
+  if (!colMatch)
+    return null;
+  const parent = element.parentElement;
+  if (!parent)
+    return null;
+  const parentClass = parent.className || "";
+  if (!parentClass.includes("row"))
+    return null;
+  const siblings = Array.from(parent.children).filter((child) => {
+    const cls = child.className || "";
+    return cls.match(/\bcol(-[a-z]{2})?(-\d+)?\b/);
+  });
+  const index2 = siblings.indexOf(element);
+  if (index2 === -1)
+    return null;
+  return index2 < siblings.length / 2 ? "left" : "right";
+}
+function detectSideBySideLayout(imgElement) {
+  const ancestors = [];
+  let current = imgElement;
+  while (current && current !== document.body && ancestors.length < 10) {
+    ancestors.push(current);
+    current = current.parentElement;
+  }
+  for (let i2 = 0; i2 < ancestors.length; i2++) {
+    const ancestor = ancestors[i2];
+    const parent = ancestor.parentElement;
+    if (!parent || parent === document.body)
+      continue;
+    const bootstrapPos = detectBootstrapColumn(ancestor);
+    if (bootstrapPos) {
+      const siblings2 = Array.from(parent.children);
+      const hasContentSibling = siblings2.some((sibling) => {
+        if (sibling === ancestor)
+          return false;
+        return hasSubstantialTextContent(sibling) && !containsImage(sibling);
+      });
+      if (hasContentSibling) {
+        return bootstrapPos;
+      }
+    }
+    const ancestorClass = ancestor.className || "";
+    const isMediaContainer = isImageContainerClass(ancestorClass);
+    if (isMediaContainer) {
+      const siblings2 = Array.from(parent.children).filter((child) => {
+        var _a;
+        const tag = (_a = child.tagName) == null ? void 0 : _a.toLowerCase();
+        return tag !== "script" && tag !== "style" && tag !== "noscript";
+      });
+      if (siblings2.length >= 2) {
+        const ancestorIndex = siblings2.indexOf(ancestor);
+        const contentSiblingIndex = siblings2.findIndex((sibling, index2) => {
+          if (index2 === ancestorIndex)
+            return false;
+          const siblingClass = sibling.className || "";
+          const hasContentClass = isContentContainerClass(siblingClass);
+          const hasText = hasSubstantialTextContent(sibling);
+          const hasNoImage = !containsImage(sibling);
+          return (hasContentClass || hasText) && hasNoImage;
+        });
+        if (contentSiblingIndex !== -1) {
+          return ancestorIndex < contentSiblingIndex ? "left" : "right";
+        }
+      }
+    }
+    const siblings = Array.from(parent.children).filter((child) => {
+      var _a;
+      const tag = (_a = child.tagName) == null ? void 0 : _a.toLowerCase();
+      return tag !== "script" && tag !== "style" && tag !== "noscript" && tag !== "br";
+    });
+    if (siblings.length === 2) {
+      const ancestorIndex = siblings.indexOf(ancestor);
+      if (ancestorIndex !== -1) {
+        const otherSibling = siblings[1 - ancestorIndex];
+        const ancestorHasImage = containsImage(ancestor);
+        const otherHasImage = containsImage(otherSibling);
+        const otherHasText = hasSubstantialTextContent(otherSibling);
+        if (ancestorHasImage && !otherHasImage && otherHasText) {
+          return ancestorIndex === 0 ? "left" : "right";
+        }
+      }
+    }
+  }
+  return null;
+}
 function detectImageAlignment(imgElement) {
   const classAlignment = detectClassBasedAlignment(imgElement);
   if (classAlignment) {
     return classAlignment;
   }
+  const wpAlignment = detectWordPressAlignment(imgElement);
+  if (wpAlignment) {
+    return wpAlignment;
+  }
   const cssAlignment = detectCSSAlignment(imgElement);
   if (cssAlignment) {
     return cssAlignment;
   }
+  const sideBySideAlignment = detectSideBySideLayout(imgElement);
+  if (sideBySideAlignment) {
+    return sideBySideAlignment;
+  }
   if (shouldCenterImage(imgElement)) {
     return "center";
   }
@@ -32502,7 +33321,7 @@ const defaultPasteContext = {
 };
 let currentPasteContext = defaultPasteContext;
 function processNode(domNode, parentElement = null) {
-  var _a;
+  var _a, _b, _c;
   const results = [];
   if (domNode.nodeType === Node.TEXT_NODE) {
     const text = domNode.textContent || "";
@@ -32528,17 +33347,22 @@ function processNode(domNode, parentElement = null) {
       const paragraph = $createParagraphNode();
       const styleInfo = getStyleInfoFromElement(element);
       const hasExplicitFontSize = styleInfo.fontSize && styleInfo.fontSize !== "16px";
+      let overflowNodes = [];
       if (!hasExplicitFontSize && currentPasteContext.isCKEditor) {
         processChildrenWithStyle(element, paragraph, {
           fontSize: DEFAULT_PARAGRAPH_FONT_SIZE,
           lineHeight: DEFAULT_PARAGRAPH_LINE_HEIGHT
         });
       } else {
-        processChildren(element, paragraph);
+        const result = processChildrenWithImageSeparation(element, paragraph);
+        overflowNodes = result.overflowNodes;
       }
       if (paragraph.getChildrenSize() > 0 || tagName === "p") {
         results.push(paragraph);
       }
+      if (overflowNodes.length > 0) {
+        results.push(...overflowNodes);
+      }
       break;
     }
     case "h1":
@@ -32601,7 +33425,41 @@ function processNode(domNode, parentElement = null) {
     }
     case "a": {
       const href = element.getAttribute("href") || "";
-      if (href) {
+      const containedImg = element.querySelector("img");
+      if (containedImg) {
+        const src = containedImg.getAttribute("src") || "";
+        if (src && !src.startsWith("file:///")) {
+          const alt = containedImg.getAttribute("alt") || "";
+          const alignment = detectImageAlignment(containedImg);
+          const layoutContext = isFloatAlignment(alignment) ? "floated" : alignment === "center" ? "centered" : "inline";
+          const { width, height } = getImageDimensionsWithDefaults(containedImg, layoutContext);
+          const position = alignmentToPosition(alignment);
+          const imageNode = $createImageNode({
+            src,
+            altText: alt,
+            width,
+            height,
+            position: isFloatAlignment(alignment) ? position : "none",
+            linkUrl: href
+            // Store the original link URL
+          });
+          if (alignment === "center") {
+            const paragraph = $createParagraphNode();
+            paragraph.setFormat("center");
+            paragraph.append(imageNode);
+            results.push(paragraph);
+          } else {
+            results.push(imageNode);
+          }
+        }
+        const textContent = (_a = element.textContent) == null ? void 0 : _a.replace(containedImg.alt || "", "").trim();
+        if (textContent && textContent.length > 0) {
+          const linkNode = $createLinkNode(href, { target: "_blank", rel: "noopener" });
+          const textNode = $createTextNode(textContent);
+          linkNode.append(textNode);
+          results.push(linkNode);
+        }
+      } else if (href) {
         const linkNode = $createLinkNode(href, { target: "_blank", rel: "noopener" });
         processChildren(element, linkNode);
         results.push(linkNode);
@@ -32615,9 +33473,9 @@ function processNode(domNode, parentElement = null) {
       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 layoutContext = isFloatAlignment(alignment) ? "floated" : alignment === "center" ? "centered" : "inline";
+        const { width, height } = getImageDimensionsWithDefaults(element, layoutContext);
         const position = alignmentToPosition(alignment);
         const imageNode = $createImageNode({
           src,
@@ -32648,13 +33506,13 @@ function processNode(domNode, parentElement = null) {
       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()) || "";
+      const captionText = ((_b = figcaption == null ? void 0 : figcaption.textContent) == null ? void 0 : _b.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 layoutContext = isFloat ? "floated" : alignment === "center" ? "centered" : "inline";
+          const { width, height } = getImageDimensionsWithDefaults(img, layoutContext);
           const imageNode = $createImageNode({
             src,
             altText: alt,
@@ -32693,6 +33551,43 @@ function processNode(domNode, parentElement = null) {
       }
       break;
     }
+    case "code": {
+      const className = element.className || "";
+      const isBlockCode = className.includes("PlaygroundEditorTheme__code") || className.includes("code-block") || element.hasAttribute("data-language") || element.hasAttribute("data-highlight-language");
+      if (isBlockCode) {
+        const language = element.getAttribute("data-language") || element.getAttribute("data-highlight-language") || void 0;
+        const codeNode = $createCodeNode(language);
+        const textContent = element.textContent || "";
+        if (textContent) {
+          codeNode.append($createTextNode(textContent));
+        }
+        results.push(codeNode);
+      } else {
+        const children = processChildren(element);
+        results.push(...children);
+      }
+      break;
+    }
+    case "pre": {
+      const codeChild = element.querySelector("code");
+      if (codeChild) {
+        const language = codeChild.getAttribute("data-language") || codeChild.getAttribute("data-highlight-language") || ((_c = codeChild.className.match(/language-(\w+)/)) == null ? void 0 : _c[1]) || void 0;
+        const codeNode = $createCodeNode(language);
+        const textContent = codeChild.textContent || "";
+        if (textContent) {
+          codeNode.append($createTextNode(textContent));
+        }
+        results.push(codeNode);
+      } else {
+        const codeNode = $createCodeNode();
+        const textContent = element.textContent || "";
+        if (textContent) {
+          codeNode.append($createTextNode(textContent));
+        }
+        results.push(codeNode);
+      }
+      break;
+    }
     case "strong":
     case "b":
     case "em":
@@ -32701,7 +33596,6 @@ function processNode(domNode, parentElement = null) {
     case "s":
     case "strike":
     case "del":
-    case "code":
     case "sub":
     case "sup":
     case "mark":
@@ -32749,6 +33643,60 @@ function processChildren(element, parentNode) {
   }
   return results;
 }
+function processChildrenWithImageSeparation(element, parentNode) {
+  const overflowNodes = [];
+  let hasTextContent = false;
+  const childNodes = element.childNodes;
+  for (let i2 = 0; i2 < childNodes.length; i2++) {
+    const child = childNodes[i2];
+    if (child.nodeType === Node.ELEMENT_NODE) {
+      const childElement = child;
+      const tagName = childElement.tagName.toLowerCase();
+      if (tagName === "img") {
+        if (hasTextContent) {
+          const nodes2 = processNode(child, element);
+          nodes2.forEach((node) => {
+            if ($isImageNode(node)) {
+              const imageParagraph = $createParagraphNode();
+              imageParagraph.append(node);
+              overflowNodes.push(imageParagraph);
+            } else if (node instanceof ParagraphNode) {
+              overflowNodes.push(node);
+            } else {
+              overflowNodes.push(node);
+            }
+          });
+          continue;
+        }
+      }
+    }
+    const nodes = processNode(child, element);
+    nodes.forEach((node) => {
+      if ($isTextNode(node) && node.getTextContent().trim().length > 0) {
+        hasTextContent = true;
+      }
+      if ($isImageNode(node) && hasTextContent) {
+        const imageParagraph = $createParagraphNode();
+        imageParagraph.append(node);
+        overflowNodes.push(imageParagraph);
+      } else if (node instanceof ParagraphNode && hasTextContent) {
+        const children = node.getChildren();
+        const hasOnlyImage = children.length === 1 && $isImageNode(children[0]);
+        if (hasOnlyImage) {
+          overflowNodes.push(node);
+        } else {
+          parentNode.append(node);
+        }
+      } else {
+        parentNode.append(node);
+        if ($isTextNode(node) && node.getTextContent().trim().length > 0) {
+          hasTextContent = true;
+        }
+      }
+    });
+  }
+  return { overflowNodes };
+}
 function processChildrenWithStyle(element, parentNode, defaultStyles) {
   const childNodes = element.childNodes;
   for (let i2 = 0; i2 < childNodes.length; i2++) {
@@ -33017,56 +33965,7 @@ function RichTextPastePlugin() {
                     return true;
                   });
                   if (filteredNodes.length > 0) {
-                    const anchorNode = selection.anchor.getNode();
-                    const anchorParent = anchorNode.getParent();
-                    const isInsideParagraphWithContent = anchorParent instanceof ElementNode && anchorParent.getType() === "paragraph" && anchorParent.getTextContent().trim().length > 0;
-                    if (isInsideParagraphWithContent) {
-                      for (const node of filteredNodes) {
-                        if ($isImageNode(node)) {
-                          const currentSelection = $getSelection();
-                          if ($isRangeSelection(currentSelection)) {
-                            const currentAnchor = currentSelection.anchor.getNode();
-                            const currentParent = currentAnchor.getParent();
-                            if (currentParent instanceof ElementNode && currentParent.getType() === "paragraph") {
-                              const imageParagraph = $createParagraphNode();
-                              imageParagraph.append(node);
-                              currentParent.insertAfter(imageParagraph);
-                              imageParagraph.selectEnd();
-                            } else {
-                              currentSelection.insertNodes([node]);
-                            }
-                          }
-                        } else if (node instanceof ParagraphNode) {
-                          const children = node.getChildren();
-                          const hasOnlyImage = children.length === 1 && $isImageNode(children[0]);
-                          if (hasOnlyImage) {
-                            const currentSelection = $getSelection();
-                            if ($isRangeSelection(currentSelection)) {
-                              const currentAnchor = currentSelection.anchor.getNode();
-                              const currentParent = currentAnchor.getParent();
-                              if (currentParent instanceof ElementNode && currentParent.getType() === "paragraph") {
-                                currentParent.insertAfter(node);
-                                node.selectEnd();
-                              } else {
-                                currentSelection.insertNodes([node]);
-                              }
-                            }
-                          } else {
-                            const currentSelection = $getSelection();
-                            if ($isRangeSelection(currentSelection)) {
-                              currentSelection.insertNodes([node]);
-                            }
-                          }
-                        } else {
-                          const currentSelection = $getSelection();
-                          if ($isRangeSelection(currentSelection)) {
-                            currentSelection.insertNodes([node]);
-                          }
-                        }
-                      }
-                    } else {
-                      selection.insertNodes(filteredNodes);
-                    }
+                    selection.insertNodes(filteredNodes);
                   }
                 }
               } catch (error) {
@@ -33087,6 +33986,651 @@ function RichTextPastePlugin() {
   }, [editor]);
   return null;
 }
+function htmlContainsImages(html) {
+  if (!html)
+    return false;
+  return /<img\s/i.test(html) || /data:image\//i.test(html);
+}
+function PasteOptionsMenu({
+  position,
+  currentMode,
+  onSelectMode,
+  onClose,
+  hasHtml
+}) {
+  const menuRef = useRef(null);
+  const [isOpen, setIsOpen] = useState$1(false);
+  const [menuPosition, setMenuPosition] = useState$1(position);
+  useEffect$1(() => {
+    setMenuPosition(position);
+  }, [position]);
+  useEffect$1(() => {
+    const handleClickOutside = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [onClose]);
+  const allOptions = [
+    {
+      mode: "rich",
+      label: "Use rich text",
+      icon: /* @__PURE__ */ jsx(Type, { className: "cteditor-size-4" })
+    },
+    {
+      mode: "markdown",
+      label: "Use Markdown",
+      icon: /* @__PURE__ */ jsx(Hash, { className: "cteditor-size-4" })
+    },
+    {
+      mode: "plain",
+      label: "Use plain text",
+      icon: /* @__PURE__ */ jsx(FileText, { className: "cteditor-size-4" })
+    }
+  ];
+  const options = hasHtml ? allOptions : allOptions.filter((option) => option.mode !== "rich");
+  const currentOption = options.find((o) => o.mode === currentMode);
+  const menuStyle = {
+    position: "fixed",
+    left: Math.min(menuPosition.x, window.innerWidth - 200),
+    top: Math.min(menuPosition.y + 5, window.innerHeight - 150),
+    zIndex: 1e3
+  };
+  return /* @__PURE__ */ jsxs("div", { ref: menuRef, style: menuStyle, className: "cteditor-relative", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: () => setIsOpen(!isOpen),
+        className: "cteditor-flex cteditor-items-center cteditor-gap-1.5 cteditor-px-2 cteditor-py-1 cteditor-text-xs cteditor-bg-background cteditor-border cteditor-border-border cteditor-rounded-md cteditor-shadow-lg hover:cteditor-bg-accent cteditor-transition-colors",
+        children: [
+          currentOption == null ? void 0 : currentOption.icon,
+          /* @__PURE__ */ jsx(
+            ChevronDown,
+            {
+              className: `cteditor-size-3 cteditor-transition-transform ${isOpen ? "cteditor-rotate-180" : ""}`
+            }
+          )
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsx("div", { className: "cteditor-absolute cteditor-top-full cteditor-left-0 cteditor-mt-1 cteditor-w-44 cteditor-bg-background cteditor-border cteditor-border-border cteditor-rounded-md cteditor-shadow-xl cteditor-overflow-hidden", children: options.map((option) => /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: () => {
+          onSelectMode(option.mode);
+          setIsOpen(false);
+        },
+        className: `cteditor-w-full cteditor-flex cteditor-items-center cteditor-gap-2 cteditor-px-3 cteditor-py-2 cteditor-text-xs hover:cteditor-bg-accent cteditor-transition-colors ${currentMode === option.mode ? "cteditor-bg-primary/10 cteditor-text-primary" : ""}`,
+        children: [
+          option.icon,
+          /* @__PURE__ */ jsx("span", { className: "cteditor-flex-1 cteditor-text-left", children: option.label }),
+          currentMode === option.mode && /* @__PURE__ */ jsx(Check, { className: "cteditor-size-3 cteditor-text-primary" })
+        ]
+      },
+      option.mode
+    )) })
+  ] });
+}
+function processInlineMarkdown(text) {
+  if (!text) {
+    return [];
+  }
+  const nodes = [];
+  const tripleBacktickPattern = /```([^`]+)```/g;
+  if (tripleBacktickPattern.test(text)) {
+    tripleBacktickPattern.lastIndex = 0;
+    let lastIndex = 0;
+    let match;
+    while ((match = tripleBacktickPattern.exec(text)) !== null) {
+      if (match.index > lastIndex) {
+        const beforeText = text.slice(lastIndex, match.index);
+        const beforeNodes = processSimpleInlineMarkdown(beforeText);
+        nodes.push(...beforeNodes);
+      }
+      const codeContent = match[1];
+      const codeNode = $createTextNode(codeContent);
+      codeNode.toggleFormat("code");
+      nodes.push(codeNode);
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+      const afterText = text.slice(lastIndex);
+      const afterNodes = processSimpleInlineMarkdown(afterText);
+      nodes.push(...afterNodes);
+    }
+    return nodes;
+  }
+  return processSimpleInlineMarkdown(text);
+}
+function processSimpleInlineMarkdown(text) {
+  if (!text) {
+    return [];
+  }
+  let processedText = text;
+  let hasBold = false;
+  let hasItalic = false;
+  let hasCode = false;
+  let hasStrikethrough = false;
+  if (/\*\*(.+?)\*\*/.test(processedText)) {
+    hasBold = true;
+    processedText = processedText.replace(/\*\*(.+?)\*\*/g, "$1");
+  }
+  if (/__(.+?)__/.test(processedText)) {
+    hasBold = true;
+    processedText = processedText.replace(/__(.+?)__/g, "$1");
+  }
+  if (!hasBold && /^\*([^*]+)\*$/.test(processedText)) {
+    hasItalic = true;
+    processedText = processedText.replace(/^\*([^*]+)\*$/, "$1");
+  } else if (/(?:^|[^*])\*([^*]+)\*(?:[^*]|$)/.test(processedText)) {
+    hasItalic = true;
+    processedText = processedText.replace(/\*([^*]+)\*/g, "$1");
+  }
+  if (!hasBold && /^_([^_]+)_$/.test(processedText)) {
+    hasItalic = true;
+    processedText = processedText.replace(/^_([^_]+)_$/, "$1");
+  } else if (/(?:^|[^_])_([^_]+)_(?:[^_]|$)/.test(processedText)) {
+    hasItalic = true;
+    processedText = processedText.replace(/_([^_]+)_/g, "$1");
+  }
+  if (new RegExp("(?<!`)`([^`]+)`(?!`)").test(processedText)) {
+    hasCode = true;
+    processedText = processedText.replace(new RegExp("(?<!`)`([^`]+)`(?!`)", "g"), "$1");
+  }
+  if (/~~(.+?)~~/.test(processedText)) {
+    hasStrikethrough = true;
+    processedText = processedText.replace(/~~(.+?)~~/g, "$1");
+  }
+  processedText = processedText.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+  const textNode = $createTextNode(processedText);
+  if (hasBold)
+    textNode.toggleFormat("bold");
+  if (hasItalic)
+    textNode.toggleFormat("italic");
+  if (hasCode)
+    textNode.toggleFormat("code");
+  if (hasStrikethrough)
+    textNode.toggleFormat("strikethrough");
+  return [textNode];
+}
+function convertMarkdownToNodes(text, editor) {
+  const nodes = [];
+  const lines = text.split("\n");
+  let i2 = 0;
+  while (i2 < lines.length) {
+    const line = lines[i2];
+    if (line.trim() === "") {
+      i2++;
+      continue;
+    }
+    if (/^(---|___|\*\*\*)$/.test(line.trim())) {
+      const placeholder = $createParagraphNode();
+      placeholder.append($createTextNode("___MARKDOWN_HR___"));
+      nodes.push(placeholder);
+      i2++;
+      continue;
+    }
+    const singleLineCodeMatch = line.trim().match(/^```(.+?)```$/);
+    if (singleLineCodeMatch) {
+      const codeContent = singleLineCodeMatch[1];
+      const codeNode = $createCodeNode();
+      codeNode.append($createTextNode(codeContent));
+      nodes.push(codeNode);
+      const afterParagraph = $createParagraphNode();
+      nodes.push(afterParagraph);
+      i2++;
+      continue;
+    }
+    if (line.trim().startsWith("```")) {
+      const codeLines = [];
+      const langMatch = line.trim().match(/^```(\w*)$/);
+      i2++;
+      while (i2 < lines.length && !lines[i2].trim().startsWith("```")) {
+        codeLines.push(lines[i2]);
+        i2++;
+      }
+      if (i2 < lines.length)
+        i2++;
+      const codeNode = $createCodeNode((langMatch == null ? void 0 : langMatch[1]) || void 0);
+      codeNode.append($createTextNode(codeLines.join("\n")));
+      nodes.push(codeNode);
+      const afterParagraph = $createParagraphNode();
+      nodes.push(afterParagraph);
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const headingNode = $createHeadingNode(
+        `h${level}`
+      );
+      const textNodes2 = processInlineMarkdown(headingMatch[2].trim());
+      textNodes2.forEach((node) => headingNode.append(node));
+      nodes.push(headingNode);
+      i2++;
+      continue;
+    }
+    if (/^[*\-+]\s+/.test(line)) {
+      const listNode = $createListNode("bullet");
+      while (i2 < lines.length && /^[*\-+]\s+/.test(lines[i2])) {
+        const listItemNode = $createListItemNode();
+        const itemText = lines[i2].replace(/^[*\-+]\s+/, "");
+        if (itemText) {
+          const textNodes2 = processInlineMarkdown(itemText);
+          if (textNodes2.length > 0) {
+            textNodes2.forEach((node) => listItemNode.append(node));
+          } else {
+            listItemNode.append($createTextNode(itemText));
+          }
+        }
+        listNode.append(listItemNode);
+        i2++;
+      }
+      nodes.push(listNode);
+      continue;
+    }
+    if (/^\d+[.)]\s+/.test(line)) {
+      const listNode = $createListNode("number");
+      while (i2 < lines.length && /^\d+[.)]\s+/.test(lines[i2])) {
+        const listItemNode = $createListItemNode();
+        const itemText = lines[i2].replace(/^\d+[.)]\s+/, "");
+        if (itemText) {
+          const textNodes2 = processInlineMarkdown(itemText);
+          if (textNodes2.length > 0) {
+            textNodes2.forEach((node) => listItemNode.append(node));
+          } else {
+            listItemNode.append($createTextNode(itemText));
+          }
+        }
+        listNode.append(listItemNode);
+        i2++;
+      }
+      nodes.push(listNode);
+      continue;
+    }
+    if (/^\[(x|\s)?\]\s+/i.test(line)) {
+      const listNode = $createListNode("check");
+      while (i2 < lines.length && /^\[(x|\s)?\]\s+/i.test(lines[i2])) {
+        const listItemNode = $createListItemNode();
+        const isChecked = /^\[x\]/i.test(lines[i2]);
+        const itemText = lines[i2].replace(/^\[(x|\s)?\]\s+/i, "");
+        if (itemText) {
+          const textNodes2 = processInlineMarkdown(itemText);
+          if (textNodes2.length > 0) {
+            textNodes2.forEach((node) => listItemNode.append(node));
+          } else {
+            listItemNode.append($createTextNode(itemText));
+          }
+        }
+        if (isChecked) {
+          listItemNode.setChecked(true);
+        }
+        listNode.append(listItemNode);
+        i2++;
+      }
+      nodes.push(listNode);
+      continue;
+    }
+    if (/^>\s*/.test(line)) {
+      const quoteNode = $createQuoteNode();
+      const quoteLines = [];
+      while (i2 < lines.length && /^>\s*/.test(lines[i2])) {
+        quoteLines.push(lines[i2].replace(/^>\s*/, ""));
+        i2++;
+      }
+      const quoteText = quoteLines.join("\n");
+      if (quoteText) {
+        const textNodes2 = processInlineMarkdown(quoteText);
+        if (textNodes2.length > 0) {
+          textNodes2.forEach((node) => quoteNode.append(node));
+        } else {
+          quoteNode.append($createTextNode(quoteText));
+        }
+      }
+      nodes.push(quoteNode);
+      continue;
+    }
+    const paragraph = $createParagraphNode();
+    const textNodes = processInlineMarkdown(line);
+    textNodes.forEach((node) => paragraph.append(node));
+    nodes.push(paragraph);
+    i2++;
+  }
+  return nodes;
+}
+function convertPlainTextToNodes(text) {
+  const nodes = [];
+  const paragraphs = text.split(/\n\n+/);
+  for (const para of paragraphs) {
+    if (para.trim() || para === "") {
+      const paragraph = $createParagraphNode();
+      const lines = para.split(/\n/);
+      lines.forEach((line, index2) => {
+        if (line) {
+          paragraph.append($createTextNode(line));
+        }
+        if (index2 < lines.length - 1) {
+          paragraph.append($createLineBreakNode());
+        }
+      });
+      if (paragraph.getChildrenSize() > 0) {
+        nodes.push(paragraph);
+      }
+    }
+  }
+  if (nodes.length === 0) {
+    nodes.push($createParagraphNode());
+  }
+  return nodes;
+}
+function applyMarkdownToNodes(nodes, _editor) {
+  const processTextNode = (node) => {
+    const text = node.getTextContent();
+    const style = node.getStyle();
+    const format = node.getFormat();
+    const markdownPattern = new RegExp("(```([^`]+)```)|(`([^`]+)`)|(\\*\\*(.+?)\\*\\*)|((?<!\\*)\\*([^*]+)\\*(?!\\*))|(~~(.+?)~~)", "g");
+    if (!markdownPattern.test(text)) {
+      return [node];
+    }
+    markdownPattern.lastIndex = 0;
+    const resultNodes = [];
+    let lastIndex = 0;
+    let match;
+    while ((match = markdownPattern.exec(text)) !== null) {
+      if (match.index > lastIndex) {
+        const beforeText = text.slice(lastIndex, match.index);
+        const beforeNode = $createTextNode(beforeText);
+        if (style)
+          beforeNode.setStyle(style);
+        if (format)
+          beforeNode.setFormat(format);
+        resultNodes.push(beforeNode);
+      }
+      let content = "";
+      let nodeFormat = format;
+      if (match[1]) {
+        content = match[2];
+        nodeFormat = format | 16;
+      } else if (match[3]) {
+        content = match[4];
+        nodeFormat = format | 16;
+      } else if (match[5]) {
+        content = match[6];
+        nodeFormat = format | 1;
+      } else if (match[7]) {
+        content = match[8];
+        nodeFormat = format | 2;
+      } else if (match[9]) {
+        content = match[10];
+        nodeFormat = format | 4;
+      }
+      if (content) {
+        const formattedNode = $createTextNode(content);
+        if (style)
+          formattedNode.setStyle(style);
+        formattedNode.setFormat(nodeFormat);
+        resultNodes.push(formattedNode);
+      }
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+      const afterText = text.slice(lastIndex);
+      const afterNode = $createTextNode(afterText);
+      if (style)
+        afterNode.setStyle(style);
+      if (format)
+        afterNode.setFormat(format);
+      resultNodes.push(afterNode);
+    }
+    return resultNodes.length > 0 ? resultNodes : [node];
+  };
+  const processNode2 = (node) => {
+    if ($isElementNode(node)) {
+      const children = node.getChildren();
+      for (let i2 = children.length - 1; i2 >= 0; i2--) {
+        const child = children[i2];
+        if ($isTextNode(child)) {
+          const replacementNodes = processTextNode(child);
+          if (replacementNodes.length > 1 || replacementNodes[0] !== child) {
+            for (const newNode of replacementNodes) {
+              child.insertBefore(newNode);
+            }
+            child.remove();
+          }
+        } else if ($isElementNode(child)) {
+          processNode2(child);
+        }
+      }
+    }
+  };
+  nodes.forEach((node) => processNode2(node));
+  return nodes;
+}
+function getNodeDOMPosition(editor) {
+  const domSelection = window.getSelection();
+  if (!domSelection || domSelection.rangeCount === 0) {
+    return null;
+  }
+  const range = domSelection.getRangeAt(0);
+  let rect = range.getBoundingClientRect();
+  if (rect.width === 0 && rect.height === 0) {
+    const anchorNode = domSelection.anchorNode;
+    if (anchorNode) {
+      const element = anchorNode.nodeType === Node.TEXT_NODE ? anchorNode.parentElement : anchorNode;
+      if (element) {
+        rect = element.getBoundingClientRect();
+      }
+    }
+  }
+  if (rect.right === 0 && rect.bottom === 0) {
+    const rootElement = editor.getRootElement();
+    if (rootElement) {
+      const rootRect = rootElement.getBoundingClientRect();
+      return {
+        x: rootRect.left + 20,
+        y: Math.min(rootRect.top + 100, window.innerHeight - 150)
+      };
+    }
+    return null;
+  }
+  return {
+    x: rect.right,
+    y: rect.bottom
+  };
+}
+function handleHorizontalRulePlaceholders(editor) {
+  editor.update(
+    () => {
+      const root2 = $getRoot();
+      const children = root2.getChildren();
+      for (const child of children) {
+        if ($isParagraphNode(child)) {
+          const textContent = child.getTextContent();
+          if (textContent === "___MARKDOWN_HR___") {
+            editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, void 0);
+            child.remove();
+          }
+        }
+      }
+    },
+    { tag: "paste-options" }
+  );
+}
+function PasteOptionsPlugin() {
+  const [editor] = useLexicalComposerContext();
+  const [pasteData, setPasteData] = useState$1(null);
+  const [currentMode, setCurrentMode] = useState$1("rich");
+  const [showMenu, setShowMenu] = useState$1(false);
+  const [menuPosition, setMenuPosition] = useState$1({ x: 0, y: 0 });
+  useEffect$1(() => {
+    if (!showMenu)
+      return;
+    const handleScroll2 = () => {
+      const newPosition = getNodeDOMPosition(editor);
+      if (newPosition) {
+        setMenuPosition(newPosition);
+        setPasteData(
+          (prev) => prev ? { ...prev, position: newPosition } : null
+        );
+      }
+    };
+    window.addEventListener("scroll", handleScroll2, true);
+    return () => window.removeEventListener("scroll", handleScroll2, true);
+  }, [editor, showMenu]);
+  useEffect$1(() => {
+    return editor.registerCommand(
+      KEY_ESCAPE_COMMAND,
+      () => {
+        if (showMenu) {
+          setShowMenu(false);
+          setPasteData(null);
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  }, [editor, showMenu]);
+  useEffect$1(() => {
+    if (!showMenu)
+      return;
+    const removeListener = editor.registerUpdateListener(
+      ({ tags, dirtyElements, dirtyLeaves }) => {
+        if (!tags.has("paste") && !tags.has("history-merge") && !tags.has("paste-options")) {
+          if (dirtyElements.size > 0 || dirtyLeaves.size > 0) {
+            setShowMenu(false);
+            setPasteData(null);
+          }
+        }
+      }
+    );
+    return removeListener;
+  }, [editor, showMenu]);
+  useEffect$1(() => {
+    const handlePaste = (event) => {
+      const clipboardData = event.clipboardData;
+      if (!clipboardData)
+        return;
+      const html = clipboardData.getData("text/html");
+      const plain = clipboardData.getData("text/plain");
+      if (!html && !plain)
+        return;
+      if (htmlContainsImages(html)) {
+        return;
+      }
+      const isPlainTextPaste = !html && plain;
+      const initialMode = isPlainTextPaste ? "plain" : "rich";
+      setTimeout(() => {
+        editor.getEditorState().read(() => {
+          const selection = $getSelection();
+          if (!$isRangeSelection(selection))
+            return;
+          const position = getNodeDOMPosition(editor);
+          if (!position)
+            return;
+          setPasteData({
+            html,
+            plain,
+            position,
+            initialMode
+          });
+          setCurrentMode(initialMode);
+          setMenuPosition(position);
+          setShowMenu(true);
+        });
+      }, 150);
+    };
+    const rootElement = editor.getRootElement();
+    if (rootElement) {
+      rootElement.addEventListener("paste", handlePaste);
+      return () => rootElement.removeEventListener("paste", handlePaste);
+    }
+  }, [editor]);
+  const handleSelectMode = useCallback(
+    (mode) => {
+      if (!pasteData) {
+        return;
+      }
+      if (mode === currentMode) {
+        setShowMenu(false);
+        setPasteData(null);
+        return;
+      }
+      editor.dispatchCommand(UNDO_COMMAND, void 0);
+      setTimeout(() => {
+        editor.update(
+          () => {
+            const selection = $getSelection();
+            if (!$isRangeSelection(selection))
+              return;
+            let nodes = [];
+            if (mode === "plain") {
+              nodes = convertPlainTextToNodes(pasteData.plain);
+            } else if (mode === "markdown") {
+              if (pasteData.html) {
+                nodes = convertHTMLToNodesWithStyles(pasteData.html, editor);
+                nodes = applyMarkdownToNodes(nodes);
+              } else {
+                nodes = convertMarkdownToNodes(pasteData.plain);
+              }
+            } else if (mode === "rich") {
+              if (pasteData.html) {
+                const parser = new DOMParser();
+                const doc = parser.parseFromString(pasteData.html, "text/html");
+                nodes = $generateNodesFromDOM(editor, doc);
+              } else {
+                nodes = convertPlainTextToNodes(pasteData.plain);
+              }
+            }
+            if (nodes.length > 0) {
+              const filteredNodes = nodes.filter((node) => {
+                const textContent = node.getTextContent();
+                return textContent.trim().length > 0 || node.getType() !== "paragraph";
+              });
+              if (filteredNodes.length > 0) {
+                selection.insertNodes(filteredNodes);
+              } else if (nodes.length > 0) {
+                selection.insertNodes(nodes);
+              }
+            }
+          },
+          { tag: "paste-options" }
+        );
+        if (mode === "markdown") {
+          setTimeout(() => {
+            handleHorizontalRulePlaceholders(editor);
+          }, 50);
+        }
+      }, 50);
+      setCurrentMode(mode);
+      setShowMenu(false);
+      setPasteData(null);
+    },
+    [editor, pasteData, currentMode]
+  );
+  const handleClose = useCallback(() => {
+    setShowMenu(false);
+    setPasteData(null);
+  }, []);
+  if (!showMenu || !pasteData) {
+    return null;
+  }
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      PasteOptionsMenu,
+      {
+        position: menuPosition,
+        currentMode,
+        onSelectMode: handleSelectMode,
+        onClose: handleClose,
+        hasHtml: Boolean(pasteData.html)
+      }
+    ),
+    document.body
+  );
+}
 function getOptionMeta(label) {
   const lower = label.toLowerCase();
   if (lower.startsWith("paragraph"))
@@ -34721,6 +36265,7 @@ function TableActionMenu({
     },
     [editor, tableCellNode]
   );
+  const menuItemClass = " cteditor-group cteditor-flex cteditor-items-center cteditor-gap-1.5 cteditor-px-2 cteditor-py-1 cteditor-rounded-sm cteditor-transition-all cteditor-duration-200 cteditor-cursor-pointer cteditor-text-xs hover:cteditor-bg-foreground/10";
   let mergeCellButton = null;
   if (cellMerge) {
     if (canMergeCells) {
@@ -34728,10 +36273,10 @@ function TableActionMenu({
         "button",
         {
           type: "button",
-          className: "item",
+          className: menuItemClass,
           onClick: () => mergeTableCellsAtSelection(),
           "data-test-id": "table-merge-cells",
-          children: /* @__PURE__ */ jsx("span", { className: "cteditor-text-[11px] cteditor-text-muted-foreground cteditor-font-medium cteditor-tracking-wider cteditor-block cteditor-pb-1", children: "Merge cells" })
+          children: /* @__PURE__ */ jsx("span", { className: "text", children: "Merge cells" })
         }
       );
     } else if (canUnmergeCell) {
@@ -34739,15 +36284,14 @@ function TableActionMenu({
         "button",
         {
           type: "button",
-          className: "item",
+          className: menuItemClass,
           onClick: () => unmergeTableCellsAtSelection(),
           "data-test-id": "table-unmerge-cells",
-          children: /* @__PURE__ */ jsx("span", { className: "cteditor-text-[11px] cteditor-text-muted-foreground cteditor-font-medium cteditor-tracking-wider cteditor-block cteditor-pb-1", children: "Unmerge cells" })
+          children: /* @__PURE__ */ jsx("span", { className: "text", children: "Unmerge cells" })
         }
       );
     }
   }
-  const menuItemClass = " cteditor-group cteditor-flex cteditor-items-center cteditor-gap-1.5 cteditor-px-2 cteditor-py-1 cteditor-rounded-sm cteditor-transition-all cteditor-duration-200 cteditor-cursor-pointer cteditor-text-xs hover:cteditor-bg-foreground/10";
   return createPortal(
     /* @__PURE__ */ jsxs(
       "div",
@@ -37419,9 +38963,57 @@ function processHtmlForExport(html, tableStyleMap, codeBlockStyles) {
   const wrapper = doc.createElement("div");
   wrapper.style.padding = "1em";
   wrapper.style.minHeight = "100%";
+  wrapper.className = "editor-content-wrapper";
+  const styleTag = doc.createElement("style");
+  styleTag.textContent = `
+    /* Responsive image styles - WYSIWYG for mobile */
+    @media screen and (max-width: 768px) {
+      /* Floated images stack on mobile - no text wrap */
+      .image-float-left,
+      .image-float-right,
+      img[style*="float: left"],
+      img[style*="float: right"] {
+        float: none !important;
+        clear: both !important;
+        display: block !important;
+        margin: 1em auto !important;
+        max-width: 100% !important;
+        /* On mobile, allow width to shrink but keep height proportional to width */
+        width: auto !important;
+        height: auto !important;
+      }
+
+      /* Floated image containers (with captions) also stack */
+      .image-float-container,
+      .image-float-container-left,
+      .image-float-container-right,
+      p[style*="float: left"],
+      p[style*="float: right"] {
+        float: none !important;
+        clear: both !important;
+        max-width: 100% !important;
+        margin: 1em 0 !important;
+      }
+
+      /* Clear floats properly */
+      .editor-content-wrapper::after {
+        content: "";
+        display: table;
+        clear: both;
+      }
+    }
+
+    /* Clearfix for floated content */
+    .editor-content-wrapper::after {
+      content: "";
+      display: table;
+      clear: both;
+    }
+  `;
   while (doc.body.firstChild) {
     wrapper.appendChild(doc.body.firstChild);
   }
+  wrapper.insertBefore(styleTag, wrapper.firstChild);
   return wrapper.outerHTML;
 }
 function cleanupHeaderCellStructure(container) {
@@ -37492,12 +39084,21 @@ function applyGenericSafeStyles(container, codeBlockStyles) {
   container.querySelectorAll("img").forEach((img) => {
     const position = img.getAttribute("data-position");
     const parent = img.parentElement;
-    img.style.cssText += "; max-width: 100%; height: auto;";
+    const explicitWidth = img.getAttribute("width");
+    const explicitHeight = img.getAttribute("height");
+    const hasExplicitDimensions = explicitWidth && explicitHeight && explicitWidth !== "inherit" && explicitHeight !== "inherit";
+    if (hasExplicitDimensions) {
+      img.style.cssText += `; max-width: 100%; width: ${explicitWidth}px; height: ${explicitHeight}px;`;
+    } else {
+      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";
+      img.classList.add("image-float-" + floatDir);
       if (hasCaption && parent) {
+        parent.classList.add("image-float-container", "image-float-container-" + floatDir);
         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");
@@ -37509,10 +39110,20 @@ function applyGenericSafeStyles(container, codeBlockStyles) {
       }
     } else if (position === "full") {
       img.style.cssText += "; display: block; width: 100%; margin: 1em 0;";
+    } else if (position === "inline-left") {
+      img.classList.add("image-inline-left");
+      img.style.cssText += "; display: block; margin: 1em 0; text-align: left;";
+    } else if (position === "inline-center") {
+      img.classList.add("image-inline-center");
+      img.style.cssText += "; display: block; margin: 1em auto;";
+    } else if (position === "inline-right") {
+      img.classList.add("image-inline-right");
+      img.style.cssText += "; display: block; margin: 1em 0 1em auto;";
     } else {
-      img.style.cssText += "; display: block;";
+      img.style.cssText += "; display: inline-block; vertical-align: middle;";
       if (parent && parent.style.textAlign === "center") {
         img.style.margin = "0 auto";
+        img.style.display = "block";
       }
     }
     img.removeAttribute("data-position");
@@ -37864,24 +39475,52 @@ function preprocessInitialContent(html) {
   });
   const images = doc.querySelectorAll("img");
   images.forEach((img) => {
+    const htmlImg = 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");
+    if (htmlImg.classList.contains("image-inline-left")) {
+      img.setAttribute("data-position", "inline-left");
+      htmlImg.classList.remove("image-inline-left");
+    } else if (htmlImg.classList.contains("image-inline-center")) {
+      img.setAttribute("data-position", "inline-center");
+      htmlImg.classList.remove("image-inline-center");
+    } else if (htmlImg.classList.contains("image-inline-right")) {
+      img.setAttribute("data-position", "inline-right");
+      htmlImg.classList.remove("image-inline-right");
+    } else if (htmlImg.classList.contains("image-float-left")) {
+      img.setAttribute("data-position", "left");
+      htmlImg.classList.remove("image-float-left");
+    } else if (htmlImg.classList.contains("image-float-right")) {
+      img.setAttribute("data-position", "right");
+      htmlImg.classList.remove("image-float-right");
+    } else {
+      const imgFloat = htmlImg.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");
+        }
+      } else {
+        const margin = htmlImg.style.margin;
+        if (margin === "1em auto" || htmlImg.style.marginLeft === "auto" && htmlImg.style.marginRight === "auto") {
+          img.setAttribute("data-position", "inline-center");
+        } else if (htmlImg.style.marginLeft === "auto" && htmlImg.style.marginRight !== "auto") {
+          img.setAttribute("data-position", "inline-right");
+        }
       }
     }
+    if (parent.classList.contains("image-float-container")) {
+      parent.classList.remove("image-float-container", "image-float-container-left", "image-float-container-right");
+    }
   });
   const styledElements = doc.querySelectorAll("span[style], b[style], strong[style], i[style], em[style]");
   styledElements.forEach((el) => {
@@ -38561,6 +40200,7 @@ const ConfigurableEditor = ({
         /* @__PURE__ */ jsx(CodeBlockNormalizerPlugin, {}),
         /* @__PURE__ */ jsx(CodeBlockSelectAllPlugin, {}),
         /* @__PURE__ */ jsx(SlashCommandPlugin, {}),
+        /* @__PURE__ */ jsx(MarkdownShortcutsPlugin, {}),
         /* @__PURE__ */ jsx(CombinedPluginWrapper, {}),
         /* @__PURE__ */ jsx(OnChangeWrapper, { onChange }),
         /* @__PURE__ */ jsx(InitialContentPlugin, { initialContent }),
@@ -38571,6 +40211,7 @@ const ConfigurableEditor = ({
         /* @__PURE__ */ jsx(LinkPreviewPlugin, {}),
         /* @__PURE__ */ jsx(DragDropPaste, {}),
         /* @__PURE__ */ jsx(RichTextPastePlugin, {}),
+        /* @__PURE__ */ jsx(PasteOptionsPlugin, {}),
         /* @__PURE__ */ jsx(FilePlugin, {}),
         /* @__PURE__ */ jsx(HorizontalRulePlugin, {}),
         /* @__PURE__ */ jsx(CustomHorizontalRulePlugin, {}),
@@ -38759,11 +40400,12 @@ const ConfigurableEditorWithAuth = ({
 };
 export {
   $isFileNode as $,
-  AiJsonResponse as A,
+  AlignLeft as A,
   Button as B,
   ConfigurableEditorWithAuth as C,
   Download as D,
   ExternalLink as E,
+  FileText as F,
   HtmlViewProvider as H,
   LocalStoragePlugin$1 as L,
   Sparkles as S,
@@ -38779,12 +40421,16 @@ export {
   DialogFooter as i,
   initialConfig as j,
   $isImageNode as k,
-  EditorProvider as l,
-  useEditor as m,
-  ConfigurableEditor as n,
-  editorConfig as o,
+  AlignCenter as l,
+  AlignRight as m,
+  Type as n,
+  AiJsonResponse as o,
+  EditorProvider as p,
+  useEditor as q,
+  ConfigurableEditor as r,
+  editorConfig as s,
   toast as t,
   useHtmlView as u,
   verifyApiKey as v
 };
-//# sourceMappingURL=index-d1d21414.js.map
+//# sourceMappingURL=index-0533674e.js.map