@tarviks/lexical-rich-editor 1.2.1 → 1.3.0

package/dist/index.js

@@ -9,7 +9,6 @@ var useLexicalNodeSelection = require('@lexical/react/useLexicalNodeSelection');
 var lexical = require('lexical');
 var react = require('@fluentui/react');
 var reactComponents = require('@fluentui/react-components');
-var reactIcons = require('@fluentui/react-icons');
 var code = require('@lexical/code');
 var link = require('@lexical/link');
 var list = require('@lexical/list');
@@ -25,8 +24,8 @@ var LexicalRichTextPlugin = require('@lexical/react/LexicalRichTextPlugin');
 var LexicalTablePlugin = require('@lexical/react/LexicalTablePlugin');
 var richText = require('@lexical/rich-text');
 var table = require('@lexical/table');
-var LexicalBlockWithAlignableContents = require('@lexical/react/LexicalBlockWithAlignableContents');
 var LexicalDecoratorBlockNode = require('@lexical/react/LexicalDecoratorBlockNode');
+var reactIcons = require('@fluentui/react-icons');
 var selection = require('@lexical/selection');
 var reactDom = require('react-dom');
 var html = require('@lexical/html');
@@ -544,17 +543,6 @@ var init_ImageComponent = __esm({
             onClick,
             lexical.COMMAND_PRIORITY_LOW
           ),
-          editor.registerCommand(
-            lexical.DRAGSTART_COMMAND,
-            (event) => {
-              if (event.target === imageRef.current) {
-                event.preventDefault();
-                return true;
-              }
-              return false;
-            },
-            lexical.COMMAND_PRIORITY_LOW
-          ),
           editor.registerCommand(
             lexical.KEY_DELETE_COMMAND,
             $onDelete,
@@ -612,36 +600,44 @@ var init_ImageComponent = __esm({
       const onResizeStart = () => {
         setIsResizing(true);
       };
-      const draggable = isSelected && lexical.$isNodeSelection(selection) && !isResizing;
+      const draggable = !isResizing;
       const isFocused = (isSelected || isResizing) && isEditable;
-      return /* @__PURE__ */ jsxRuntime.jsx(React9.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { draggable, children: isLoadError ? /* @__PURE__ */ jsxRuntime.jsx(BrokenImage, {}) : /* @__PURE__ */ jsxRuntime.jsx(
-          LazyImage,
-          {
-            className: isFocused ? `focused ${lexical.$isNodeSelection(selection) ? "draggable" : ""}` : null,
-            src,
-            altText,
-            imageRef,
-            width,
-            height,
-            maxWidth,
-            onError: () => setIsLoadError(true)
-          }
-        ) }),
-        resizable && lexical.$isNodeSelection(selection) && isFocused && /* @__PURE__ */ jsxRuntime.jsx(
-          ImageResizer_default,
-          {
-            showCaption,
-            setShowCaption,
-            editor,
-            buttonRef,
-            imageRef,
-            onResizeStart,
-            onResizeEnd,
-            captionsEnabled: !isLoadError && captionsEnabled
-          }
-        )
-      ] }) });
+      return /* @__PURE__ */ jsxRuntime.jsx(React9.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          draggable,
+          style: { position: "relative", display: "inline-block" },
+          children: [
+            isLoadError ? /* @__PURE__ */ jsxRuntime.jsx(BrokenImage, {}) : /* @__PURE__ */ jsxRuntime.jsx(
+              LazyImage,
+              {
+                className: isFocused ? `focused ${lexical.$isNodeSelection(selection) ? "draggable" : ""}` : null,
+                src,
+                altText,
+                imageRef,
+                width,
+                height,
+                maxWidth,
+                onError: () => setIsLoadError(true)
+              }
+            ),
+            resizable && lexical.$isNodeSelection(selection) && isFocused && /* @__PURE__ */ jsxRuntime.jsx(
+              ImageResizer_default,
+              {
+                showCaption,
+                setShowCaption,
+                editor,
+                buttonRef,
+                imageRef,
+                maxWidth,
+                onResizeStart,
+                onResizeEnd,
+                captionsEnabled: !isLoadError && captionsEnabled
+              }
+            )
+          ]
+        }
+      ) });
     };
     ImageComponent_default = ImageComponent;
   }
@@ -786,9 +782,6 @@ var init_ImageNode = __esm({
         const writable = this.getWritable();
         writable.__width = width;
         writable.__height = height;
-        if (typeof width === "number" && width > writable.__maxWidth) {
-          writable.__maxWidth = width;
-        }
       }
       setShowCaption(showCaption) {
         const writable = this.getWritable();
@@ -915,35 +908,13 @@ var init_InlineImageComponent = __esm({
     };
     InlineImageComponent = ({ src, altText, nodeKey, width, height, showCaption, caption, position }) => {
       const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection.useLexicalNodeSelection(nodeKey);
+      const [isResizing, setIsResizing] = React9.useState(false);
       const [selection, setSelection] = React9.useState(null);
       const activeEditorRef = React9.useRef(null);
       const imageRef = React9.useRef(null);
       const buttonRef = React9.useRef(null);
       const [editor] = LexicalComposerContext.useLexicalComposerContext();
       const isEditable = useLexicalEditable.useLexicalEditable();
-      const [isResizing, setIsResizing] = React9.useState(false);
-      const onResizeEnd = (nextWidth, nextHeight) => {
-        setTimeout(() => {
-          setIsResizing(false);
-        }, 200);
-        editor.update(() => {
-          const node = lexical.$getNodeByKey(nodeKey);
-          if ($isInlineImageNode(node)) {
-            node.setWidthAndHeight(nextWidth, nextHeight);
-          }
-        });
-      };
-      const onResizeStart = () => {
-        setIsResizing(true);
-      };
-      const setShowCaption = (show) => {
-        editor.update(() => {
-          const node = lexical.$getNodeByKey(nodeKey);
-          if ($isInlineImageNode(node)) {
-            node.setShowCaption(show);
-          }
-        });
-      };
       const $onDelete = React9.useCallback(
         (payload) => {
           const deleteSelection = lexical.$getSelection();
@@ -999,6 +970,25 @@ var init_InlineImageComponent = __esm({
         },
         [caption, editor, setSelected]
       );
+      const onClick = React9.useCallback(
+        (payload) => {
+          const event = payload;
+          if (isResizing) {
+            return true;
+          }
+          if (event.target === imageRef.current) {
+            if (event.shiftKey) {
+              setSelected(!isSelected);
+            } else {
+              clearSelection();
+              setSelected(true);
+            }
+            return true;
+          }
+          return false;
+        },
+        [isResizing, isSelected, setSelected, clearSelection]
+      );
       React9.useEffect(() => {
         let isMounted = true;
         const unregister = utils.mergeRegister(
@@ -1017,51 +1007,13 @@ var init_InlineImageComponent = __esm({
           ),
           editor.registerCommand(
             lexical.CLICK_COMMAND,
-            (payload) => {
-              const event = payload;
-              if (isResizing) {
-                return true;
-              }
-              if (event.target === imageRef.current) {
-                if (event.shiftKey) {
-                  setSelected(!isSelected);
-                } else {
-                  clearSelection();
-                  setSelected(true);
-                }
-                return true;
-              }
-              return false;
-            },
-            lexical.COMMAND_PRIORITY_LOW
-          ),
-          editor.registerCommand(
-            lexical.DRAGSTART_COMMAND,
-            (event) => {
-              if (event.target === imageRef.current) {
-                event.preventDefault();
-                return true;
-              }
-              return false;
-            },
-            lexical.COMMAND_PRIORITY_LOW
-          ),
-          editor.registerCommand(
-            lexical.KEY_DELETE_COMMAND,
-            $onDelete,
-            lexical.COMMAND_PRIORITY_LOW
-          ),
-          editor.registerCommand(
-            lexical.KEY_BACKSPACE_COMMAND,
-            $onDelete,
+            onClick,
             lexical.COMMAND_PRIORITY_LOW
           ),
+          editor.registerCommand(lexical.KEY_DELETE_COMMAND, $onDelete, lexical.COMMAND_PRIORITY_LOW),
+          editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, $onDelete, lexical.COMMAND_PRIORITY_LOW),
           editor.registerCommand(lexical.KEY_ENTER_COMMAND, $onEnter, lexical.COMMAND_PRIORITY_LOW),
-          editor.registerCommand(
-            lexical.KEY_ESCAPE_COMMAND,
-            $onEscape,
-            lexical.COMMAND_PRIORITY_LOW
-          )
+          editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, $onEscape, lexical.COMMAND_PRIORITY_LOW)
         );
         return () => {
           isMounted = false;
@@ -1076,12 +1028,27 @@ var init_InlineImageComponent = __esm({
         $onDelete,
         $onEnter,
         $onEscape,
+        onClick,
         setSelected
       ]);
-      const draggable = isSelected && lexical.$isNodeSelection(selection) && !isResizing;
+      const onResizeStart = () => {
+        setIsResizing(true);
+      };
+      const onResizeEnd = (nextWidth, nextHeight) => {
+        setTimeout(() => {
+          setIsResizing(false);
+        }, 200);
+        editor.update(() => {
+          const node = lexical.$getNodeByKey(nodeKey);
+          if ($isInlineImageNode(node)) {
+            node.setWidthAndHeight(nextWidth, nextHeight);
+          }
+        });
+      };
+      const draggable = !isResizing;
       const isFocused = (isSelected || isResizing) && isEditable;
-      return /* @__PURE__ */ jsxRuntime.jsx(React9.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx("span", { draggable, children: /* @__PURE__ */ jsxRuntime.jsx(
+      return /* @__PURE__ */ jsxRuntime.jsx(React9.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsxs("span", { draggable, style: { position: "relative", display: "inline-block" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
           LazyImage2,
           {
             className: isFocused ? `focused ${lexical.$isNodeSelection(selection) ? "draggable" : ""}` : null,
@@ -1092,18 +1059,19 @@ var init_InlineImageComponent = __esm({
             height,
             position
           }
-        ) }),
-        isFocused && lexical.$isNodeSelection(selection) && /* @__PURE__ */ jsxRuntime.jsx(
+        ),
+        lexical.$isNodeSelection(selection) && isFocused && /* @__PURE__ */ jsxRuntime.jsx(
           ImageResizer_default,
           {
-            showCaption,
-            setShowCaption,
+            showCaption: false,
+            setShowCaption: () => {
+            },
+            captionsEnabled: false,
             editor,
             buttonRef,
             imageRef,
             onResizeStart,
-            onResizeEnd,
-            captionsEnabled: false
+            onResizeEnd
           }
         )
       ] }) });
@@ -1294,6 +1262,19 @@ var ContentEditorLevel = /* @__PURE__ */ ((ContentEditorLevel2) => {
   ContentEditorLevel2["Pro"] = "pro";
   return ContentEditorLevel2;
 })(ContentEditorLevel || {});
+var DEFAULT_VALIDATION_MESSAGES = {
+  required: "This field is required.",
+  minWords: (current, min) => `Minimum ${min} word${min === 1 ? "" : "s"} required (${current} entered).`,
+  maxWords: (current, max) => `Word limit exceeded: ${current} / ${max} words.`,
+  minChars: (current, min) => `Minimum ${min} character${min === 1 ? "" : "s"} required (${current} entered).`,
+  maxChars: (current, max) => `Character limit exceeded: ${current} / ${max} characters.`,
+  noImages: "Images are not allowed in this field.",
+  maxImages: (current, max) => `Too many images: ${current} / ${max} allowed.`,
+  noLinks: "Hyperlinks are not allowed in this field.",
+  maxLinks: (current, max) => `Too many links: ${current} / ${max} allowed.`,
+  noTables: "Tables are not allowed in this field.",
+  imageTooLarge: (fileMB, maxMB) => `Image size (${fileMB.toFixed(1)} MB) exceeds the ${maxMB} MB limit.`
+};
 
 // src/Types/PageSetup.ts
 var DEFAULT_PAGE_SETUP = {
@@ -1334,6 +1315,106 @@ function resolvePageCanvasMetrics(value) {
     paddingPx: Math.round(margin.valueIn * CSS_PX_PER_INCH)
   };
 }
+lexical.createCommand(
+  "INSERT_ALPHA_LIST_COMMAND"
+);
+var AlphaListNode = class _AlphaListNode extends list.ListNode {
+  static getType() {
+    return "alpha-list";
+  }
+  static clone(node) {
+    return new _AlphaListNode(node.getStart(), node.__key);
+  }
+  constructor(start = 1, key) {
+    super("number", start, key);
+    this.__listType = "lower-alpha";
+  }
+  createDOM(config, _editor) {
+    const element = document.createElement("ol");
+    element.setAttribute("type", "a");
+    if (this.getStart() !== 1) element.setAttribute("start", String(this.getStart()));
+    element.style.listStyleType = "lower-alpha";
+    const olClass = config.theme?.list?.ol;
+    if (olClass) element.className = olClass;
+    return element;
+  }
+  updateDOM() {
+    return false;
+  }
+  exportDOM(_editor) {
+    const element = document.createElement("ol");
+    element.setAttribute("type", "a");
+    if (this.getStart() !== 1) element.setAttribute("start", String(this.getStart()));
+    element.style.listStyleType = "lower-alpha";
+    return { element };
+  }
+  static importDOM() {
+    return {
+      ol: (domNode) => {
+        if (domNode instanceof HTMLOListElement && (domNode.getAttribute("type") === "a" || domNode.style.listStyleType === "lower-alpha")) {
+          return { conversion: convertAlphaOL, priority: 1 };
+        }
+        return null;
+      }
+    };
+  }
+  exportJSON() {
+    const base = super.exportJSON();
+    return {
+      ...base,
+      type: "alpha-list",
+      listType: "lower-alpha",
+      tag: "ol",
+      version: 1,
+      start: this.getStart()
+    };
+  }
+  static importJSON(serialized) {
+    return new _AlphaListNode(serialized.start ?? 1);
+  }
+};
+function convertAlphaOL(domNode) {
+  const start = domNode instanceof HTMLOListElement ? parseInt(domNode.getAttribute("start") || "1", 10) || 1 : 1;
+  return { node: $createAlphaListNode(start) };
+}
+function $createAlphaListNode(start = 1) {
+  return new AlphaListNode(start);
+}
+function $isAlphaListNode(node) {
+  return node instanceof AlphaListNode;
+}
+function $toggleAlphaList() {
+  const selection = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(selection)) return;
+  const anchor = selection.anchor.getNode();
+  const currentList = utils.$findMatchingParent(anchor, list.$isListNode);
+  if ($isAlphaListNode(currentList)) {
+    list.$removeList();
+    return;
+  }
+  list.$insertList("number");
+  const sel2 = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(sel2)) return;
+  const newAnchor = sel2.anchor.getNode();
+  const newList = utils.$findMatchingParent(newAnchor, (n) => list.$isListNode(n) && !$isAlphaListNode(n));
+  if (!newList || !list.$isListNode(newList)) return;
+  const start = newList.getStart();
+  const formatType = typeof newList.getFormatType === "function" ? newList.getFormatType() : void 0;
+  const alpha = $createAlphaListNode(start);
+  for (const child of newList.getChildren()) {
+    alpha.append(child);
+  }
+  newList.replace(alpha);
+  if (formatType && typeof alpha.setFormat === "function") {
+    alpha.setFormat(formatType);
+  }
+  const firstItem = alpha.getFirstChild();
+  if (list.$isListItemNode(firstItem)) {
+    firstItem.selectStart();
+  } else {
+    alpha.select();
+  }
+}
 var AutocompleteNode = class _AutocompleteNode extends lexical.TextNode {
   static getType() {
     return "autocomplete";
@@ -1344,6 +1425,13 @@ var AutocompleteNode = class _AutocompleteNode extends lexical.TextNode {
   static importJSON(serializedNode) {
     return new _AutocompleteNode(serializedNode.text, serializedNode.uuid);
   }
+  // AutocompleteNode is excluded from copy via excludeFromCopy(), so it is
+  // never placed on the clipboard and never needs to be reconstructed from
+  // HTML.  Returning null here satisfies Lexical's exportDOM/importDOM
+  // contract check and silences the console warning.
+  static importDOM() {
+    return null;
+  }
   exportJSON() {
     return { ...super.exportJSON(), uuid: this.__uuid };
   }
@@ -1658,13 +1746,20 @@ function VideoResizer({
       const dy = ev.clientY - rs.startY;
       let newW = rs.startW;
       let newH = rs.startH;
-      if (dir === "se") {
+      if (dir === "se" || dir === "ne") {
         newW = Math.max(MIN_WIDTH, rs.startW + dx);
         newH = newW / rs.ratio;
+      } else if (dir === "nw" || dir === "sw") {
+        newW = Math.max(MIN_WIDTH, rs.startW - dx);
+        newH = newW / rs.ratio;
       } else if (dir === "e") {
         newW = Math.max(MIN_WIDTH, rs.startW + dx);
+      } else if (dir === "w") {
+        newW = Math.max(MIN_WIDTH, rs.startW - dx);
       } else if (dir === "s") {
         newH = Math.max(MIN_HEIGHT, rs.startH + dy);
+      } else if (dir === "n") {
+        newH = Math.max(MIN_HEIGHT, rs.startH - dy);
       }
       container.style.width = `${newW}px`;
       container.style.height = `${newH}px`;
@@ -1684,13 +1779,23 @@ function VideoResizer({
     /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
-        style: {
-          ...handleBase,
-          top: "50%",
-          right: -5,
-          transform: "translateY(-50%)",
-          cursor: "ew-resize"
-        },
+        style: { ...handleBase, top: -5, left: "50%", transform: "translateX(-50%)", cursor: "n-resize" },
+        onPointerDown: (e) => startResize(e, "n"),
+        title: "Resize height"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: { ...handleBase, top: -5, right: -5, cursor: "ne-resize" },
+        onPointerDown: (e) => startResize(e, "ne"),
+        title: "Resize (proportional)"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: { ...handleBase, top: "50%", right: -5, transform: "translateY(-50%)", cursor: "ew-resize" },
         onPointerDown: (e) => startResize(e, "e"),
         title: "Resize width"
       }
@@ -1698,13 +1803,15 @@ function VideoResizer({
     /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
-        style: {
-          ...handleBase,
-          bottom: -5,
-          left: "50%",
-          transform: "translateX(-50%)",
-          cursor: "ns-resize"
-        },
+        style: { ...handleBase, bottom: -5, right: -5, cursor: "se-resize" },
+        onPointerDown: (e) => startResize(e, "se"),
+        title: "Resize (proportional)"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: { ...handleBase, bottom: -5, left: "50%", transform: "translateX(-50%)", cursor: "s-resize" },
         onPointerDown: (e) => startResize(e, "s"),
         title: "Resize height"
       }
@@ -1712,15 +1819,30 @@ function VideoResizer({
     /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
-        style: { ...handleBase, bottom: -5, right: -5, cursor: "se-resize" },
-        onPointerDown: (e) => startResize(e, "se"),
+        style: { ...handleBase, bottom: -5, left: -5, cursor: "sw-resize" },
+        onPointerDown: (e) => startResize(e, "sw"),
+        title: "Resize (proportional)"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: { ...handleBase, top: "50%", left: -5, transform: "translateY(-50%)", cursor: "ew-resize" },
+        onPointerDown: (e) => startResize(e, "w"),
+        title: "Resize width"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: { ...handleBase, top: -5, left: -5, cursor: "nw-resize" },
+        onPointerDown: (e) => startResize(e, "nw"),
         title: "Resize (proportional)"
       }
     )
   ] });
 }
 function YouTubeComponent({
-  className,
   format,
   nodeKey,
   videoID,
@@ -1728,9 +1850,48 @@ function YouTubeComponent({
   height,
   editor
 }) {
+  const wrapperRef = React9__namespace.useRef(null);
   const containerRef = React9__namespace.useRef(null);
+  const iframeRef = React9__namespace.useRef(null);
+  const isResizingRef = React9__namespace.useRef(false);
+  const [isNodeSelected, setNodeSelected, clearNodeSelection] = useLexicalNodeSelection.useLexicalNodeSelection(nodeKey);
   const [isHovered, setIsHovered] = React9__namespace.useState(false);
   const [isResizing, setIsResizing] = React9__namespace.useState(false);
+  const [isPlaying, setIsPlaying] = React9__namespace.useState(false);
+  React9__namespace.useEffect(() => {
+    return utils.mergeRegister(
+      editor.registerCommand(
+        lexical.FORMAT_ELEMENT_COMMAND,
+        (formatType) => {
+          if (isNodeSelected) {
+            editor.update(() => {
+              const node = lexical.$getNodeByKey(nodeKey);
+              if ($isYouTubeNode(node)) node.setFormat(formatType);
+            });
+            return true;
+          }
+          return false;
+        },
+        lexical.COMMAND_PRIORITY_LOW
+      ),
+      // Select this node on click.  When the thumbnail is shown the <img> is
+      // in the parent DOM so CLICK_COMMAND fires naturally.  When the iframe is
+      // live, clicks land in the iframe's browsing context — the node stays
+      // selected via wrapperRef boundary detection on the wrapper div.
+      editor.registerCommand(
+        lexical.CLICK_COMMAND,
+        (event) => {
+          if (wrapperRef.current?.contains(event.target)) {
+            if (!event.shiftKey) clearNodeSelection();
+            setNodeSelected(true);
+            return true;
+          }
+          return false;
+        },
+        lexical.COMMAND_PRIORITY_LOW
+      )
+    );
+  }, [editor, isNodeSelected, nodeKey, clearNodeSelection, setNodeSelected]);
   const handleDelete = (e) => {
     e.preventDefault();
     e.stopPropagation();
@@ -1739,72 +1900,173 @@ function YouTubeComponent({
       node?.remove();
     });
   };
+  const handleResizeStart = () => {
+    isResizingRef.current = true;
+    setIsResizing(true);
+    if (iframeRef.current) iframeRef.current.style.pointerEvents = "none";
+  };
   const handleResizeEnd = (w, h) => {
+    isResizingRef.current = false;
     setIsResizing(false);
+    if (iframeRef.current) iframeRef.current.style.pointerEvents = "";
+    setIsHovered(true);
     editor.update(() => {
       const node = lexical.$getNodeByKey(nodeKey);
-      if ($isYouTubeNode(node)) {
-        node.setSize(Math.round(w), Math.round(h));
-      }
+      if ($isYouTubeNode(node)) node.setSize(Math.round(w), Math.round(h));
     });
   };
-  return /* @__PURE__ */ jsxRuntime.jsx(LexicalBlockWithAlignableContents.BlockWithAlignableContents, { className, format, nodeKey, children: /* @__PURE__ */ jsxRuntime.jsxs(
+  const actionBtnStyle = (side) => ({
+    position: "absolute",
+    top: 8,
+    [side]: 8,
+    width: 28,
+    height: 28,
+    borderRadius: "50%",
+    background: "rgba(0,0,0,0.65)",
+    color: "#fff",
+    border: "none",
+    cursor: "pointer",
+    fontSize: side === "right" ? 18 : 14,
+    lineHeight: 1,
+    padding: 0,
+    zIndex: 10,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: wrapperRef, style: { display: "block", textAlign: format || void 0 }, children: /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
       ref: containerRef,
-      style: { position: "relative", display: "inline-block", width, height, lineHeight: 0 },
+      style: {
+        position: "relative",
+        display: "inline-block",
+        width,
+        height,
+        lineHeight: 0,
+        outline: isNodeSelected ? "2px solid #0078d4" : void 0,
+        outlineOffset: 2
+      },
       onMouseEnter: () => setIsHovered(true),
       onMouseLeave: () => {
-        if (!isResizing) setIsHovered(false);
+        if (!isResizingRef.current) setIsHovered(false);
       },
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "iframe",
-          {
-            width: "100%",
-            height: "100%",
-            src: `https://www.youtube.com/embed/${videoID}`,
-            allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture",
-            allowFullScreen: true,
-            title: "YouTube video",
-            style: { display: "block", border: "none", pointerEvents: isResizing ? "none" : "auto" }
-          }
-        ),
-        isHovered && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "button",
-            {
-              type: "button",
-              onClick: handleDelete,
-              title: "Remove video",
-              style: {
-                position: "absolute",
-                top: 8,
-                right: 8,
-                width: 28,
-                height: 28,
-                borderRadius: "50%",
-                background: "rgba(0,0,0,0.65)",
-                color: "#fff",
-                border: "none",
-                cursor: "pointer",
-                fontSize: 18,
-                lineHeight: 1,
-                padding: 0,
-                zIndex: 10,
-                display: "flex",
-                alignItems: "center",
-                justifyContent: "center"
-              },
-              children: "\xD7"
-            }
-          ),
+        isPlaying ? (
+          /* ── Playing state ─────────────────────────────────────────────────
+           * Show the real YouTube iframe in-place at the same dimensions.
+           * autoplay=1 starts playback immediately.
+           * pointer-events are set to 'none' during resize (handleResizeStart)
+           * so drag events are not lost to the iframe's browsing context.     */
           /* @__PURE__ */ jsxRuntime.jsx(
-            VideoResizer,
+            "iframe",
             {
-              containerRef,
-              onResizeStart: () => setIsResizing(true),
-              onResizeEnd: handleResizeEnd
+              ref: iframeRef,
+              width: "100%",
+              height: "100%",
+              src: `https://www.youtube.com/embed/${videoID}?autoplay=1`,
+              sandbox: "allow-same-origin allow-scripts allow-popups allow-presentation",
+              allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture",
+              allowFullScreen: true,
+              title: "YouTube video",
+              style: { display: "block", border: "none" }
+            }
+          )
+        ) : (
+          /* ── Thumbnail state ───────────────────────────────────────────────
+           * Static <img> keeps all clicks in the parent DOM so Lexical's
+           * CLICK_COMMAND fires correctly and the node can be selected.
+           * Clicking the red ▶ badge switches to playing state.              */
+          /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "img",
+              {
+                src: `https://img.youtube.com/vi/${videoID}/hqdefault.jpg`,
+                alt: "YouTube video",
+                draggable: false,
+                style: {
+                  width: "100%",
+                  height: "100%",
+                  objectFit: "cover",
+                  display: "block",
+                  userSelect: "none",
+                  cursor: "pointer"
+                }
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                role: "button",
+                "aria-label": "Play video",
+                onClick: () => setIsPlaying(true),
+                style: {
+                  position: "absolute",
+                  top: "50%",
+                  left: "50%",
+                  transform: "translate(-50%, -50%)",
+                  width: 56,
+                  height: 56,
+                  background: "rgba(255, 0, 0, 0.85)",
+                  borderRadius: "50%",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  cursor: "pointer"
+                },
+                children: /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: "#fff", fontSize: 20, lineHeight: 1, marginLeft: 5 }, children: "\u25B6" })
+              }
+            )
+          ] })
+        ),
+        (isHovered || isResizing) && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: handleDelete,
+              title: "Remove video",
+              style: actionBtnStyle("right"),
+              children: "\xD7"
+            }
+          ),
+          isPlaying && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: (e) => {
+                e.stopPropagation();
+                setIsPlaying(false);
+              },
+              title: "Stop video",
+              style: actionBtnStyle("left"),
+              children: "\u23F9"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: (e) => {
+                e.stopPropagation();
+                window.open(`https://www.youtube.com/watch?v=${videoID}`, "_blank", "noopener,noreferrer");
+              },
+              title: "Open in browser",
+              style: {
+                ...actionBtnStyle("left"),
+                top: isPlaying ? 44 : 8,
+                // stack below stop button when playing
+                fontSize: 13
+              },
+              children: "\u2197"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            VideoResizer,
+            {
+              containerRef,
+              onResizeStart: handleResizeStart,
+              onResizeEnd: handleResizeEnd
             }
           )
         ] })
@@ -1864,6 +2126,7 @@ var YouTubeNode = class _YouTubeNode extends LexicalDecoratorBlockNode.Decorator
     iframe.setAttribute("width", String(this.__width));
     iframe.setAttribute("height", String(this.__height));
     iframe.style.border = "none";
+    iframe.setAttribute("sandbox", "allow-same-origin allow-scripts allow-popups allow-presentation");
     iframe.setAttribute(
       "allow",
       "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
@@ -1891,16 +2154,10 @@ var YouTubeNode = class _YouTubeNode extends LexicalDecoratorBlockNode.Decorator
     writable.__width = width;
     writable.__height = height;
   }
-  decorate(_editor, config) {
-    const embedBlockTheme = config.theme.embedBlock || {};
-    const className = {
-      base: embedBlockTheme.base || "",
-      focus: embedBlockTheme.focus || ""
-    };
+  decorate(_editor, _config) {
     return /* @__PURE__ */ jsxRuntime.jsx(
       YouTubeComponent,
       {
-        className,
         format: this.__format,
         nodeKey: this.getKey(),
         videoID: this.__id,
@@ -2266,12 +2523,12 @@ function useFloatingPortalContainer(editor) {
   }, [editor]);
   return container;
 }
-function setPopupPositionFixed(popupEl, rect) {
+function setPopupPositionFixed(popupEl, rect, topBoundary) {
   const GAP = 8;
   const MARGIN = 8;
   let top = rect.top - popupEl.offsetHeight - GAP;
-  let left = rect.left + rect.width - popupEl.offsetWidth;
-  if (top < MARGIN) top = rect.bottom + GAP;
+  let left = rect.left;
+  if (top < topBoundary) top = rect.bottom + GAP;
   left = clamp2(left, MARGIN, window.innerWidth - popupEl.offsetWidth - MARGIN);
   popupEl.style.top = `${top}px`;
   popupEl.style.left = `${left}px`;
@@ -2313,10 +2570,22 @@ function FloatingCharacterStylesEditor({
       popupEl.classList.remove("is-open");
       return;
     }
-    const range = sel.getRangeAt(0);
-    const rect = range.getBoundingClientRect();
+    let rect;
+    try {
+      const focusRange = document.createRange();
+      focusRange.setStart(sel.focusNode, sel.focusOffset);
+      focusRange.setEnd(sel.focusNode, sel.focusOffset);
+      rect = focusRange.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0 && rect.top === 0 && rect.left === 0) {
+        throw new Error("empty focus rect");
+      }
+    } catch {
+      rect = sel.getRangeAt(0).getBoundingClientRect();
+    }
+    const toolbarEl = root?.closest(".lexical-rich-editor-root")?.querySelector(".editor-toolbar-root");
+    const topBoundary = toolbarEl ? toolbarEl.getBoundingClientRect().bottom + 8 : 8;
     if (!mouseDownRef.current) {
-      setPopupPositionFixed(popupEl, rect);
+      setPopupPositionFixed(popupEl, rect, topBoundary);
     }
     popupEl.classList.add("is-open");
   }, [editor]);
@@ -2524,6 +2793,11 @@ function useCharacterStylesPopup(editor, opts) {
         setIsText(false);
         return;
       }
+      const activeElement = document.activeElement;
+      if (activeElement && activeElement !== document.body && rootElement && !rootElement.contains(activeElement)) {
+        setIsText(false);
+        return;
+      }
       if (!lexical.$isRangeSelection(selection)) return;
       const node = getSelectedNode(selection);
       setIsBold(selection.hasFormat("bold"));
@@ -2544,7 +2818,11 @@ function useCharacterStylesPopup(editor, opts) {
   }, [editor]);
   React9.useEffect(() => {
     document.addEventListener("selectionchange", updatePopupState);
-    return () => document.removeEventListener("selectionchange", updatePopupState);
+    document.addEventListener("focusin", updatePopupState);
+    return () => {
+      document.removeEventListener("selectionchange", updatePopupState);
+      document.removeEventListener("focusin", updatePopupState);
+    };
   }, [updatePopupState]);
   React9.useEffect(() => editor.registerUpdateListener(updatePopupState), [editor, updatePopupState]);
   if (!portalContainer || !isText || isLink) return null;
@@ -2802,34 +3080,57 @@ function normalizeToBlockHtml(html) {
   if (pendingP) body.appendChild(pendingP);
   return body.innerHTML;
 }
+function splitHeadingsAtBrSequences(html) {
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  const headings = Array.from(doc.querySelectorAll("h1, h2, h3, h4, h5, h6"));
+  headings.forEach((el) => {
+    const inner = el.innerHTML;
+    const SEP = /<br\s*\/?>\s*(?:<br\s*\/?>)+/gi;
+    if (!SEP.test(inner)) return;
+    SEP.lastIndex = 0;
+    const parts = inner.split(SEP).map((p) => p.trim()).filter(Boolean);
+    if (parts.length <= 1) return;
+    const parent = el.parentNode;
+    if (!parent) return;
+    const tagName = el.tagName.toLowerCase();
+    const attrs = Array.from(el.attributes);
+    const fragment = doc.createDocumentFragment();
+    parts.forEach((part) => {
+      const newEl = doc.createElement(tagName);
+      attrs.forEach((a) => newEl.setAttribute(a.name, a.value));
+      newEl.innerHTML = part;
+      fragment.appendChild(newEl);
+    });
+    parent.replaceChild(fragment, el);
+  });
+  return doc.body.innerHTML;
+}
 var CustomOnChangePlugin = ({ value, onChange }) => {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const initializedRef = React9.useRef(false);
-  const onChangeRef = React9.useRef(onChange);
-  onChangeRef.current = onChange;
   React9.useEffect(() => {
     if (!value || initializedRef.current) return;
     initializedRef.current = true;
     editor.update(() => {
       const root = lexical.$getRoot();
       root.clear();
+      const safe = sanitizeHtml(value);
+      const cleaned = normalizeToBlockHtml(splitHeadingsAtBrSequences(safe));
       const parser = new DOMParser();
-      const dom = parser.parseFromString(value, "text/html");
+      const dom = parser.parseFromString(cleaned, "text/html");
       const nodes = html.$generateNodesFromDOM(editor, dom);
       root.append(...nodes);
-      lexical.$setSelection(null);
     });
   }, [editor, value]);
-  const handleChange = React9.useCallback((editorState) => {
-    editorState.read(() => {
-      onChangeRef.current(postProcessOutput(html.$generateHtmlFromNodes(editor)));
-    });
-  }, [editor]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     LexicalOnChangePlugin.OnChangePlugin,
     {
-      onChange: handleChange,
-      ignoreSelectionChange: true
+      onChange: (editorState) => {
+        editorState.read(() => {
+          const raw = html.$generateHtmlFromNodes(editor);
+          onChange(postProcessOutput(splitHeadingsAtBrSequences(raw)));
+        });
+      }
     }
   );
 };
@@ -2939,7 +3240,7 @@ var FloatingLinkEditor = ({ editor, isLink, setIsLink, anchorElem, isLinkEditMod
       setLinkUrl("");
     }
     return true;
-  }, [anchorElem, editor, isLink, setIsLinkEditMode, isLinkEditMode, linkUrl]);
+  }, [anchorElem, editor, setIsLinkEditMode, isLinkEditMode, isLink, linkUrl]);
   React9.useEffect(() => {
     const scrollerElem = anchorElem.parentElement;
     const update = () => {
@@ -3037,7 +3338,6 @@ var FloatingLinkEditor = ({ editor, isLink, setIsLink, anchorElem, isLinkEditMod
       {
         ref: inputRef,
         className: "link-input",
-        placeholder: "https://",
         value: editedLinkUrl,
         onChange: (event) => {
           setEditedLinkUrl(event.target.value);
@@ -3047,31 +3347,33 @@ var FloatingLinkEditor = ({ editor, isLink, setIsLink, anchorElem, isLinkEditMod
         }
       }
     ),
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "link-actions", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "link-input-actions", children: [
       /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
+        "div",
         {
-          type: "button",
-          className: "link-icon-btn link-cancel",
+          className: "link-cancel",
+          role: "button",
+          tabIndex: 0,
           title: "Cancel",
           "aria-label": "Cancel",
           onMouseDown: preventDefault,
           onClick: () => {
             setIsLinkEditMode(false);
           },
-          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.Dismiss16Regular, {})
+          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.DismissRegular, { fontSize: 16 })
         }
       ),
       /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
+        "div",
         {
-          type: "button",
-          className: "link-icon-btn link-confirm",
+          className: "link-confirm",
+          role: "button",
+          tabIndex: 0,
           title: "Confirm",
           "aria-label": "Confirm",
           onMouseDown: preventDefault,
           onClick: handleLinkSubmission,
-          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.Checkmark16Regular, {})
+          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.CheckmarkRegular, { fontSize: 16 })
         }
       )
     ] })
@@ -3085,38 +3387,38 @@ var FloatingLinkEditor = ({ editor, isLink, setIsLink, anchorElem, isLinkEditMod
         children: linkUrl
       }
     ),
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "link-actions", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
-        {
-          type: "button",
-          className: "link-icon-btn link-edit",
-          title: "Edit link",
-          "aria-label": "Edit link",
-          onMouseDown: preventDefault,
-          onClick: (event) => {
-            event.preventDefault();
-            setEditedLinkUrl(linkUrl);
-            setIsLinkEditMode(true);
-          },
-          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.Edit16Regular, {})
-        }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
-        {
-          type: "button",
-          className: "link-icon-btn link-trash",
-          title: "Remove link",
-          "aria-label": "Remove link",
-          onMouseDown: preventDefault,
-          onClick: () => {
-            editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, null);
-          },
-          children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.Delete16Regular, {})
-        }
-      )
-    ] })
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "link-edit",
+        role: "button",
+        tabIndex: 0,
+        title: "Edit link",
+        "aria-label": "Edit link",
+        onMouseDown: preventDefault,
+        onClick: (event) => {
+          event.preventDefault();
+          setEditedLinkUrl(linkUrl);
+          setIsLinkEditMode(true);
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.EditRegular, { fontSize: 16 })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "link-trash",
+        role: "button",
+        tabIndex: 0,
+        title: "Remove link",
+        "aria-label": "Remove link",
+        onMouseDown: preventDefault,
+        onClick: () => {
+          editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, null);
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.DeleteRegular, { fontSize: 16 })
+      }
+    )
   ] }) });
 };
 var useFloatingLinkEditorToolbar = (editor, anchorElem, isLinkEditMode, setIsLinkEditMode) => {
@@ -3197,8 +3499,6 @@ var FloatingLinkEditorPlugin = ({ anchorElem, isLinkEditMode, setIsLinkEditMode
     setIsLinkEditMode
   );
 };
-
-// src/Plugins/ImagePlugin.tsx
 init_ImageNode();
 var INSERT_IMAGE_COMMAND = lexical.createCommand("INSERT_IMAGE_COMMAND");
 var readClipboardImageAsDataURL = async (event) => {
@@ -3217,28 +3517,77 @@ var readClipboardImageAsDataURL = async (event) => {
   }
   return null;
 };
+var InsertImageByURL = ({
+  setIsOpen,
+  onClick,
+  disabled
+}) => {
+  const [altText, setAltText] = React9.useState("");
+  const [src, setSrc] = React9.useState("");
+  const isDisabled = disabled || src === "";
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 6, padding: "10px 0px 0px 0px" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Enter URL", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactComponents.Input,
+      {
+        autoFocus: !disabled,
+        appearance: "underline",
+        placeholder: "Add URL",
+        disabled,
+        onChange: (_, v) => setSrc(v.value),
+        value: src
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Alt Text", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactComponents.Input,
+      {
+        placeholder: "Alt text",
+        disabled,
+        onChange: (_, v) => setAltText(v.value),
+        value: altText
+      },
+      "alt-text-url"
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { horizontal: true, horizontalAlign: "end", tokens: { childrenGap: 6 }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactComponents.Button,
+        {
+          style: { width: "150px" },
+          onClick: () => !disabled && onClick({ altText, src }),
+          disabled: isDisabled,
+          size: "small",
+          children: "Confirm"
+        },
+        "url-confirm-btn"
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactComponents.Button,
+        {
+          style: { width: "150px" },
+          onClick: () => setIsOpen(false),
+          disabled,
+          size: "small",
+          children: "Cancel"
+        },
+        "file-url-cancel"
+      )
+    ] })
+  ] });
+};
 var InsertImageDialog = ({
   activeEditor,
   disabled,
-  open: externalOpen,
-  onClose
+  maxImageSizeMB,
+  validationMessages
 }) => {
   const [src, setSrc] = React9.useState("");
   const [altText, setAltText] = React9.useState("");
-  const [internalOpen, setInternalOpen] = React9.useState(false);
+  const [isOpen, setIsOpen] = React9.useState(false);
+  const [selectedValue, setSelectedValue] = React9.useState("Upload");
   const [fileName, setFileName] = React9.useState("");
+  const [fileSizeError, setFileSizeError] = React9.useState(null);
   const hasModifier = React9.useRef(false);
   const iconColor = disabled ? "var(--colorNeutralForegroundDisabled, #A6A6A6)" : "#333333";
-  const isControlled = externalOpen !== void 0;
-  const isOpen = isControlled ? !!externalOpen && !disabled : internalOpen && !disabled;
-  const isAddDisabled = disabled || src === "";
-  const handleClose = () => {
-    setSrc("");
-    setAltText("");
-    setFileName("");
-    if (isControlled) onClose?.();
-    else setInternalOpen(false);
-  };
+  const isDisabled = disabled || src === "" || !!fileSizeError;
   React9.useEffect(() => {
     hasModifier.current = false;
     const handler = (e) => {
@@ -3250,57 +3599,75 @@ var InsertImageDialog = ({
   const onClick = (payload) => {
     if (disabled) return;
     activeEditor.dispatchCommand(INSERT_IMAGE_COMMAND, payload);
-    handleClose();
+    setIsOpen(false);
+    setAltText("");
+    setSrc("");
+    setFileName("");
+    setFileSizeError(null);
   };
   const loadImage = (event) => {
     if (disabled) return;
     const files = event.target.files;
     if (!files || files.length === 0) return;
+    const file = files[0];
+    if (maxImageSizeMB !== void 0) {
+      const fileMB = file.size / (1024 * 1024);
+      if (fileMB > maxImageSizeMB) {
+        const override = validationMessages?.imageTooLarge;
+        const msg = override !== void 0 ? typeof override === "function" ? override(fileMB, maxImageSizeMB) : override : DEFAULT_VALIDATION_MESSAGES.imageTooLarge(fileMB, maxImageSizeMB);
+        setFileSizeError(msg);
+        setSrc("");
+        setFileName("");
+        event.target.value = "";
+        return;
+      }
+    }
+    setFileSizeError(null);
     const reader = new FileReader();
     reader.onload = () => {
       if (typeof reader.result === "string") {
         setSrc(reader.result);
-        setFileName(files[0].name);
+        setFileName(file.name);
       }
     };
-    reader.readAsDataURL(files[0]);
+    reader.readAsDataURL(file);
   };
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    !isControlled && /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Button,
-      {
-        size: "small",
-        title: "Add Image",
-        disabled,
-        icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageAddRegular, { style: { color: iconColor } }),
-        style: {
-          background: isOpen && !disabled ? "#ebebeb" : "none",
-          border: "none",
-          margin: 2,
-          opacity: disabled ? 0.55 : 1,
-          cursor: disabled ? "not-allowed" : "pointer"
-        },
-        onClick: () => {
-          if (disabled) return;
-          setSrc("");
-          setAltText("");
-          setFileName("");
-          setInternalOpen(true);
-        }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactComponents.Dialog,
+    {
+      open: disabled ? false : isOpen,
+      onOpenChange: (_, data) => {
+        if (!disabled) setIsOpen(data.open);
       },
-      "upload-image"
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Dialog,
-      {
-        open: isOpen,
-        onOpenChange: (_, data) => {
-          if (!data.open) handleClose();
-        },
-        children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: "400px" }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert Image" }),
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 10 }, style: { paddingTop: 8 }, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Upload", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            title: "Add Image",
+            disabled,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageAddRegular, { style: { color: iconColor } }),
+            style: {
+              background: isOpen && !disabled ? "#ebebeb" : "none",
+              border: "none",
+              margin: 2,
+              opacity: disabled ? 0.55 : 1,
+              cursor: disabled ? "not-allowed" : "pointer"
+            },
+            onClick: () => {
+              if (disabled) return;
+              setIsOpen((prev) => !prev);
+              setSrc("");
+              setAltText("");
+              setFileName("");
+            }
+          },
+          "upload-image"
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: 340 }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert image" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 8 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Upload", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
               "label",
               {
                 style: {
@@ -3339,7 +3706,8 @@ var InsertImageDialog = ({
                 ]
               }
             ) }),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Alt Text", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+            fileSizeError && /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MessageBar, { intent: "error", style: { marginTop: 4 }, children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MessageBarBody, { children: fileSizeError }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Alt Text", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
               reactComponents.Input,
               {
                 placeholder: "Alt text",
@@ -3348,25 +3716,24 @@ var InsertImageDialog = ({
                 onChange: (_, d) => setAltText(d.value),
                 value: altText
               }
-            ) })
-          ] }) }),
-          /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogActions, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Button,
+            ) }),
+            selectedValue === "URL" && /* @__PURE__ */ jsxRuntime.jsx(
+              InsertImageByURL,
               {
-                appearance: "primary",
-                size: "small",
-                disabled: isAddDisabled,
-                onClick: () => onClick({ altText, src }),
-                children: "Add"
+                disabled,
+                setIsOpen: (open) => setIsOpen(open),
+                onClick: (payload) => onClick(payload)
               }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: handleClose, children: "Cancel" })
+            )
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogActions, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled: isDisabled, onClick: () => onClick({ altText, src }), children: "Add" }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: () => setIsOpen(false), children: "Cancel" })
           ] })
         ] }) })
-      }
-    )
-  ] });
+      ]
+    }
+  );
 };
 var ImagesPlugin = ({ captionsEnabled }) => {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
@@ -3379,9 +3746,21 @@ var ImagesPlugin = ({ captionsEnabled }) => {
         INSERT_IMAGE_COMMAND,
         (payload) => {
           const imageNode = $createImageNode(payload);
-          lexical.$insertNodes([imageNode]);
-          if (lexical.$isRootOrShadowRoot(imageNode.getParentOrThrow())) {
-            utils.$wrapNodeInElement(imageNode, lexical.$createParagraphNode).selectEnd();
+          const selection = lexical.$getSelection();
+          if (lexical.$isRangeSelection(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            const topLevel = anchorNode.getTopLevelElementOrThrow();
+            const imageParagraph = lexical.$createParagraphNode();
+            imageParagraph.append(imageNode);
+            topLevel.insertAfter(imageParagraph);
+            const tail = lexical.$createParagraphNode();
+            imageParagraph.insertAfter(tail);
+            tail.select();
+          } else {
+            lexical.$insertNodes([imageNode]);
+            if (lexical.$isRootOrShadowRoot(imageNode.getParentOrThrow())) {
+              utils.$wrapNodeInElement(imageNode, lexical.$createParagraphNode).selectEnd();
+            }
           }
           return true;
         },
@@ -3432,12 +3811,25 @@ var TRANSPARENT_IMAGE = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAA
 var img = document.createElement("img");
 img.src = TRANSPARENT_IMAGE;
 var $onDragStart = (event) => {
-  const node = $getImageNodeInSelection();
+  let node = $getImageNodeInSelection();
+  if (!node) {
+    const target = event.target;
+    if (!target) return false;
+    const lexicalNode = lexical.$getNearestNodeFromDOMNode(target);
+    if ($isImageNode(lexicalNode)) {
+      node = lexicalNode;
+    }
+  }
   if (!node) return false;
   const dataTransfer = event.dataTransfer;
   if (!dataTransfer) return false;
+  const imgEl = event.target?.closest?.("span.editor-image")?.querySelector?.("img") ?? event.target;
+  if (imgEl instanceof HTMLElement) {
+    dataTransfer.setDragImage(imgEl, 20, 20);
+  } else {
+    dataTransfer.setDragImage(img, 0, 0);
+  }
   dataTransfer.setData("text/plain", "_");
-  dataTransfer.setDragImage(img, 0, 0);
   dataTransfer.setData(
     "application/x-lexical-drag",
     JSON.stringify({
@@ -3465,20 +3857,23 @@ var $onDragover = (event) => {
   return true;
 };
 var $onDrop = (event, editor) => {
-  const node = $getImageNodeInSelection();
-  if (!node) return false;
   const data = getDragImageData(event);
   if (!data) return false;
   event.preventDefault();
   if (canDropImage(event)) {
+    const sourceKey = data.key;
+    if (sourceKey) {
+      const sourceNode = lexical.$getNodeByKey(sourceKey);
+      if (sourceNode) sourceNode.remove();
+    }
     const range = getDragSelection(event);
-    node.remove();
     const rangeSelection = lexical.$createRangeSelection();
     if (range !== null && range !== void 0) {
       rangeSelection.applyDOMRange(range);
     }
     lexical.$setSelection(rangeSelection);
-    editor.dispatchCommand(INSERT_IMAGE_COMMAND, data);
+    const { key: _key, ...insertPayload } = data;
+    editor.dispatchCommand(INSERT_IMAGE_COMMAND, insertPayload);
   }
   return true;
 };
@@ -3498,7 +3893,7 @@ var getDragImageData = (event) => {
 };
 var canDropImage = (event) => {
   const target = event.target;
-  return !!(lexical.isHTMLElement(target) && !target.closest("code, span.editor-image") && lexical.isHTMLElement(target.parentElement) && target.parentElement.closest("div.ContentEditable__root"));
+  return !!(lexical.isHTMLElement(target) && !target.closest("code, span.editor-image") && target.closest('[contenteditable="true"]'));
 };
 var getDragSelection = (event) => {
   let range;
@@ -3513,8 +3908,6 @@ var getDragSelection = (event) => {
   }
   return range;
 };
-
-// src/Plugins/InlineImage.tsx
 init_InlineImage();
 init_InlineImageNode();
 var INSERT_INLINE_IMAGE_COMMAND = lexical.createCommand(
@@ -3533,39 +3926,45 @@ var useStyles = reactComponents.makeStyles({
 var InsertInlineImageDialog = ({
   disabled,
   activeEditor,
-  open: externalOpen,
-  onClose
+  maxImageSizeMB,
+  validationMessages
 }) => {
   const hasModifier = React9.useRef(false);
   const [src, setSrc] = React9.useState("");
-  const [internalOpen, setInternalOpen] = React9.useState(false);
+  const [isOpen, setIsOpen] = React9.useState(false);
   const [altText, setAltText] = React9.useState("");
   const [fileName, setFileName] = React9.useState("");
   const [position, setPosition] = React9.useState("left");
+  const [fileSizeError, setFileSizeError] = React9.useState(null);
   const styles = useStyles();
   const iconColor = disabled ? "var(--colorNeutralForegroundDisabled, #A6A6A6)" : "#333333";
-  const isControlled = externalOpen !== void 0;
-  const isOpen = isControlled ? !!externalOpen && !disabled : internalOpen && !disabled;
-  const isAddDisabled = disabled || src === "";
-  const handleClose = () => {
-    setSrc("");
-    setAltText("");
-    setFileName("");
-    if (isControlled) onClose?.();
-    else setInternalOpen(false);
-  };
+  const isDisabled = disabled || src === "" || !!fileSizeError;
   const loadImage = (event) => {
     if (disabled) return;
     const files = event.target.files;
     if (!files || files.length === 0) return;
+    const file = files[0];
+    if (maxImageSizeMB !== void 0) {
+      const fileMB = file.size / (1024 * 1024);
+      if (fileMB > maxImageSizeMB) {
+        const override = validationMessages?.imageTooLarge;
+        const msg = override !== void 0 ? typeof override === "function" ? override(fileMB, maxImageSizeMB) : override : DEFAULT_VALIDATION_MESSAGES.imageTooLarge(fileMB, maxImageSizeMB);
+        setFileSizeError(msg);
+        setSrc("");
+        setFileName("");
+        event.target.value = "";
+        return;
+      }
+    }
+    setFileSizeError(null);
     const reader = new FileReader();
     reader.onload = () => {
       if (typeof reader.result === "string") {
         setSrc(reader.result);
-        setFileName(files[0].name);
+        setFileName(file.name);
       }
     };
-    reader.readAsDataURL(files[0]);
+    reader.readAsDataURL(file);
   };
   React9.useEffect(() => {
     const handler = (e) => {
@@ -3578,44 +3977,48 @@ var InsertInlineImageDialog = ({
     if (disabled) return;
     const payload = { altText, position, src };
     activeEditor.dispatchCommand(INSERT_INLINE_IMAGE_COMMAND, payload);
-    handleClose();
+    setIsOpen(false);
+    setAltText("");
+    setSrc("");
+    setFileName("");
+    setFileSizeError(null);
   };
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    !isControlled && /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Button,
-      {
-        size: "small",
-        title: "Add Inline Image",
-        disabled,
-        icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageEditRegular, { style: { color: iconColor } }),
-        style: {
-          background: isOpen && !disabled ? "#ebebeb" : "none",
-          border: "none",
-          margin: 2,
-          opacity: disabled ? 0.55 : 1,
-          cursor: disabled ? "not-allowed" : "pointer"
-        },
-        onClick: () => {
-          if (disabled) return;
-          setSrc("");
-          setAltText("");
-          setFileName("");
-          setInternalOpen(true);
-        }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactComponents.Dialog,
+    {
+      open: disabled ? false : isOpen,
+      onOpenChange: (_, data) => {
+        if (!disabled) setIsOpen(data.open);
       },
-      "upload-inline-image"
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Dialog,
-      {
-        open: isOpen,
-        onOpenChange: (_, data) => {
-          if (!data.open) handleClose();
-        },
-        children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: "440px" }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert Inline Image" }),
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 10 }, style: { paddingTop: 8 }, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Upload", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            title: "Add Inline Image",
+            disabled,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageEditRegular, { style: { color: iconColor } }),
+            style: {
+              background: isOpen && !disabled ? "#ebebeb" : "none",
+              border: "none",
+              margin: 2,
+              opacity: disabled ? 0.55 : 1,
+              cursor: disabled ? "not-allowed" : "pointer"
+            },
+            onClick: () => {
+              if (disabled) return;
+              setIsOpen((prev) => !prev);
+              setAltText("");
+              setSrc("");
+              setFileName("");
+            }
+          },
+          "upload-inline-image"
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: 360 }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert inline image" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 8 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Upload", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
               "label",
               {
                 style: {
@@ -3654,22 +4057,25 @@ var InsertInlineImageDialog = ({
                 ]
               }
             ) }),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Position", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Position", size: "small", children: /* @__PURE__ */ jsxRuntime.jsxs(
               reactComponents.Dropdown,
               {
-                placeholder: "Left Align",
                 className: styles.alignDropdown,
                 disabled,
+                value: position === "full" ? "Full" : position === "right" ? "Right" : "Left",
+                selectedOptions: [position ?? "left"],
                 listbox: { style: { width: "120px" } },
                 root: { style: { borderBottom: "1px solid black" } },
+                onOptionSelect: (_, data) => setPosition(data.optionValue),
                 children: [
-                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { text: "full", onClick: () => setPosition("full"), children: "Full" }, "full"),
-                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { text: "left", onClick: () => setPosition("left"), children: "Left" }, "left"),
-                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { text: "right", onClick: () => setPosition("right"), children: "Right" }, "right")
+                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: "left", children: "Left" }, "left"),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: "right", children: "Right" }, "right"),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: "full", children: "Full" }, "full")
                 ]
               }
             ) }),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Alt Text", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+            fileSizeError && /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MessageBar, { intent: "error", style: { marginTop: 4 }, children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MessageBarBody, { children: fileSizeError }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Alt Text", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
               reactComponents.Input,
               {
                 placeholder: "Alt text",
@@ -3684,9 +4090,8 @@ var InsertInlineImageDialog = ({
             /* @__PURE__ */ jsxRuntime.jsx(
               reactComponents.Button,
               {
-                appearance: "primary",
                 size: "small",
-                disabled: isAddDisabled,
+                disabled: isDisabled,
                 onClick: handleOnClick,
                 children: "Add"
               },
@@ -3697,16 +4102,16 @@ var InsertInlineImageDialog = ({
               {
                 size: "small",
                 disabled,
-                onClick: handleClose,
+                onClick: () => setIsOpen(false),
                 children: "Cancel"
               },
               "file-inline-upload-cancel"
             )
           ] })
         ] }) })
-      }
-    )
-  ] });
+      ]
+    }
+  );
 };
 var InlineImagePlugin = () => {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
@@ -3723,6 +4128,11 @@ var InlineImagePlugin = () => {
           if (lexical.$isRootOrShadowRoot(imageNode.getParentOrThrow())) {
             utils.$wrapNodeInElement(imageNode, lexical.$createParagraphNode).selectEnd();
           }
+          const parent = imageNode.getParent();
+          if (parent && typeof parent.setFormat === "function") {
+            const fmt = payload.position === "right" ? "right" : payload.position === "full" ? "center" : "left";
+            parent.setFormat(fmt);
+          }
           return true;
         },
         lexical.COMMAND_PRIORITY_EDITOR
@@ -3751,12 +4161,23 @@ var TRANSPARENT_IMAGE2 = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEA
 var img2 = document.createElement("img");
 img2.src = TRANSPARENT_IMAGE2;
 function $onDragStart2(event) {
-  const node = $getImageNodeInSelection2();
+  let node = $getImageNodeInSelection2();
+  if (!node) {
+    const target = event.target;
+    if (!target) return false;
+    const lexicalNode = lexical.$getNearestNodeFromDOMNode(target);
+    if ($isInlineImageNode(lexicalNode)) node = lexicalNode;
+  }
   if (!node) return false;
   const dataTransfer = event.dataTransfer;
   if (!dataTransfer) return false;
+  const imgEl = event.target?.closest?.(".inline-editor-image")?.querySelector?.("img") ?? event.target;
+  if (imgEl instanceof HTMLElement) {
+    dataTransfer.setDragImage(imgEl, 20, 20);
+  } else {
+    dataTransfer.setDragImage(img2, 0, 0);
+  }
   dataTransfer.setData("text/plain", "_");
-  dataTransfer.setDragImage(img2, 0, 0);
   dataTransfer.setData(
     "application/x-lexical-drag",
     JSON.stringify({
@@ -3775,28 +4196,31 @@ function $onDragStart2(event) {
   return true;
 }
 var $onDragover2 = (event) => {
-  const node = $getImageNodeInSelection2();
-  if (!node) return false;
+  const hasDragData = !!event.dataTransfer?.types.includes("application/x-lexical-drag");
+  if (!hasDragData) return false;
   if (!canDropImage2(event)) {
     event.preventDefault();
   }
   return true;
 };
 var $onDrop2 = (event, editor) => {
-  const node = $getImageNodeInSelection2();
-  if (!node) return false;
   const data = getDragImageData2(event);
   if (!data) return false;
   event.preventDefault();
   if (canDropImage2(event)) {
+    const sourceKey = data.key;
+    if (sourceKey) {
+      const sourceNode = lexical.$getNodeByKey(sourceKey);
+      if (sourceNode) sourceNode.remove();
+    }
     const range = getDragSelection2(event);
-    node.remove();
     const rangeSelection = lexical.$createRangeSelection();
     if (range !== null && range !== void 0) {
       rangeSelection.applyDOMRange(range);
     }
     lexical.$setSelection(rangeSelection);
-    editor.dispatchCommand(INSERT_INLINE_IMAGE_COMMAND, data);
+    const { key: _key, ...insertPayload } = data;
+    editor.dispatchCommand(INSERT_INLINE_IMAGE_COMMAND, insertPayload);
   }
   return true;
 };
@@ -3816,7 +4240,7 @@ var getDragImageData2 = (event) => {
 };
 var canDropImage2 = (event) => {
   const target = event.target;
-  return !!(lexical.isHTMLElement(target) && !target.closest("code, span.editor-image") && lexical.isHTMLElement(target.parentElement) && target.parentElement.closest("div.ContentEditable__root"));
+  return !!(lexical.isHTMLElement(target) && !target.closest("code, span.editor-image, .inline-editor-image") && target.closest('[contenteditable="true"]'));
 };
 var getDragSelection2 = (event) => {
   let range;
@@ -3907,20 +4331,79 @@ function hasBlock(editor, kind) {
 }
 
 // src/Plugins/RefApiPlugin.tsx
+function getUserContentSignature(editor) {
+  const parts = [];
+  editor.getEditorState().read(() => {
+    const root = lexical.$getRoot();
+    const collectNode = (node) => {
+      if ($isHtmlBlockNode(node)) return;
+      if (lexical.$isDecoratorNode(node)) {
+        parts.push(`D:${node.getKey()}`);
+        return;
+      }
+      if (lexical.$isLineBreakNode(node)) {
+        parts.push("BR");
+        return;
+      }
+      if (lexical.$isTextNode(node)) {
+        parts.push(`T${node.getFormat()}:${node.getStyle()}:${node.getTextContent()}`);
+        return;
+      }
+      if (lexical.$isElementNode(node)) {
+        const type = node.getType();
+        const tag = typeof node.getTag === "function" ? node.getTag() : "";
+        const list = typeof node.getListType === "function" ? node.getListType() : "";
+        const fmt = typeof node.getFormat === "function" ? node.getFormat() : "";
+        parts.push(`[${type}:${tag}:${list}:${fmt}]`);
+        for (const child of node.getChildren()) {
+          collectNode(child);
+        }
+        parts.push("[/]");
+      }
+    };
+    for (const child of root.getChildren()) {
+      if ($isHtmlBlockNode(child)) continue;
+      collectNode(child);
+    }
+  });
+  return JSON.stringify(parts);
+}
 function RefApiPlugin({
   forwardedRef,
   contentEditableDomRef,
-  focusedRef,
-  setRefErrors
+  focusedRef
 }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const cleanBaselineRef = React9__namespace.default.useRef(null);
+  React9__namespace.default.useEffect(() => {
+    const capture = () => {
+      if (cleanBaselineRef.current === null) {
+        cleanBaselineRef.current = getUserContentSignature(editor);
+      }
+    };
+    const unregister = editor.registerUpdateListener(({ dirtyElements, dirtyLeaves }) => {
+      if (cleanBaselineRef.current !== null) {
+        unregister();
+        return;
+      }
+      if (dirtyElements.size === 0 && dirtyLeaves.size === 0) return;
+      capture();
+      unregister();
+    });
+    const timerId = setTimeout(capture, 0);
+    return () => {
+      clearTimeout(timerId);
+      unregister();
+    };
+  }, [editor]);
   React9.useImperativeHandle(
     forwardedRef,
     () => ({
       setValue: (html$1) => {
         editor.update(() => {
+          const safe = normalizeToBlockHtml(sanitizeHtml(html$1 || ""));
           const parser = new DOMParser();
-          const dom = parser.parseFromString(html$1 || "<p></p>", "text/html");
+          const dom = parser.parseFromString(safe || "<p></p>", "text/html");
           const nodes = html.$generateNodesFromDOM(editor, dom);
           const root = lexical.$getRoot();
           root.clear();
@@ -3930,9 +4413,9 @@ function RefApiPlugin({
       getValue: () => {
         let html$1 = "";
         editor.getEditorState().read(() => {
-          html$1 = html.$generateHtmlFromNodes(editor, null);
+          html$1 = postProcessOutput(splitHeadingsAtBrSequences(html.$generateHtmlFromNodes(editor, null)));
         });
-        return postProcessOutput(html$1);
+        return html$1;
       },
       clear: () => {
         editor.update(() => {
@@ -3950,14 +4433,20 @@ function RefApiPlugin({
       },
       isFocused: () => focusedRef.current,
       getEditor: () => editor,
-      setErrors: (messages) => setRefErrors(messages),
-      clearErrors: () => setRefErrors([]),
       // Generic blocks (signature, footer, banner, etc.)
       upsertBlock: (spec) => upsertBlock(editor, spec),
       removeBlock: (kind) => removeBlock(editor, kind),
-      hasBlock: (kind) => hasBlock(editor, kind)
+      hasBlock: (kind) => hasBlock(editor, kind),
+      checkDirty: () => {
+        if (cleanBaselineRef.current === null) return false;
+        const current = getUserContentSignature(editor);
+        return current !== cleanBaselineRef.current;
+      },
+      markClean: () => {
+        cleanBaselineRef.current = getUserContentSignature(editor);
+      }
     }),
-    [editor, contentEditableDomRef, focusedRef, setRefErrors]
+    [editor, contentEditableDomRef, focusedRef]
   );
   return null;
 }
@@ -4598,8 +5087,22 @@ function TableActionMenuPlugin({ disabled = false }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const [isInTable, setIsInTable] = React9__namespace.useState(false);
   const [anchorRect, setAnchorRect] = React9__namespace.useState(null);
+  const [contentRight, setContentRight] = React9__namespace.useState(null);
   const [open, setOpen] = React9__namespace.useState(false);
+  const openRef = React9__namespace.useRef(false);
+  const savedAnchorRef = React9__namespace.useRef(null);
+  const measureContentRight = React9__namespace.useCallback((cellDom) => {
+    try {
+      const range = document.createRange();
+      range.selectNodeContents(cellDom);
+      const cr = range.getBoundingClientRect();
+      return cr.width > 2 ? cr.right : null;
+    } catch {
+      return null;
+    }
+  }, []);
   const updateFromSelection = React9__namespace.useCallback(() => {
+    if (openRef.current) return;
     const root = editor.getRootElement();
     if (!root) return;
     editor.getEditorState().read(() => {
@@ -4611,6 +5114,7 @@ function TableActionMenuPlugin({ disabled = false }) {
           if (dom) {
             setIsInTable(true);
             setAnchorRect(dom.getBoundingClientRect());
+            setContentRight(null);
             return;
           }
         }
@@ -4618,6 +5122,7 @@ function TableActionMenuPlugin({ disabled = false }) {
       if (!lexical.$isRangeSelection(selection)) {
         setIsInTable(false);
         setAnchorRect(null);
+        setContentRight(null);
         return;
       }
       const anchorNode = selection.anchor.getNode();
@@ -4625,18 +5130,28 @@ function TableActionMenuPlugin({ disabled = false }) {
       if (!cellNode || !table.$isTableCellNode(cellNode)) {
         setIsInTable(false);
         setAnchorRect(null);
+        setContentRight(null);
         return;
       }
       const cellDom = editor.getElementByKey(cellNode.getKey());
       if (!cellDom) {
         setIsInTable(false);
         setAnchorRect(null);
+        setContentRight(null);
         return;
       }
       setIsInTable(true);
       setAnchorRect(cellDom.getBoundingClientRect());
+      setContentRight(measureContentRight(cellDom));
+      if (lexical.$isRangeSelection(selection)) {
+        savedAnchorRef.current = {
+          key: selection.anchor.key,
+          offset: selection.anchor.offset,
+          type: selection.anchor.type
+        };
+      }
     });
-  }, [editor]);
+  }, [editor, measureContentRight]);
   React9__namespace.useEffect(() => {
     return utils.mergeRegister(
       editor.registerCommand(
@@ -4693,30 +5208,37 @@ function TableActionMenuPlugin({ disabled = false }) {
       lexical.COMMAND_PRIORITY_HIGH
     );
   }, [editor, disabled]);
-  React9__namespace.useEffect(() => {
-    if (!isInTable && open) setOpen(false);
-  }, [isInTable, open]);
   const canShow = isInTable && !!anchorRect && !disabled;
   const handleStyle = React9__namespace.useMemo(() => {
     if (!anchorRect) return void 0;
     const top = Math.max(8, anchorRect.top + 6);
-    const left = Math.max(8, anchorRect.right - 34);
+    const clampedCellRight = Math.min(anchorRect.right, window.innerWidth - 8);
+    const left = contentRight !== null ? Math.max(anchorRect.left + 4, Math.min(contentRight + 4, clampedCellRight - 32)) : Math.max(8, anchorRect.left + 8);
     return {
       position: "fixed",
       top,
       left,
       zIndex: 9999
     };
-  }, [anchorRect]);
+  }, [anchorRect, contentRight]);
   const dangerStyle = {
     color: "var(--colorPaletteRedForeground1)"
   };
   const run = React9__namespace.useCallback(
     (fn) => {
       if (disabled) return;
-      editor.focus();
-      editor.update(() => fn());
+      openRef.current = false;
       setOpen(false);
+      editor.update(() => {
+        const saved = savedAnchorRef.current;
+        if (saved && lexical.$getNodeByKey(saved.key)) {
+          const sel = lexical.$createRangeSelection();
+          sel.anchor.set(saved.key, saved.offset, saved.type);
+          sel.focus.set(saved.key, saved.offset, saved.type);
+          lexical.$setSelection(sel);
+        }
+        fn();
+      });
     },
     [disabled, editor]
   );
@@ -4726,32 +5248,31 @@ function TableActionMenuPlugin({ disabled = false }) {
   const insertColLeft = () => run(() => table.$insertTableColumnAtSelection(false));
   const deleteRow = () => run(() => table.$deleteTableRowAtSelection());
   const deleteCol = () => run(() => table.$deleteTableColumnAtSelection());
-  const deleteTable = () => run(() => {
-    const selection = lexical.$getSelection();
-    if (table.$isTableSelection(selection)) {
-      const tableNode = selection.getNodes().find((n) => table.$isTableNode(n));
+  const deleteTable = () => {
+    if (disabled) return;
+    openRef.current = false;
+    setOpen(false);
+    editor.update(() => {
+      const saved = savedAnchorRef.current;
+      if (!saved) return;
+      const anchorNode = lexical.$getNodeByKey(saved.key);
+      if (!anchorNode) return;
+      const tableNode = lexical.$findMatchingParent(anchorNode, (n) => table.$isTableNode(n));
       if (tableNode) tableNode.remove();
-      return;
-    }
-    if (!lexical.$isRangeSelection(selection)) return;
-    const node = selection.anchor.getNode();
-    const cell = lexical.$findMatchingParent(node, (n) => table.$isTableCellNode(n)) ?? (table.$isTableCellNode(node) ? node : null);
-    if (!cell) return;
-    const table$1 = table.$getTableNodeFromLexicalNodeOrThrow(cell);
-    table$1.remove();
-  });
+    });
+  };
   if (!canShow || !handleStyle) return null;
   return reactDom.createPortal(
-    /* @__PURE__ */ jsxRuntime.jsx("div", { style: handleStyle, className: "aoTableActionHandleRoot", children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Menu, { open, onOpenChange: (_, data) => setOpen(data.open), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: handleStyle, className: "aoTableActionHandleRoot", "data-lexical-editor-portal": "true", children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Menu, { open, onOpenChange: (_, data) => {
+      openRef.current = data.open;
+      setOpen(data.open);
+    }, children: [
       /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MenuTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
         "button",
         {
           type: "button",
           className: "aoTableActionHandleBtn",
           "aria-label": "Table options",
-          onMouseDown: (e) => {
-            e.preventDefault();
-          },
           children: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ChevronDown12Regular, {})
         }
       ) }),
@@ -5075,8 +5596,8 @@ function getToolbarGroupsByLevel(level) {
         // ['undo', 'redo', '|'],
         ["Bold", "Italic", "Underline", "|"],
         ["ColorPicker", "|"],
-        ["Link", "|"],
-        ["Insert", "|"],
+        ["Link", "Table", "|"],
+        // ['Image', 'Youtube', 'InlineImage', '|'],
         ["Heading", "|"],
         ["FontFamily", "|"],
         ["FontSize", "|"],
@@ -5090,8 +5611,9 @@ function getToolbarGroupsByLevel(level) {
         // ['undo', 'redo', '|'],
         ["Bold", "Italic", "Underline", "|"],
         ["ColorPicker", "|"],
-        ["Link", "|"],
-        ["Insert", "|"],
+        ["Link", "Table", "|"],
+        // ['CodeBlock', '|'],
+        ["Image", "Youtube", "InlineImage", "|"],
         ["Heading", "|"],
         ["FontFamily", "|"],
         ["FontSize", "|"],
@@ -5101,6 +5623,85 @@ function getToolbarGroupsByLevel(level) {
       ];
   }
 }
+var DEFAULT_FONT_SIZE = 15;
+function $splitBlocksAtLineBreaks(selection) {
+  const blocksToSplit = /* @__PURE__ */ new Set();
+  for (const node of selection.getNodes()) {
+    const block = node.getTopLevelElement();
+    if (block && lexical.$isElementNode(block)) {
+      const children = block.getChildren();
+      if (children.some(lexical.$isLineBreakNode)) {
+        blocksToSplit.add(block);
+      }
+    }
+  }
+  for (const block of blocksToSplit) {
+    const children = [...block.getChildren()];
+    const groups = [[]];
+    for (const child of children) {
+      if (lexical.$isLineBreakNode(child)) {
+        groups.push([]);
+      } else {
+        groups[groups.length - 1].push(child);
+      }
+    }
+    const nonEmptyCount = groups.filter((g) => g.length > 0).length;
+    if (nonEmptyCount <= 1) continue;
+    for (let i = groups.length - 1; i >= 1; i--) {
+      const group = groups[i];
+      const newBlock = group.length === 0 ? lexical.$createParagraphNode() : richText.$isHeadingNode(block) ? richText.$createHeadingNode(block.getTag()) : lexical.$createParagraphNode();
+      group.forEach((child) => newBlock.append(child));
+      block.insertAfter(newBlock);
+    }
+    [...block.getChildren()].filter(lexical.$isLineBreakNode).forEach((br) => br.remove());
+  }
+}
+function $splitBlockAtPartialSelection(selection) {
+  if (selection.isCollapsed()) return false;
+  const anchorBlock = selection.anchor.getNode().getTopLevelElement();
+  const focusBlock = selection.focus.getNode().getTopLevelElement();
+  if (!anchorBlock || !focusBlock || !anchorBlock.is(focusBlock)) return false;
+  if (!lexical.$isElementNode(anchorBlock)) return false;
+  const block = anchorBlock;
+  const extractedNodes = selection.extract();
+  if (!extractedNodes.length) return false;
+  const allDirect = extractedNodes.every((n) => {
+    const parent = n.getParent();
+    return parent !== null && parent.is(block);
+  });
+  if (!allDirect) return false;
+  const allChildren = [...block.getChildren()];
+  const firstSelected = extractedNodes[0];
+  const lastSelected = extractedNodes[extractedNodes.length - 1];
+  const firstIdx = allChildren.findIndex((n) => n.is(firstSelected));
+  const lastIdx = allChildren.findIndex((n) => n.is(lastSelected));
+  if (firstIdx === -1 || lastIdx === -1) return false;
+  if (firstIdx === 0 && lastIdx === allChildren.length - 1) return false;
+  const selectedNodes = allChildren.slice(firstIdx, lastIdx + 1);
+  const afterNodes = allChildren.slice(lastIdx + 1);
+  if (afterNodes.length > 0) {
+    const afterBlock = richText.$isHeadingNode(block) ? richText.$createHeadingNode(block.getTag()) : lexical.$createParagraphNode();
+    afterNodes.forEach((n) => afterBlock.append(n));
+    block.insertAfter(afterBlock);
+  }
+  const selectedBlock = lexical.$createParagraphNode();
+  selectedNodes.forEach((n) => selectedBlock.append(n));
+  block.insertAfter(selectedBlock);
+  if (block.getChildrenSize() === 0) {
+    block.remove();
+  }
+  selectedBlock.select();
+  return true;
+}
+var formatParagraph = (editor) => {
+  editor.update(() => {
+    const selection$1 = lexical.$getSelection();
+    if (lexical.$isRangeSelection(selection$1)) {
+      $splitBlocksAtLineBreaks(selection$1);
+    }
+    selection.$setBlocksType(lexical.$getSelection(), () => lexical.$createParagraphNode());
+  });
+};
 var PRESET = [
   "#000000",
   "#434343",
@@ -5384,7 +5985,7 @@ var ColorPickerControl = ({ value, title, disabled, onChange, icon, onOpenChange
         directionalHint: 4,
         className: "aoColorCallout",
         preventDismissOnEvent,
-        children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 14 }, styles: { root: { padding: "14px 16px 16px", width: 288 } }, children: [
+        children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 14 }, styles: { root: { padding: "14px 16px 16px", width: 250 } }, children: [
           /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between" }, children: [
             /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 13, fontWeight: 600, color: "#242424", letterSpacing: 0.1 }, children: title }),
             /* @__PURE__ */ jsxRuntime.jsx(
@@ -5397,8 +5998,8 @@ var ColorPickerControl = ({ value, title, disabled, onChange, icon, onOpenChange
                   display: "flex",
                   alignItems: "center",
                   justifyContent: "center",
-                  width: 24,
-                  height: 24,
+                  width: 18,
+                  height: 18,
                   padding: 0,
                   border: "none",
                   borderRadius: 4,
@@ -5421,7 +6022,7 @@ var ColorPickerControl = ({ value, title, disabled, onChange, icon, onOpenChange
               style: {
                 position: "relative",
                 width: "100%",
-                height: 150,
+                height: 125,
                 borderRadius: 8,
                 overflow: "hidden",
                 cursor: "crosshair",
@@ -5510,8 +6111,8 @@ var ColorPickerControl = ({ value, title, disabled, onChange, icon, onOpenChange
               "div",
               {
                 style: {
-                  width: 32,
-                  height: 32,
+                  width: 20,
+                  height: 20,
                   borderRadius: 6,
                   flexShrink: 0,
                   background: hex,
@@ -5552,10 +6153,10 @@ var ColorPickerControl = ({ value, title, disabled, onChange, icon, onOpenChange
                       title: c,
                       "aria-label": c,
                       style: {
-                        width: 22,
-                        height: 22,
+                        width: 18,
+                        height: 18,
                         padding: 0,
-                        borderRadius: 5,
+                        borderRadius: 4,
                         background: c,
                         cursor: "pointer",
                         boxShadow: isSelected ? "0 0 0 2px #fff, 0 0 0 3px #4a86e8" : "inset 0 0 0 1px rgba(0,0,0,0.15)",
@@ -5765,7 +6366,6 @@ var FontFamilyPlugin = ({ disabled = false }) => {
     "font-family"
   );
 };
-var DEFAULT_FONT_SIZE = 15;
 var FONT_SIZE_OPTIONS = [
   "8",
   "9",
@@ -5901,135 +6501,43 @@ var FontSizePlugin = ({ disabled }) => {
     "fontsize"
   ) });
 };
-var VERBATIM_LINK_RE = /^https?:\/\/|^mailto:|^tel:|^#|^\//i;
-function getLinkValidationMessage(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return void 0;
-  if (/\s/.test(trimmed)) return "URL cannot contain spaces";
-  if (!VERBATIM_LINK_RE.test(trimmed) && !trimmed.includes(".")) {
-    return "Enter a valid URL (e.g. example.com)";
-  }
-  return void 0;
-}
 var InsertLinkPlugin = ({
   disabled,
-  open: externalOpen,
-  onClose
+  setIsLinkEditMode
 }) => {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
-  const [internalOpen, setInternalOpen] = React9.useState(false);
-  const [text, setText] = React9.useState("");
-  const [link$1, setLink] = React9.useState("");
   const iconColor = disabled ? "var(--colorNeutralForegroundDisabled, #A6A6A6)" : "#333333";
-  const isControlled = externalOpen !== void 0;
-  const isOpen = isControlled ? !!externalOpen && !disabled : internalOpen && !disabled;
-  const linkError = getLinkValidationMessage(link$1);
-  const handleClose = () => {
-    setText("");
-    setLink("");
-    if (isControlled) onClose?.();
-    else setInternalOpen(false);
-  };
-  const insertLink = (text2, link2) => {
+  const insertLink = () => {
     if (disabled) return;
-    if (getLinkValidationMessage(link2)) return;
-    const trimmedLink = link2.trim();
-    const href = VERBATIM_LINK_RE.test(trimmedLink) ? trimmedLink : `https://${trimmedLink}`;
     editor.update(() => {
       const selection = lexical.$getSelection();
-      if (lexical.$isRangeSelection(selection)) {
-        const textNode = new lexical.TextNode(text2);
-        const linkNode = link.$createLinkNode(href);
-        linkNode.append(textNode);
-        selection.insertNodes([linkNode]);
+      if (!lexical.$isRangeSelection(selection)) return;
+      const node = getSelectedNode2(selection);
+      const linkParent = utils.$findMatchingParent(node, link.$isLinkNode);
+      if (!linkParent && !link.$isLinkNode(node)) {
+        editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, "https://");
       }
     });
-    handleClose();
+    setIsLinkEditMode(true);
   };
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    !isControlled && /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Button,
-      {
-        size: "small",
-        title: "Add link",
-        disabled,
-        icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.LinkAddRegular, { style: { color: iconColor } }),
-        style: {
-          background: isOpen && !disabled ? "#ebebeb" : "none",
-          border: "none",
-          margin: 2,
-          opacity: disabled ? 0.55 : 1,
-          cursor: disabled ? "not-allowed" : "pointer"
-        },
-        onClick: () => {
-          if (disabled) return;
-          setInternalOpen((prev) => !prev);
-        }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactComponents.Button,
+    {
+      size: "small",
+      title: "Add link",
+      disabled,
+      icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.LinkAddRegular, { style: { color: iconColor } }),
+      style: {
+        background: "none",
+        border: "none",
+        margin: 2,
+        opacity: disabled ? 0.55 : 1,
+        cursor: disabled ? "not-allowed" : "pointer"
       },
-      "upload-link"
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Dialog,
-      {
-        open: isOpen,
-        onOpenChange: (_, data) => {
-          if (!data.open) handleClose();
-        },
-        children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: "380px" }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert Link" }),
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 10 }, style: { paddingTop: 8 }, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Text", orientation: "horizontal", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Input,
-              {
-                autoFocus: !disabled,
-                value: text,
-                appearance: "underline",
-                placeholder: "Text",
-                disabled,
-                onChange: (_, v) => setText(v.value)
-              }
-            ) }),
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Field,
-              {
-                label: "Link",
-                orientation: "horizontal",
-                size: "small",
-                validationState: linkError ? "error" : "none",
-                validationMessage: linkError,
-                children: /* @__PURE__ */ jsxRuntime.jsx(
-                  reactComponents.Input,
-                  {
-                    value: link$1,
-                    appearance: "underline",
-                    placeholder: "Link",
-                    disabled,
-                    onChange: (_, v) => setLink(v.value),
-                    onKeyDown: (e) => {
-                      if (e.key === "Enter" && text && link$1 && !linkError) insertLink(text, link$1);
-                    }
-                  }
-                )
-              }
-            )
-          ] }) }),
-          /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogActions, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Button,
-              {
-                appearance: "primary",
-                size: "small",
-                disabled: disabled || !text || !link$1 || !!linkError,
-                onClick: () => insertLink(text, link$1),
-                children: "Add"
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: handleClose, children: "Cancel" })
-          ] })
-        ] }) })
-      }
-    )
-  ] });
+      onClick: insertLink
+    },
+    "insert-link"
+  );
 };
 function PageSetupPlugin({ disabled, value, onChange }) {
   const sizeLabel = value.size === "pageless" ? "Pageless" : PAGE_SIZE_OPTIONS.find((o) => o.key === value.size)?.label ?? "Pageless";
@@ -6085,281 +6593,177 @@ function PageSetupPlugin({ disabled, value, onChange }) {
     }
   );
 }
-var MAX_ROWS = 50;
-var MAX_COLS = 50;
-var TableItemPlugin = ({
-  disabled,
-  open: externalOpen,
-  onClose
-}) => {
+var TableItemPlugin = ({ disabled }) => {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const [columns, setColumns] = React9.useState("");
   const [rows, setRows] = React9.useState("");
-  const [internalOpen, setInternalOpen] = React9.useState(false);
-  const [rowError, setRowError] = React9.useState("");
-  const [colError, setColError] = React9.useState("");
-  const isControlled = externalOpen !== void 0;
-  const isOpen = isControlled ? !!externalOpen && !disabled : internalOpen && !disabled;
+  const [isOpen, setIsOpen] = React9.useState(false);
   const iconColor = disabled ? "var(--colorNeutralForegroundDisabled, #A6A6A6)" : "#333333";
-  const handleClose = () => {
-    setRows("");
-    setColumns("");
-    setRowError("");
-    setColError("");
-    if (isControlled) onClose?.();
-    else setInternalOpen(false);
-  };
-  const onRowsChange = (val) => {
-    const clean = val.replace(/\D/g, "");
-    setRows(clean);
-    const n = Number(clean);
-    if (clean && n > MAX_ROWS) setRowError(`Maximum ${MAX_ROWS} rows allowed`);
-    else setRowError("");
-  };
-  const onColsChange = (val) => {
-    const clean = val.replace(/\D/g, "");
-    setColumns(clean);
-    const n = Number(clean);
-    if (clean && n > MAX_COLS) setColError(`Maximum ${MAX_COLS} columns allowed`);
-    else setColError("");
-  };
   const onAddTable = () => {
     if (disabled) return;
     const row = Number(rows);
     const col = Number(columns);
     if (!row || !col) return;
-    if (row > MAX_ROWS || col > MAX_COLS) return;
     editor.update(() => {
       const tableNode = table.$createTableNodeWithDimensions(row, col, true);
       utils.$insertNodeToNearestRoot(tableNode);
     });
-    handleClose();
+    setRows("");
+    setColumns("");
+    setIsOpen(false);
   };
-  const isAddDisabled = disabled || !rows || !columns || !!rowError || !!colError;
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    !isControlled && /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Button,
-      {
-        size: "small",
-        title: "Add table",
-        disabled,
-        icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TableAddRegular, { style: { color: iconColor } }),
-        style: {
-          background: isOpen && !disabled ? "#ebebeb" : "none",
-          border: "none",
-          margin: 2,
-          opacity: disabled ? 0.55 : 1,
-          cursor: disabled ? "not-allowed" : "pointer"
-        },
-        onClick: () => {
-          if (disabled) return;
-          setRows("");
-          setColumns("");
-          setRowError("");
-          setColError("");
-          setInternalOpen(true);
-        }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactComponents.Dialog,
+    {
+      open: disabled ? false : isOpen,
+      onOpenChange: (_, data) => {
+        if (!disabled) setIsOpen(data.open);
       },
-      "insert-table-nodes"
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Dialog,
-      {
-        open: isOpen,
-        onOpenChange: (_, data) => {
-          if (!data.open) handleClose();
-        },
-        children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: "380px" }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert Table" }),
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 10 }, style: { paddingTop: 8 }, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Field,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            title: "Add table",
+            disabled,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TableAddRegular, { style: { color: iconColor } }),
+            style: {
+              background: isOpen && !disabled ? "#ebebeb" : "none",
+              border: "none",
+              margin: 2,
+              opacity: disabled ? 0.55 : 1,
+              cursor: disabled ? "not-allowed" : "pointer"
+            },
+            onClick: () => {
+              if (disabled) return;
+              setIsOpen((prev) => !prev);
+              setRows("");
+              setColumns("");
+            }
+          },
+          "insert-table-nodes"
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: 300 }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert table" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 8 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Rows", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactComponents.Input,
               {
-                label: "Rows",
-                orientation: "horizontal",
-                size: "small",
-                validationMessage: rowError || void 0,
-                validationState: rowError ? "error" : "none",
-                children: /* @__PURE__ */ jsxRuntime.jsx(
-                  reactComponents.Input,
-                  {
-                    autoFocus: !disabled,
-                    type: "number",
-                    min: 1,
-                    max: MAX_ROWS,
-                    value: rows,
-                    placeholder: "Rows",
-                    appearance: "underline",
-                    disabled,
-                    input: { style: { textAlign: "left" } },
-                    onChange: (_, v) => onRowsChange(v.value)
-                  }
-                )
+                autoFocus: !disabled,
+                value: rows,
+                placeholder: "Rows",
+                appearance: "underline",
+                disabled,
+                onChange: (_, v) => setRows(v.value)
               }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Field,
+            ) }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "Columns", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactComponents.Input,
               {
-                label: "Columns",
-                orientation: "horizontal",
-                size: "small",
-                validationMessage: colError || void 0,
-                validationState: colError ? "error" : "none",
-                children: /* @__PURE__ */ jsxRuntime.jsx(
-                  reactComponents.Input,
-                  {
-                    type: "number",
-                    min: 1,
-                    max: MAX_COLS,
-                    value: columns,
-                    placeholder: "Columns",
-                    appearance: "underline",
-                    disabled,
-                    input: { style: { textAlign: "left" } },
-                    onChange: (_, v) => onColsChange(v.value)
-                  }
-                )
+                value: columns,
+                placeholder: "Columns",
+                appearance: "underline",
+                disabled,
+                onChange: (_, v) => setColumns(v.value)
               }
-            )
+            ) })
           ] }) }),
           /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogActions, { children: [
             /* @__PURE__ */ jsxRuntime.jsx(
               reactComponents.Button,
               {
-                appearance: "primary",
                 size: "small",
-                disabled: isAddDisabled,
+                appearance: "primary",
+                disabled: disabled || !rows || !columns,
                 onClick: onAddTable,
                 children: "Add"
               }
             ),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: handleClose, children: "Cancel" })
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: () => setIsOpen(false), children: "Cancel" })
           ] })
         ] }) })
-      }
-    )
-  ] });
+      ]
+    }
+  );
 };
-function extractYouTubeId(url) {
-  const trimmed = url.trim();
-  if (/^[\w-]{11}$/.test(trimmed)) return trimmed;
-  const match = /(?:youtu\.be\/|youtube\.com\/(?:watch\?v=|embed\/|v\/|shorts\/|live\/|u\/\w\/))([^#&?]{11})/.exec(trimmed);
-  return match ? match[1] : null;
-}
-var YoutubeUploadPlugin = ({
-  disabled,
-  open: externalOpen,
-  onClose
-}) => {
+var YoutubeUploadPlugin = ({ disabled }) => {
   const [url, setURL] = React9.useState("");
-  const [urlError, setUrlError] = React9.useState("");
-  const [internalOpen, setInternalOpen] = React9.useState(false);
+  const [isOpen, setIsOpen] = React9.useState(false);
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const iconColor = disabled ? "var(--colorNeutralForegroundDisabled, #A6A6A6)" : "#424242";
-  const isControlled = externalOpen !== void 0;
-  const isOpen = isControlled ? !!externalOpen && !disabled : internalOpen && !disabled;
-  const handleClose = () => {
-    setURL("");
-    setUrlError("");
-    if (isControlled) onClose?.();
-    else setInternalOpen(false);
-  };
   const onHandleEmbeded = () => {
     if (disabled) return;
     if (!url) return;
-    const id = extractYouTubeId(url);
-    if (!id) {
-      setUrlError("Invalid YouTube URL. Supported: watch?v=, youtu.be/, /shorts/, /live/");
-      return;
-    }
-    setUrlError("");
+    const match = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/.exec(url);
+    const id = match && match[2]?.length === 11 ? match[2] : null;
+    if (!id) return;
     editor.update(() => {
       const node = $createYouTubeNode(id);
       lexical.$insertNodes([node]);
     });
-    handleClose();
+    setURL("");
+    setIsOpen(false);
   };
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    !isControlled && /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Button,
-      {
-        title: "Add youtube URL",
-        size: "small",
-        disabled,
-        icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.VideoClipRegular, { style: { color: iconColor } }),
-        style: {
-          background: isOpen && !disabled ? "#ebebeb" : "none",
-          border: "none",
-          margin: 2,
-          opacity: disabled ? 0.55 : 1,
-          cursor: disabled ? "not-allowed" : "pointer"
-        },
-        onClick: () => {
-          if (disabled) return;
-          setURL("");
-          setUrlError("");
-          setInternalOpen(true);
-        }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactComponents.Dialog,
+    {
+      open: disabled ? false : isOpen,
+      onOpenChange: (_, data) => {
+        if (!disabled) setIsOpen(data.open);
       },
-      "upload-video"
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      reactComponents.Dialog,
-      {
-        open: isOpen,
-        onOpenChange: (_, data) => {
-          if (!data.open) handleClose();
-        },
-        children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: "420px" }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Insert YouTube Video" }),
-          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.Stack, { tokens: { childrenGap: 10 }, style: { paddingTop: 8 }, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Field,
-              {
-                label: "URL",
-                orientation: "horizontal",
-                size: "small",
-                validationState: urlError ? "error" : "none",
-                validationMessage: urlError || void 0,
-                children: /* @__PURE__ */ jsxRuntime.jsx(
-                  reactComponents.Input,
-                  {
-                    autoFocus: !disabled,
-                    disabled,
-                    value: url,
-                    appearance: "underline",
-                    placeholder: "Paste YouTube URL or video ID\u2026",
-                    onChange: (_, v) => {
-                      setURL(v.value);
-                      if (urlError) setUrlError("");
-                    },
-                    onKeyDown: (e) => {
-                      if (e.key === "Enter") onHandleEmbeded();
-                    }
-                  }
-                )
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 11, color: "#94a3b8", lineHeight: 1.5 }, children: "Supports: youtube.com/watch?v=\u2026, youtu.be/\u2026, /shorts/\u2026, /live/\u2026" })
-          ] }) }),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            title: "Add youtube URL",
+            size: "small",
+            disabled,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.VideoClipRegular, { style: { color: iconColor } }),
+            style: {
+              background: isOpen && !disabled ? "#ebebeb" : "none",
+              border: "none",
+              margin: 2,
+              opacity: disabled ? 0.55 : 1,
+              cursor: disabled ? "not-allowed" : "pointer"
+            },
+            onClick: () => {
+              if (disabled) return;
+              setIsOpen((prev) => !prev);
+              setURL("");
+            }
+          },
+          "upload-video"
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogSurface, { style: { maxWidth: 320 }, children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogBody, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogTitle, { children: "Embed YouTube video" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactComponents.DialogContent, { children: /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { tokens: { childrenGap: 8 }, children: /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Field, { label: "URL", size: "small", children: /* @__PURE__ */ jsxRuntime.jsx(
+            reactComponents.Input,
+            {
+              autoFocus: !disabled,
+              disabled,
+              value: url,
+              appearance: "underline",
+              placeholder: "Add Youtube video URL",
+              onChange: (_, v) => setURL(v.value)
+            }
+          ) }) }) }),
           /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.DialogActions, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Button,
-              {
-                appearance: "primary",
-                size: "small",
-                disabled: disabled || !url,
-                onClick: onHandleEmbeded,
-                children: "Add"
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: handleClose, children: "Cancel" })
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled: disabled || !url, onClick: onHandleEmbeded, children: "Add" }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Button, { size: "small", disabled, onClick: () => setIsOpen(false), children: "Cancel" })
           ] })
         ] }) })
-      }
-    )
-  ] });
+      ]
+    }
+  );
 };
+var TextAlphaListLtrFilled = ({ style }) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "1em", height: "1em", viewBox: "0 0 20 20", fill: "currentColor", "aria-hidden": "true", style, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8.75 4a.75.75 0 1 0 0 1.5h7.5a.75.75 0 0 0 0-1.5h-7.5Z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8.75 9a.75.75 0 1 0 0 1.5h7.5a.75.75 0 0 0 0-1.5h-7.5Z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 14.75c0-.41.34-.75.75-.75h7.5a.75.75 0 0 1 0 1.5h-7.5a.75.75 0 0 1-.75-.75Z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("text", { x: "3.5", y: "6", fontSize: "5.5", fontWeight: "bold", textAnchor: "middle", children: "a" }),
+  /* @__PURE__ */ jsxRuntime.jsx("text", { x: "3.5", y: "11", fontSize: "5.5", fontWeight: "bold", textAnchor: "middle", children: "b" }),
+  /* @__PURE__ */ jsxRuntime.jsx("text", { x: "3.5", y: "16", fontSize: "5.5", fontWeight: "bold", textAnchor: "middle", children: "c" })
+] });
 var useStyles4 = reactComponents.makeStyles({
   dropdown: {
     minInlineSize: "90px",
@@ -6377,25 +6781,42 @@ var ALLOWED_TOKENS = {
   Bold: true,
   Italic: true,
   Underline: true,
+  Strikethrough: true,
+  Subscript: true,
+  Superscript: true,
+  Highlight: true,
+  Uppercase: true,
+  Lowercase: true,
+  Capitalize: true,
+  BulletList: true,
+  NumberList: true,
+  AlphabeticalList: true,
+  Quote: true,
+  PageBreak: true,
+  H1: true,
+  H2: true,
+  H3: true,
+  H4: true,
+  H5: true,
+  H6: true,
   ColorPicker: true,
   Link: true,
   Table: true,
   Image: true,
   InlineImage: true,
   Youtube: true,
-  Insert: true,
-  Heading: true,
   FontFamily: true,
   FontSize: true,
+  Align: true,
+  Heading: true,
   Decorators: true,
   CodeBlock: true,
-  Align: true,
   PageSetup: true
 };
 function sanitizePluginGroups(groups) {
-  if (!groups || groups.length === 0) return [];
+  if (!Array.isArray(groups) || groups.length === 0) return [];
   return groups.map(
-    (g) => (g || []).map((t) => t.trim()).filter((t) => ALLOWED_TOKENS[t] === true)
+    (g) => (Array.isArray(g) ? g : []).map((t) => typeof t === "string" ? t.trim() : "").filter((t) => ALLOWED_TOKENS[t] === true)
   ).filter((g) => g.length > 0);
 }
 var ToolBarPlugins = (props) => {
@@ -6415,9 +6836,9 @@ var ToolBarPlugins = (props) => {
   const [isLowercase, setIsLowercase] = React9.useState(false);
   const [isCapitalize, setIsCapitalize] = React9.useState(false);
   const [alignment, setAlignment] = React9.useState("left");
-  const [activeInsertDialog, setActiveInsertDialog] = React9.useState(null);
-  const lastSelectionRef = React9__namespace.default.useRef(null);
-  const presetGroups = getToolbarGroupsByLevel(props.level);
+  const [decoratorOpen, setDecoratorOpen] = React9.useState(false);
+  const decoratorSelectingRef = React9__namespace.default.useRef(false);
+  const presetGroups = props.customToolbar ?? getToolbarGroupsByLevel(props.level);
   const pluginGroups = React9.useMemo(() => sanitizePluginGroups(presetGroups), [presetGroups]);
   const updateToolbarPlugins = () => {
     const selection = lexical.$getSelection();
@@ -6459,6 +6880,10 @@ var ToolBarPlugins = (props) => {
       setSelectNodeType("paragraph");
       return;
     }
+    if ($isAlphaListNode(element)) {
+      setSelectNodeType("alpha");
+      return;
+    }
     if (list.$isListNode(element)) {
       const parentList = utils.$getNearestNodeOfType(anchorNode, list.ListNode);
       const type2 = parentList ? parentList.getTag() : element.getTag();
@@ -6470,23 +6895,15 @@ var ToolBarPlugins = (props) => {
       ["paragraph", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "quote", "code"].includes(type) ? type : "paragraph"
     );
   };
-  const applyToBlock = React9__namespace.default.useCallback(
-    (fn) => {
-      editor.update(() => {
-        const saved = lastSelectionRef.current;
-        if (saved) lexical.$setSelection(saved.clone());
-        const sel = lexical.$getSelection();
-        if (lexical.$isRangeSelection(sel)) fn(sel);
-      });
-    },
-    [editor]
-  );
   const formatQuote = () => {
-    applyToBlock((selection$1) => {
+    editor.update(() => {
+      const selection$1 = lexical.$getSelection();
+      if (!lexical.$isRangeSelection(selection$1)) return;
       if (selectNodeType === "quote") {
-        selection.$setBlocksType(selection$1, () => lexical.$createParagraphNode());
+        formatParagraph(editor);
       } else {
-        selection.$setBlocksType(selection$1, () => richText.$createQuoteNode());
+        $splitBlocksAtLineBreaks(selection$1);
+        selection.$setBlocksType(lexical.$getSelection(), () => richText.$createQuoteNode());
       }
     });
   };
@@ -6503,8 +6920,6 @@ var ToolBarPlugins = (props) => {
       editor.registerCommand(
         lexical.SELECTION_CHANGE_COMMAND,
         () => {
-          const sel = lexical.$getSelection();
-          if (lexical.$isRangeSelection(sel)) lastSelectionRef.current = sel.clone();
           updateToolbarPlugins();
           return false;
         },
@@ -6536,52 +6951,16 @@ var ToolBarPlugins = (props) => {
         editor.dispatchCommand(lexical.FORMAT_TEXT_COMMAND, "highlight");
         break;
       case "leftAlign" /* LeftAlign */:
-        applyToBlock((sel) => {
-          const seen = /* @__PURE__ */ new Set();
-          sel.getNodes().forEach((n) => {
-            const t = n.getTopLevelElementOrThrow();
-            if (!seen.has(t.getKey())) {
-              seen.add(t.getKey());
-              t.setFormat("left");
-            }
-          });
-        });
+        applyAlignmentWithSplit("left");
         break;
       case "rightAlign" /* RightAlign */:
-        applyToBlock((sel) => {
-          const seen = /* @__PURE__ */ new Set();
-          sel.getNodes().forEach((n) => {
-            const t = n.getTopLevelElementOrThrow();
-            if (!seen.has(t.getKey())) {
-              seen.add(t.getKey());
-              t.setFormat("right");
-            }
-          });
-        });
+        applyAlignmentWithSplit("right");
         break;
       case "centerAlign" /* CenterAlign */:
-        applyToBlock((sel) => {
-          const seen = /* @__PURE__ */ new Set();
-          sel.getNodes().forEach((n) => {
-            const t = n.getTopLevelElementOrThrow();
-            if (!seen.has(t.getKey())) {
-              seen.add(t.getKey());
-              t.setFormat("center");
-            }
-          });
-        });
+        applyAlignmentWithSplit("center");
         break;
       case "justifyAlign" /* JustifyAlign */:
-        applyToBlock((sel) => {
-          const seen = /* @__PURE__ */ new Set();
-          sel.getNodes().forEach((n) => {
-            const t = n.getTopLevelElementOrThrow();
-            if (!seen.has(t.getKey())) {
-              seen.add(t.getKey());
-              t.setFormat("justify");
-            }
-          });
-        });
+        applyAlignmentWithSplit("justify");
         break;
       case "undo" /* Undo */:
         editor.dispatchCommand(lexical.UNDO_COMMAND, void 0);
@@ -6600,9 +6979,32 @@ var ToolBarPlugins = (props) => {
         break;
     }
   };
+  const applyAlignmentWithSplit = (formatType) => {
+    editor.update(() => {
+      const selection = lexical.$getSelection();
+      if (!lexical.$isRangeSelection(selection)) return;
+      $splitBlocksAtLineBreaks(selection);
+      const sel = lexical.$getSelection();
+      if (lexical.$isRangeSelection(sel)) {
+        $splitBlockAtPartialSelection(sel);
+      }
+    });
+    editor.dispatchCommand(lexical.FORMAT_ELEMENT_COMMAND, formatType);
+  };
   const updateHeading = (heading) => {
-    applyToBlock((selection$1) => {
-      selection.$setBlocksType(selection$1, () => richText.$createHeadingNode(heading));
+    editor.update(() => {
+      const selection$1 = lexical.$getSelection();
+      if (lexical.$isRangeSelection(selection$1)) {
+        $splitBlocksAtLineBreaks(selection$1);
+        const sel = lexical.$getSelection();
+        if (lexical.$isRangeSelection(sel)) {
+          $splitBlockAtPartialSelection(sel);
+        }
+        selection.$setBlocksType(lexical.$getSelection(), () => richText.$createHeadingNode(heading));
+      }
+    });
+    editor.getEditorState().read(() => {
+      updateToolbarPlugins();
     });
   };
   const renderToken = (token, groupIndex, tokenIndex) => {
@@ -6614,7 +7016,6 @@ var ToolBarPlugins = (props) => {
     const brand = palette.themePrimary;
     const brandHover = palette.themeDarkAlt ?? brand;
     const brandPressed = palette.themeDark ?? brand;
-    palette.white;
     const bgHover = palette.neutralLighter;
     const bgPressed = palette.neutralLight;
     const bgActive = palette.neutralLighterAlt ?? palette.neutralLighter;
@@ -6661,13 +7062,14 @@ var ToolBarPlugins = (props) => {
       marginRight: 8,
       verticalAlign: "middle"
     };
-    const isDisabled = !isEditable || !!props.readOnly;
     switch (token) {
       case "Bold":
         return /* @__PURE__ */ jsxRuntime.jsx(
           reactComponents.Button,
           {
             size: "small",
+            "aria-label": "Bold",
+            "aria-pressed": isBold,
             disabled: !isEditable || props.readOnly,
             icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextBold24Regular, { style: { color: getIconColor(isBold) } }),
             style: getButtonStyle(isBold),
@@ -6680,6 +7082,8 @@ var ToolBarPlugins = (props) => {
           reactComponents.Button,
           {
             size: "small",
+            "aria-label": "Italic",
+            "aria-pressed": isItalic,
             disabled: !isEditable || props.readOnly,
             icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextItalicFilled, { style: { color: getIconColor(isItalic) } }),
             style: getButtonStyle(isItalic),
@@ -6692,6 +7096,8 @@ var ToolBarPlugins = (props) => {
           reactComponents.Button,
           {
             size: "small",
+            "aria-label": "Underline",
+            "aria-pressed": isUnderline,
             disabled: !isEditable || props.readOnly,
             icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextUnderlineFilled, { style: { color: getIconColor(isUnderline) } }),
             style: getButtonStyle(isUnderline),
@@ -6702,7 +7108,14 @@ var ToolBarPlugins = (props) => {
       case "ColorPicker":
         return /* @__PURE__ */ jsxRuntime.jsx(ColorPickerPlugin, { disabled: !isEditable || props.readOnly }, key);
       case "Link":
-        return /* @__PURE__ */ jsxRuntime.jsx(InsertLinkPlugin, { disabled: !isEditable || props.readOnly }, key);
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          InsertLinkPlugin,
+          {
+            disabled: !isEditable || props.readOnly,
+            setIsLinkEditMode: props.setIsLinkEditMode
+          },
+          key
+        );
       case "Table":
         return /* @__PURE__ */ jsxRuntime.jsx(TableItemPlugin, { disabled: !isEditable || props.readOnly }, key);
       case "Image":
@@ -6710,7 +7123,9 @@ var ToolBarPlugins = (props) => {
           InsertImageDialog,
           {
             activeEditor: editor,
-            disabled: !isEditable || props.readOnly
+            disabled: !isEditable || props.readOnly,
+            maxImageSizeMB: props.maxImageSizeMB,
+            validationMessages: props.validationMessages
           },
           key
         );
@@ -6719,139 +7134,405 @@ var ToolBarPlugins = (props) => {
           InsertInlineImageDialog,
           {
             activeEditor: editor,
-            disabled: !isEditable || props.readOnly
+            disabled: !isEditable || props.readOnly,
+            maxImageSizeMB: props.maxImageSizeMB,
+            validationMessages: props.validationMessages
           },
           key
         );
       case "Youtube":
         return /* @__PURE__ */ jsxRuntime.jsx(YoutubeUploadPlugin, { disabled: !isEditable || props.readOnly }, key);
-      case "Insert": {
-        const menuIconColor = isDisabled ? fgDisabled : fg;
-        return /* @__PURE__ */ jsxRuntime.jsxs(React9__namespace.default.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Menu, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MenuTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsxRuntime.jsx(
-              reactComponents.Button,
-              {
-                size: "small",
-                disabled: isDisabled,
-                icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.AddRegular, { style: { color: menuIconColor } }),
-                style: {
-                  ...getButtonStyle(false),
-                  gap: 4,
-                  paddingInline: 8
-                },
-                children: "Insert"
-              }
-            ) }),
-            /* @__PURE__ */ jsxRuntime.jsx(reactComponents.MenuPopover, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.MenuList, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx(
-                reactComponents.MenuItem,
-                {
-                  icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TableAddRegular, { style: { color: menuIconColor } }),
-                  onClick: () => !isDisabled && setActiveInsertDialog("table"),
-                  children: "Table"
-                }
-              ),
-              /* @__PURE__ */ jsxRuntime.jsx(
-                reactComponents.MenuItem,
-                {
-                  icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageAddRegular, { style: { color: menuIconColor } }),
-                  onClick: () => !isDisabled && setActiveInsertDialog("image"),
-                  children: "Image"
-                }
-              ),
-              /* @__PURE__ */ jsxRuntime.jsx(
-                reactComponents.MenuItem,
-                {
-                  icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.ImageEditRegular, { style: { color: menuIconColor } }),
-                  onClick: () => !isDisabled && setActiveInsertDialog("inlineImage"),
-                  children: "Inline Image"
-                }
-              ),
-              /* @__PURE__ */ jsxRuntime.jsx(
-                reactComponents.MenuItem,
-                {
-                  icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.VideoClipRegular, { style: { color: menuIconColor } }),
-                  onClick: () => !isDisabled && setActiveInsertDialog("youtube"),
-                  children: "YouTube"
-                }
-              )
-            ] }) })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            TableItemPlugin,
-            {
-              disabled: isDisabled,
-              open: activeInsertDialog === "table",
-              onClose: () => setActiveInsertDialog(null)
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            InsertImageDialog,
-            {
-              activeEditor: editor,
-              disabled: isDisabled,
-              open: activeInsertDialog === "image",
-              onClose: () => setActiveInsertDialog(null)
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            InsertInlineImageDialog,
-            {
-              activeEditor: editor,
-              disabled: isDisabled,
-              open: activeInsertDialog === "inlineImage",
-              onClose: () => setActiveInsertDialog(null)
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            YoutubeUploadPlugin,
-            {
-              disabled: isDisabled,
-              open: activeInsertDialog === "youtube",
-              onClose: () => setActiveInsertDialog(null)
-            }
-          )
-        ] }, key);
-      }
       case "Heading": {
         const headingLabel = selectNodeType === "paragraph" ? "Normal" : HEADING_OPTION.find((h) => h.key === selectNodeType)?.text ?? selectNodeType;
         return /* @__PURE__ */ jsxRuntime.jsxs(
           reactComponents.Dropdown,
           {
-            title: "Add heading",
-            id: `heading-option-${groupIndex}`,
-            placeholder: "Format",
-            disabled: !isEditable,
-            style: { minWidth: "100px" },
-            className: styles.dropdown,
-            value: headingLabel,
-            selectedOptions: [selectNodeType],
-            onOptionSelect: (_, data) => {
-              const val = data.optionValue;
-              if (!val) return;
-              if (val === "paragraph") {
-                applyToBlock((sel) => selection.$setBlocksType(sel, () => lexical.$createParagraphNode()));
+            title: "Add heading",
+            id: `heading-option-${groupIndex}`,
+            placeholder: "Format",
+            disabled: !isEditable,
+            style: { minWidth: "100px" },
+            className: styles.dropdown,
+            value: headingLabel,
+            selectedOptions: [selectNodeType],
+            onOptionSelect: (_, data) => {
+              const val = data.optionValue;
+              if (!val) return;
+              if (val === "paragraph") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading(val);
+                setSelectNodeType(val);
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: "paragraph", children: "Normal" }),
+              HEADING_OPTION.map((option, idx) => /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: option.key, children: option.text }, `${option.key}-${idx}`))
+            ]
+          },
+          key
+        );
+      }
+      case "FontFamily":
+        return /* @__PURE__ */ jsxRuntime.jsx(FontFamilyPlugin, { disabled: !isEditable || props.readOnly }, key);
+      case "FontSize":
+        return /* @__PURE__ */ jsxRuntime.jsx(FontSizePlugin, { disabled: !isEditable || props.readOnly }, key);
+      case "|":
+        return /* @__PURE__ */ jsxRuntime.jsx(reactComponents.ToolbarDivider, {}, key);
+      // ── Standalone text-format toggle buttons ─────────────────────────────
+      // These were previously only accessible inside the 'Decorators' dropdown.
+      // Use them directly in customToolbar to show individual buttons instead.
+      case "Strikethrough":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Strikethrough",
+            "aria-pressed": isStrikethrough,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextStrikethroughFilled, { style: { color: getIconColor(isStrikethrough) } }),
+            style: getButtonStyle(isStrikethrough),
+            onClick: () => onHandleSelectOption("strike" /* Strikethrough */)
+          },
+          key
+        );
+      case "Subscript":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Subscript",
+            "aria-pressed": isSubscript,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextSubscriptFilled, { style: { color: getIconColor(isSubscript) } }),
+            style: getButtonStyle(isSubscript),
+            onClick: () => onHandleSelectOption("subscript" /* Subscript */)
+          },
+          key
+        );
+      case "Superscript":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Superscript",
+            "aria-pressed": isSuperscript,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextSuperscriptFilled, { style: { color: getIconColor(isSuperscript) } }),
+            style: getButtonStyle(isSuperscript),
+            onClick: () => onHandleSelectOption("superscript" /* Superscript */)
+          },
+          key
+        );
+      case "Highlight":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Highlight",
+            "aria-pressed": isHighlight,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(
+              reactIcons.HighlightAccentFilled,
+              {
+                style: { color: isEditable ? isHighlight ? brand : fg : fgDisabled }
+              }
+            ),
+            style: getButtonStyle(isHighlight),
+            onClick: () => onHandleSelectOption("highlight" /* Highlight */)
+          },
+          key
+        );
+      case "Uppercase":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Uppercase",
+            "aria-pressed": isUppercase,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextCaseUppercaseFilled, { style: { color: getIconColor(isUppercase) } }),
+            style: getButtonStyle(isUppercase),
+            onClick: () => editor.dispatchCommand(lexical.FORMAT_TEXT_COMMAND, "uppercase")
+          },
+          key
+        );
+      case "Lowercase":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Lowercase",
+            "aria-pressed": isLowercase,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextCaseLowercaseFilled, { style: { color: getIconColor(isLowercase) } }),
+            style: getButtonStyle(isLowercase),
+            onClick: () => onHandleSelectOption("lowercase" /* Lowercase */)
+          },
+          key
+        );
+      case "Capitalize":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Capitalize",
+            "aria-pressed": isCapitalize,
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextCaseTitleFilled, { style: { color: getIconColor(isCapitalize) } }),
+            style: getButtonStyle(isCapitalize),
+            onClick: () => onHandleSelectOption("capitalize" /* Capitalize */)
+          },
+          key
+        );
+      // ── Standalone list toggle buttons ────────────────────────────────────
+      case "BulletList":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Bullet list",
+            "aria-pressed": selectNodeType === "ul",
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextBulletListLtrFilled, { style: { color: getIconColor(selectNodeType === "ul") } }),
+            style: getButtonStyle(selectNodeType === "ul"),
+            onClick: () => editor.dispatchCommand(
+              selectNodeType === "ul" ? list.REMOVE_LIST_COMMAND : list.INSERT_UNORDERED_LIST_COMMAND,
+              void 0
+            )
+          },
+          key
+        );
+      case "NumberList":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Number list",
+            "aria-pressed": selectNodeType === "ol",
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextNumberListLtrFilled, { style: { color: getIconColor(selectNodeType === "ol") } }),
+            style: getButtonStyle(selectNodeType === "ol"),
+            onClick: () => editor.dispatchCommand(
+              selectNodeType === "ol" ? list.REMOVE_LIST_COMMAND : list.INSERT_ORDERED_LIST_COMMAND,
+              void 0
+            )
+          },
+          key
+        );
+      case "AlphabeticalList":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Alphabetical list",
+            "aria-pressed": selectNodeType === "alpha",
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(
+              TextAlphaListLtrFilled,
+              {
+                style: { color: getIconColor(selectNodeType === "alpha") }
+              }
+            ),
+            style: getButtonStyle(selectNodeType === "alpha"),
+            onClick: () => editor.update(() => $toggleAlphaList())
+          },
+          key
+        );
+      // ── Standalone block buttons ──────────────────────────────────────────
+      case "Quote":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Quote",
+            "aria-pressed": selectNodeType === "quote",
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.CommentQuoteRegular, { style: { color: getIconColor(selectNodeType === "quote") } }),
+            style: getButtonStyle(selectNodeType === "quote"),
+            onClick: () => formatQuote()
+          },
+          key
+        );
+      case "PageBreak":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Page break",
+            disabled: !isEditable || props.readOnly,
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.DocumentPageBreakRegular, { style: { color: getIconColor() } }),
+            style: getButtonStyle(),
+            onClick: () => editor.dispatchCommand(INSERT_PAGE_BREAK, void 0)
+          },
+          key
+        );
+      // ── Standalone heading-level toggle buttons ───────────────────────────
+      // Each button sets (or toggles off) that specific heading level.
+      // Clicking an active heading reverts to normal paragraph.
+      case "H1":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 1",
+            "aria-pressed": selectNodeType === "h1",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h1"),
+              color: getIconColor(selectNodeType === "h1"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h1") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading("h1");
+                setSelectNodeType("h1");
+              }
+            },
+            children: "H1"
+          },
+          key
+        );
+      case "H2":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 2",
+            "aria-pressed": selectNodeType === "h2",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h2"),
+              color: getIconColor(selectNodeType === "h2"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h2") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading("h2");
+                setSelectNodeType("h2");
+              }
+            },
+            children: "H2"
+          },
+          key
+        );
+      case "H3":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 3",
+            "aria-pressed": selectNodeType === "h3",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h3"),
+              color: getIconColor(selectNodeType === "h3"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h3") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading("h3");
+                setSelectNodeType("h3");
+              }
+            },
+            children: "H3"
+          },
+          key
+        );
+      case "H4":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 4",
+            "aria-pressed": selectNodeType === "h4",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h4"),
+              color: getIconColor(selectNodeType === "h4"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h4") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading("h4");
+                setSelectNodeType("h4");
+              }
+            },
+            children: "H4"
+          },
+          key
+        );
+      case "H5":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 5",
+            "aria-pressed": selectNodeType === "h5",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h5"),
+              color: getIconColor(selectNodeType === "h5"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h5") {
+                formatParagraph(editor);
                 setSelectNodeType("paragraph");
               } else {
-                updateHeading(val);
-                setSelectNodeType(val);
+                updateHeading("h5");
+                setSelectNodeType("h5");
               }
             },
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: "paragraph", children: "Normal" }),
-              HEADING_OPTION.map((option, idx) => /* @__PURE__ */ jsxRuntime.jsx(reactComponents.Option, { value: option.key, children: option.text }, `${option.key}-${idx}`))
-            ]
+            children: "H5"
+          },
+          key
+        );
+      case "H6":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactComponents.Button,
+          {
+            size: "small",
+            "aria-label": "Heading 6",
+            "aria-pressed": selectNodeType === "h6",
+            disabled: !isEditable || props.readOnly,
+            style: {
+              ...getButtonStyle(selectNodeType === "h6"),
+              color: getIconColor(selectNodeType === "h6"),
+              fontSize: 12,
+              fontWeight: 600
+            },
+            onClick: () => {
+              if (selectNodeType === "h6") {
+                formatParagraph(editor);
+                setSelectNodeType("paragraph");
+              } else {
+                updateHeading("h6");
+                setSelectNodeType("h6");
+              }
+            },
+            children: "H6"
           },
           key
         );
-      }
-      case "FontFamily":
-        return /* @__PURE__ */ jsxRuntime.jsx(FontFamilyPlugin, { disabled: !isEditable || props.readOnly }, key);
-      case "FontSize":
-        return /* @__PURE__ */ jsxRuntime.jsx(FontSizePlugin, { disabled: !isEditable || props.readOnly }, key);
-      case "|":
-        return /* @__PURE__ */ jsxRuntime.jsx(reactComponents.ToolbarDivider, {}, key);
       case "Decorators": {
         const activeDecorators = [
           ...isUppercase ? ["uppercase"] : [],
@@ -6863,6 +7544,7 @@ var ToolBarPlugins = (props) => {
           ...isHighlight ? ["highlight"] : [],
           ...selectNodeType === "ul" ? ["ul-list"] : [],
           ...selectNodeType === "ol" ? ["ol-list"] : [],
+          ...selectNodeType === "alpha" ? ["al-list"] : [],
           ...selectNodeType === "quote" ? ["quote"] : []
         ];
         const DECORATOR_LABEL = {
@@ -6875,6 +7557,7 @@ var ToolBarPlugins = (props) => {
           highlight: "Highlight",
           "ul-list": "Bullet list",
           "ol-list": "Number list",
+          "al-list": "Alphabetical list",
           quote: "Quote"
         };
         const decoratorValue = activeDecorators.length === 0 ? "" : activeDecorators.length === 1 ? DECORATOR_LABEL[activeDecorators[0]] : `${DECORATOR_LABEL[activeDecorators[0]]} +${activeDecorators.length - 1}`;
@@ -6891,7 +7574,16 @@ var ToolBarPlugins = (props) => {
             button: { style: dropdownButtonStyle },
             expandIcon: { style: dropdownExpandIconStyle },
             listbox: { style: { minInlineSize: "180px" } },
+            open: decoratorOpen,
+            onOpenChange: (_, data) => {
+              if (decoratorSelectingRef.current) {
+                decoratorSelectingRef.current = false;
+                return;
+              }
+              setDecoratorOpen(data.open);
+            },
             onOptionSelect: (_, data) => {
+              decoratorSelectingRef.current = true;
               switch (data.optionValue) {
                 case "uppercase":
                   editor.dispatchCommand(lexical.FORMAT_TEXT_COMMAND, "uppercase");
@@ -6915,10 +7607,19 @@ var ToolBarPlugins = (props) => {
                   onHandleSelectOption("highlight" /* Highlight */);
                   break;
                 case "ul-list":
-                  editor.dispatchCommand(selectNodeType === "ul" ? list.REMOVE_LIST_COMMAND : list.INSERT_UNORDERED_LIST_COMMAND, void 0);
+                  editor.dispatchCommand(
+                    selectNodeType === "ul" ? list.REMOVE_LIST_COMMAND : list.INSERT_UNORDERED_LIST_COMMAND,
+                    void 0
+                  );
                   break;
                 case "ol-list":
-                  editor.dispatchCommand(selectNodeType === "ol" ? list.REMOVE_LIST_COMMAND : list.INSERT_ORDERED_LIST_COMMAND, void 0);
+                  editor.dispatchCommand(
+                    selectNodeType === "ol" ? list.REMOVE_LIST_COMMAND : list.INSERT_ORDERED_LIST_COMMAND,
+                    void 0
+                  );
+                  break;
+                case "al-list":
+                  editor.update(() => $toggleAlphaList());
                   break;
                 case "page-break":
                   editor.dispatchCommand(INSERT_PAGE_BREAK, void 0);
@@ -6954,7 +7655,12 @@ var ToolBarPlugins = (props) => {
                 "Superscript"
               ] }),
               /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Option, { value: "highlight", text: "Highlight", children: [
-                /* @__PURE__ */ jsxRuntime.jsx(reactIcons.HighlightAccentFilled, { style: { ...optionIconStyle, color: isEditable ? brand : fgDisabled } }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  reactIcons.HighlightAccentFilled,
+                  {
+                    style: { ...optionIconStyle, color: isEditable ? brand : fgDisabled }
+                  }
+                ),
                 "Highlight"
               ] }),
               /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Option, { value: "ul-list", text: "Bullet list", children: [
@@ -6965,6 +7671,10 @@ var ToolBarPlugins = (props) => {
                 /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextNumberListLtrFilled, { style: optionIconStyle }),
                 "Number list"
               ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Option, { value: "al-list", text: "Alphabetical list", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(TextAlphaListLtrFilled, { style: optionIconStyle }),
+                "Alphabetical list"
+              ] }),
               /* @__PURE__ */ jsxRuntime.jsxs(reactComponents.Option, { value: "page-break", text: "Page Break", children: [
                 /* @__PURE__ */ jsxRuntime.jsx(reactIcons.DocumentPageBreakRegular, { style: optionIconStyle }),
                 "Page break"
@@ -6990,10 +7700,30 @@ var ToolBarPlugins = (props) => {
       //   );
       case "Align": {
         const ALIGN_OPTIONS = [
-          { value: "left", label: "Left Align", icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignLeftFilled, { style: optionIconStyle }), action: "leftAlign" /* LeftAlign */ },
-          { value: "center", label: "Center Align", icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignCenterFilled, { style: optionIconStyle }), action: "centerAlign" /* CenterAlign */ },
-          { value: "right", label: "Right Align", icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignRightFilled, { style: optionIconStyle }), action: "rightAlign" /* RightAlign */ },
-          { value: "justify", label: "Justify Align", icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignJustifyFilled, { style: optionIconStyle }), action: "justifyAlign" /* JustifyAlign */ }
+          {
+            value: "left",
+            label: "Left Align",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignLeftFilled, { style: optionIconStyle }),
+            action: "leftAlign" /* LeftAlign */
+          },
+          {
+            value: "center",
+            label: "Center Align",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignCenterFilled, { style: optionIconStyle }),
+            action: "centerAlign" /* CenterAlign */
+          },
+          {
+            value: "right",
+            label: "Right Align",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignRightFilled, { style: optionIconStyle }),
+            action: "rightAlign" /* RightAlign */
+          },
+          {
+            value: "justify",
+            label: "Justify Align",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(reactIcons.TextAlignJustifyFilled, { style: optionIconStyle }),
+            action: "justifyAlign" /* JustifyAlign */
+          }
         ];
         const alignLabel = ALIGN_OPTIONS.find((o) => o.value === alignment)?.label ?? "Left Align";
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -7209,32 +7939,31 @@ function BrowserSpellCheckPlugin({ enabled }) {
   }, [editor, enabled]);
   return null;
 }
-function WordCountPlugin({
-  onCountChange
-}) {
-  const [editor] = LexicalComposerContext.useLexicalComposerContext();
-  React9.useEffect(() => {
-    return editor.registerUpdateListener(({ editorState }) => {
-      editorState.read(() => {
-        const text = lexical.$getRoot().getTextContent();
-        const words = text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
-        onCountChange(words);
-      });
-    });
-  }, [editor, onCountChange]);
-  return null;
-}
-function CharCountPlugin({
-  onCountChange
+function ContentMetricsPlugin({
+  onMetricsChange
 }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const prevRef = React9.useRef({ words: 0, chars: 0, images: 0, links: 0, tables: 0 });
   React9.useEffect(() => {
-    return editor.registerUpdateListener(({ editorState }) => {
-      editorState.read(() => {
-        onCountChange(lexical.$getRoot().getTextContent().length);
-      });
+    return editor.registerUpdateListener(({ dirtyElements, dirtyLeaves }) => {
+      if (dirtyElements.size === 0 && dirtyLeaves.size === 0) return;
+      const root = editor.getRootElement();
+      if (!root) return;
+      const text = root.innerText ?? "";
+      const trimmed = text.trim();
+      const words = trimmed === "" ? 0 : trimmed.split(/\s+/).length;
+      const chars = trimmed.length;
+      const images = root.querySelectorAll("img").length;
+      const links = root.querySelectorAll("a[href]").length;
+      const tables = root.querySelectorAll("table").length;
+      const prev = prevRef.current;
+      if (prev.words !== words || prev.chars !== chars || prev.images !== images || prev.links !== links || prev.tables !== tables) {
+        const next = { words, chars, images, links, tables };
+        prevRef.current = next;
+        onMetricsChange(next);
+      }
     });
-  }, [editor, onCountChange]);
+  }, [editor, onMetricsChange]);
   return null;
 }
 function FocusEventsPlugin({
@@ -7255,7 +7984,8 @@ function FocusEventsPlugin({
       const next = e.relatedTarget;
       const container = containerRef.current;
       const stillInside = !!next && (container ? container.contains(next) : root.contains(next));
-      if (stillInside) return;
+      const isEditorPortal = !!next?.closest?.("[data-lexical-editor-portal]");
+      if (stillInside || isEditorPortal) return;
       editor.update(() => {
         lexical.$setSelection(null);
       });
@@ -7310,10 +8040,7 @@ function _adaptRawSpell(data, text) {
   }
   const rawGrammar = data.grammar_correction ?? data.improved_text;
   const grammarCorrection = rawGrammar && rawGrammar.trim() !== text.trim() ? rawGrammar.trim() : void 0;
-  return {
-    issues: issues.sort((a, b) => a.offset - b.offset),
-    grammarCorrection
-  };
+  return { issues: issues.sort((a, b) => a.offset - b.offset), grammarCorrection };
 }
 function _adaptRawSuggest(data) {
   if (!data) return null;
@@ -7368,387 +8095,460 @@ function _makeQueryFn(fn) {
     };
   };
 }
-var ContentEditorComponent = React9.forwardRef((props, ref) => {
-  const isReadOnly = !!props.readOnly;
-  const resolvedSpellCheck = React9__namespace.default.useMemo(
-    () => props.spellCheckFn ? _makeSpellCheckFn(props.spellCheckFn) : props.useSpellCheck,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [props.spellCheckFn, props.useSpellCheck]
-  );
-  const resolvedQuery = React9__namespace.default.useMemo(
-    () => props.suggestFn ? _makeQueryFn(props.suggestFn) : props.useQuery,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [props.suggestFn, props.useQuery]
-  );
-  const [floatingAnchorElem, setFloatingAnchorElem] = React9.useState(null);
-  const [isLinkEditMode, setIsLinkEditMode] = React9.useState(false);
-  const [wordCount, setWordCount] = React9.useState(0);
-  const handleWordCount = React9.useCallback(
-    (count) => setWordCount(count),
-    []
-  );
-  const [charCount, setCharCount] = React9.useState(0);
-  const handleCharCount = React9.useCallback(
-    (count) => setCharCount(count),
-    []
-  );
-  const [refErrors, setRefErrors] = React9.useState([]);
-  const [pageSetup, setPageSetup] = React9.useState(DEFAULT_PAGE_SETUP);
-  const pageCanvas = resolvePageCanvasMetrics(pageSetup);
-  const contentEditableDomRef = React9.useRef(null);
-  const previousOverLimitRef = React9.useRef(false);
-  const focusedRef = React9.useRef(false);
-  const setFocused = (focused) => {
-    focusedRef.current = focused;
-  };
-  const containerRef = React9.useRef(null);
-  const onAnchorRef = (elem) => {
-    if (elem) setFloatingAnchorElem(elem);
-  };
-  const initialConfig = {
-    namespace: props.namespace,
-    theme,
-    onError: () => {
-    },
-    nodes: [
-      richText.HeadingNode,
-      richText.QuoteNode,
-      code.CodeHighlightNode,
-      code.CodeNode,
-      list.ListNode,
-      list.ListItemNode,
-      link.LinkNode,
-      link.AutoLinkNode,
-      table.TableNode,
-      table.TableRowNode,
-      table.TableCellNode,
-      ImageNode,
-      InlineImageNode,
-      YouTubeNode,
-      PageBreakNode,
-      AutocompleteNode,
-      SpellErrorNode,
-      HtmlBlockNode
-    ]
-  };
-  const EditorStyles = react.mergeStyleSets({
-    editorPlaceholder: {
-      color: "var(--colorNeutralForeground3, grey)",
-      position: "absolute",
-      top: props.level !== "none" /* None */ ? "17px" : "27px",
-      left: pageCanvas.paddingPx,
-      right: pageCanvas.paddingPx,
-      fontSize: "14px",
-      pointerEvents: "none",
-      userSelect: "none"
-    },
-    contentEditor: {
-      zIndex: 0,
-      flex: "auto",
-      outline: "none",
-      overflow: "auto",
-      marginTop: "0px",
-      position: "relative",
-      background: "var(--colorNeutralBackground1, #ffffff)",
-      justifyContent: "center",
-      height: props.contentHeight ?? "100%",
-      ...isReadOnly && {
-        cursor: "not-allowed",
-        opacity: 0.75,
-        userSelect: "text"
-      }
-    }
-  });
-  const urlRegExp = new RegExp(
-    /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
-  );
-  const validateUrl = (url) => url === "https://" || urlRegExp.test(url);
-  const handleReadOnlyClickCapture = (e) => {
-    if (!isReadOnly) return;
-    const target = e.target;
-    const anchor = target?.closest?.("a");
-    if (anchor) {
-      e.preventDefault();
-      e.stopPropagation();
-    }
-  };
-  const [touched, setTouched] = React9.useState(false);
-  const isOverLimit = props.wordLimit !== void 0 && wordCount > props.wordLimit;
-  const internalErrors = [];
-  if (isOverLimit) {
-    const m = props.errorMessages?.wordLimitExceeded;
-    internalErrors.push(
-      typeof m === "function" ? m(wordCount, props.wordLimit) : m ?? `Word limit exceeded (${wordCount} / ${props.wordLimit} words used)`
-    );
-  }
-  if (props.required && touched && wordCount === 0) {
-    internalErrors.push(
-      props.errorMessages?.required ?? "This field is required"
-    );
-  }
-  if (props.minWords !== void 0 && touched && wordCount < props.minWords) {
-    const m = props.errorMessages?.minWords;
-    internalErrors.push(
-      typeof m === "function" ? m(wordCount, props.minWords) : m ?? `Minimum ${props.minWords} words required (${wordCount} entered)`
-    );
-  }
-  if (props.maxChars !== void 0 && charCount > props.maxChars) {
-    const m = props.errorMessages?.maxCharsExceeded;
-    internalErrors.push(
-      typeof m === "function" ? m(charCount, props.maxChars) : m ?? `Character limit exceeded (${charCount} / ${props.maxChars} characters used)`
+function EditorReadyPlugin({ onReady }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const calledRef = React9.useRef(false);
+  React9.useEffect(() => {
+    if (!onReady || calledRef.current) return;
+    calledRef.current = true;
+    onReady(editor);
+  }, [editor, onReady]);
+  return null;
+}
+var ContentEditorComponent = React9.forwardRef(
+  (props, ref) => {
+    const isReadOnly = !!props.readOnly;
+    const resolvedSpellCheck = React9__namespace.default.useMemo(
+      () => props.spellCheckFn ? _makeSpellCheckFn(props.spellCheckFn) : props.useSpellCheck,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [props.spellCheckFn, props.useSpellCheck]
     );
-  }
-  if (props.minChars !== void 0 && touched && charCount < props.minChars && charCount > 0) {
-    const m = props.errorMessages?.minCharsRequired;
-    internalErrors.push(
-      typeof m === "function" ? m(charCount, props.minChars) : m ?? `Minimum ${props.minChars} characters required (${charCount} entered)`
+    const resolvedQuery = React9__namespace.default.useMemo(
+      () => props.suggestFn ? _makeQueryFn(props.suggestFn) : props.useQuery,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [props.suggestFn, props.useQuery]
     );
-  }
-  const allErrors = [
-    ...internalErrors,
-    ...props.errors ?? [],
-    ...refErrors
-  ];
-  const hasErrors = allErrors.length > 0;
-  const hasRedBorder = hasErrors;
-  React9.useEffect(() => {
-    if (props.wordLimit === void 0 || !props.onWordLimitExceeded) return;
-    const wasOverLimit = previousOverLimitRef.current;
-    if (isOverLimit !== wasOverLimit) {
-      props.onWordLimitExceeded({
-        wordCount,
-        wordLimit: props.wordLimit,
-        exceeded: isOverLimit
-      });
-      previousOverLimitRef.current = isOverLimit;
-    }
-  }, [isOverLimit, wordCount, props.wordLimit, props.onWordLimitExceeded]);
-  return /* @__PURE__ */ jsxRuntime.jsx(reactComponents.FluentProvider, { theme: reactComponents.webLightTheme, style: { height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsx(LexicalComposer.LexicalComposer, { initialConfig, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, style: { height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsxs(
-    react.Stack,
-    {
-      style: {
-        zIndex: 1e3,
-        background: "#fff",
-        borderRadius: "2px",
-        width: props.width ?? "100%",
-        height: props.height ?? "100%",
-        margin: props.margin ?? "5px auto",
-        border: `1px solid ${hasRedBorder ? "#c4272c" : "var(--colorNeutralStroke1, #ccced1)"}`,
-        transition: "border-color 0.2s",
-        display: "flex",
-        flexDirection: "column"
+    const [floatingAnchorElem, setFloatingAnchorElem] = React9.useState(null);
+    const [isLinkEditMode, setIsLinkEditMode] = React9.useState(false);
+    const [metrics, setMetrics] = React9.useState({
+      words: 0,
+      chars: 0,
+      images: 0,
+      links: 0,
+      tables: 0
+    });
+    const handleMetrics = React9.useCallback((m) => setMetrics(m), []);
+    const [pageSetup, setPageSetup] = React9.useState(DEFAULT_PAGE_SETUP);
+    const pageCanvas = resolvePageCanvasMetrics(pageSetup);
+    const wordCount = metrics.words;
+    const contentEditableDomRef = React9.useRef(null);
+    const previousOverLimitRef = React9.useRef(false);
+    const focusedRef = React9.useRef(false);
+    const setFocused = (focused) => {
+      focusedRef.current = focused;
+    };
+    const containerRef = React9.useRef(null);
+    const onAnchorRef = (elem) => {
+      if (elem) setFloatingAnchorElem(elem);
+    };
+    const initialConfig = React9__namespace.default.useMemo(() => {
+      const config = {
+        namespace: props.namespace ?? "",
+        theme,
+        onError: () => {
+        },
+        nodes: [
+          richText.HeadingNode,
+          richText.QuoteNode,
+          code.CodeHighlightNode,
+          code.CodeNode,
+          list.ListNode,
+          list.ListItemNode,
+          AlphaListNode,
+          link.LinkNode,
+          link.AutoLinkNode,
+          table.TableNode,
+          table.TableRowNode,
+          table.TableCellNode,
+          ImageNode,
+          InlineImageNode,
+          YouTubeNode,
+          PageBreakNode,
+          AutocompleteNode,
+          SpellErrorNode,
+          HtmlBlockNode
+        ]
+      };
+      props.onBeforeInitialize?.(config);
+      return config;
+    }, []);
+    const EditorStyles = react.mergeStyleSets({
+      editorPlaceholder: {
+        color: "var(--colorNeutralForeground3, grey)",
+        position: "absolute",
+        top: props.level !== "none" /* None */ ? "17px" : "27px",
+        left: pageCanvas.paddingPx,
+        right: pageCanvas.paddingPx,
+        fontSize: "14px",
+        pointerEvents: "none",
+        userSelect: "none"
       },
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "div",
-          {
-            style: {
-              pointerEvents: isReadOnly ? "none" : "auto",
-              position: "sticky",
-              opacity: isReadOnly ? 0.85 : 1
-            },
-            children: /* @__PURE__ */ jsxRuntime.jsx(
-              ToolBarPlugins,
+      contentEditor: {
+        zIndex: 0,
+        flex: "auto",
+        outline: "none",
+        overflow: "auto",
+        marginTop: "0px",
+        position: "relative",
+        background: "var(--colorNeutralBackground1, #ffffff)",
+        justifyContent: "center",
+        height: props.contentHeight ?? "100%",
+        ...isReadOnly && {
+          cursor: "not-allowed",
+          opacity: 0.75,
+          userSelect: "text"
+        }
+      }
+    });
+    const urlRegExp = new RegExp(
+      /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
+    );
+    const validateUrl = (url) => url === "https://" || urlRegExp.test(url);
+    const handleReadOnlyClickCapture = (e) => {
+      if (!isReadOnly) return;
+      const target = e.target;
+      const anchor = target?.closest?.("a");
+      if (anchor) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    const isOverLimit = props.wordLimit !== void 0 && wordCount > props.wordLimit;
+    React9.useEffect(() => {
+      if (props.wordLimit === void 0 || !props.onWordLimitExceeded) return;
+      const wasOverLimit = previousOverLimitRef.current;
+      if (isOverLimit !== wasOverLimit) {
+        props.onWordLimitExceeded({
+          wordCount,
+          wordLimit: props.wordLimit,
+          exceeded: isOverLimit
+        });
+        previousOverLimitRef.current = isOverLimit;
+      }
+    }, [isOverLimit, wordCount, props.wordLimit, props.onWordLimitExceeded]);
+    const validationErrors = React9__namespace.default.useMemo(() => {
+      const errors = [];
+      const custom = props.validationMessages ?? {};
+      const { words, chars, images, links, tables } = metrics;
+      const msg = (key, ...args) => {
+        const override = custom[key];
+        if (override !== void 0) {
+          return typeof override === "function" ? override(...args) : override;
+        }
+        const def = DEFAULT_VALIDATION_MESSAGES[key];
+        return typeof def === "function" ? def(...args) : def;
+      };
+      const requiredFired = props.required && words === 0;
+      if (requiredFired) {
+        errors.push({ type: "required", message: msg("required") });
+      } else if (props.minWords !== void 0 && words < props.minWords) {
+        errors.push({ type: "minWords", message: msg("minWords", words, props.minWords) });
+      }
+      const effectiveMaxWords = props.maxWords ?? props.wordLimit;
+      if (effectiveMaxWords !== void 0 && words > effectiveMaxWords) {
+        errors.push({ type: "maxWords", message: msg("maxWords", words, effectiveMaxWords) });
+      }
+      if (!requiredFired && props.minChars !== void 0 && chars < props.minChars) {
+        errors.push({ type: "minChars", message: msg("minChars", chars, props.minChars) });
+      }
+      if (props.maxChars !== void 0 && chars > props.maxChars) {
+        errors.push({ type: "maxChars", message: msg("maxChars", chars, props.maxChars) });
+      }
+      if (props.noImages && images > 0) {
+        errors.push({ type: "noImages", message: msg("noImages") });
+      } else if (props.maxImages !== void 0 && images > props.maxImages) {
+        errors.push({ type: "maxImages", message: msg("maxImages", images, props.maxImages) });
+      }
+      if (props.noLinks && links > 0) {
+        errors.push({ type: "noLinks", message: msg("noLinks") });
+      } else if (props.maxLinks !== void 0 && links > props.maxLinks) {
+        errors.push({ type: "maxLinks", message: msg("maxLinks", links, props.maxLinks) });
+      }
+      if (props.noTables && tables > 0) {
+        errors.push({ type: "noTables", message: msg("noTables") });
+      }
+      return errors;
+    }, [
+      metrics,
+      props.required,
+      props.minWords,
+      props.maxWords,
+      props.wordLimit,
+      props.minChars,
+      props.maxChars,
+      props.noImages,
+      props.maxImages,
+      props.noLinks,
+      props.maxLinks,
+      props.noTables,
+      props.validationMessages
+    ]);
+    const previousErrorTypesRef = React9.useRef("");
+    React9.useEffect(() => {
+      if (!props.onValidationChange) return;
+      const key = validationErrors.map((e) => e.type).join(",");
+      if (key !== previousErrorTypesRef.current) {
+        previousErrorTypesRef.current = key;
+        props.onValidationChange(validationErrors);
+      }
+    }, [validationErrors, props.onValidationChange]);
+    const trimmedErrorMessage = props.errorMessage?.trim() || "";
+    const hasValidationError = validationErrors.length > 0 || !!trimmedErrorMessage;
+    return /* @__PURE__ */ jsxRuntime.jsx(reactComponents.FluentProvider, { theme: reactComponents.webLightTheme, style: { height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsxs(LexicalComposer.LexicalComposer, { initialConfig, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "lexical-rich-editor-root", style: { height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsxs(
+        react.Stack,
+        {
+          style: {
+            zIndex: 1e3,
+            background: "#fff",
+            borderRadius: "2px",
+            width: props.width ?? "100%",
+            height: props.height ?? "100%",
+            margin: props.margin ?? "5px auto",
+            border: `1px solid ${isOverLimit || hasValidationError ? "#c4272c" : "var(--colorNeutralStroke1, #ccced1)"}`,
+            transition: "border-color 0.2s",
+            display: "flex",
+            flexDirection: "column"
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
               {
-                level: props.level ?? "basic" /* Basic */,
-                readOnly: props.readOnly,
-                pageSetup,
-                onPageSetupChange: setPageSetup
+                className: "editor-toolbar-root",
+                style: {
+                  pointerEvents: isReadOnly ? "none" : "auto",
+                  position: "sticky",
+                  opacity: isReadOnly ? 0.85 : 1
+                },
+                children: /* @__PURE__ */ jsxRuntime.jsx(
+                  ToolBarPlugins,
+                  {
+                    level: props.level ?? "basic" /* Basic */,
+                    customToolbar: props.customToolbar,
+                    readOnly: props.readOnly,
+                    pageSetup,
+                    onPageSetupChange: setPageSetup,
+                    maxImageSizeMB: props.maxImageSizeMB,
+                    validationMessages: props.validationMessages,
+                    setIsLinkEditMode
+                  }
+                )
               }
-            )
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsxs(
-          "div",
-          {
-            style: {
-              position: "relative",
-              flexGrow: 1,
-              padding: "15px 0px",
-              overflowY: "scroll",
-              overflowX: "auto",
-              minWidth: 0,
-              background: pageCanvas.widthPx !== void 0 ? "#eef0f2" : void 0
-            },
-            onClickCapture: handleReadOnlyClickCapture,
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx(
-                LexicalRichTextPlugin.RichTextPlugin,
-                {
-                  ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary,
-                  contentEditable: /* @__PURE__ */ jsxRuntime.jsx(
-                    "div",
+            ),
+            /* @__PURE__ */ jsxRuntime.jsxs(
+              "div",
+              {
+                style: {
+                  position: "relative",
+                  flexGrow: 1,
+                  padding: "15px 0px",
+                  overflowY: "scroll",
+                  overflowX: "auto",
+                  minWidth: 0,
+                  background: pageCanvas.widthPx !== void 0 ? "#eef0f2" : void 0
+                },
+                onClickCapture: handleReadOnlyClickCapture,
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    LexicalRichTextPlugin.RichTextPlugin,
                     {
-                      className: "editor",
-                      style: { height: "100%", position: "relative" },
-                      ref: onAnchorRef,
-                      children: /* @__PURE__ */ jsxRuntime.jsx(
-                        LexicalContentEditable.ContentEditable,
+                      ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary,
+                      contentEditable: /* @__PURE__ */ jsxRuntime.jsx(
+                        "div",
                         {
-                          ref: contentEditableDomRef,
-                          className: react.css(EditorStyles.contentEditor),
-                          style: {
-                            paddingTop: props.level !== "none" /* None */ ? 0 : 10,
-                            paddingLeft: pageCanvas.paddingPx,
-                            paddingRight: pageCanvas.paddingPx,
-                            maxWidth: pageCanvas.widthPx,
-                            marginLeft: pageCanvas.widthPx !== void 0 ? "auto" : void 0,
-                            marginRight: pageCanvas.widthPx !== void 0 ? "auto" : void 0,
-                            boxShadow: pageCanvas.widthPx !== void 0 ? "0 0 0 1px rgba(0,0,0,0.08), 0 2px 8px rgba(0,0,0,0.08)" : void 0
-                          },
-                          spellCheck: !resolvedSpellCheck,
-                          autoCorrect: resolvedSpellCheck ? "off" : void 0,
-                          autoCapitalize: resolvedSpellCheck ? "off" : void 0
+                          className: "editor",
+                          style: { height: "100%", position: "relative" },
+                          ref: onAnchorRef,
+                          children: /* @__PURE__ */ jsxRuntime.jsx(
+                            LexicalContentEditable.ContentEditable,
+                            {
+                              ref: contentEditableDomRef,
+                              className: react.css(EditorStyles.contentEditor),
+                              style: {
+                                paddingTop: props.level !== "none" /* None */ ? 0 : 10,
+                                paddingLeft: pageCanvas.paddingPx,
+                                paddingRight: pageCanvas.paddingPx,
+                                maxWidth: pageCanvas.widthPx,
+                                marginLeft: pageCanvas.widthPx !== void 0 ? "auto" : void 0,
+                                marginRight: pageCanvas.widthPx !== void 0 ? "auto" : void 0,
+                                boxShadow: pageCanvas.widthPx !== void 0 ? "0 0 0 1px rgba(0,0,0,0.08), 0 2px 8px rgba(0,0,0,0.08)" : void 0
+                              },
+                              spellCheck: !resolvedSpellCheck,
+                              autoCorrect: resolvedSpellCheck ? "off" : void 0,
+                              autoCapitalize: resolvedSpellCheck ? "off" : void 0
+                            }
+                          )
                         }
-                      )
+                      ),
+                      placeholder: /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { className: react.css(EditorStyles.editorPlaceholder), children: props.placeholder })
                     }
                   ),
-                  placeholder: /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { className: react.css(EditorStyles.editorPlaceholder), children: props.placeholder })
-                }
-              ),
-              props.wordLimit !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(
-                "div",
-                {
-                  style: {
-                    position: "sticky",
-                    bottom: 0,
-                    display: "flex",
-                    justifyContent: "flex-end",
-                    paddingRight: 14,
-                    pointerEvents: "none",
-                    userSelect: "none"
-                  },
-                  children: /* @__PURE__ */ jsxRuntime.jsxs(
-                    "span",
+                  (props.wordLimit !== void 0 || props.maxWords !== void 0 || props.minWords !== void 0 || props.maxChars !== void 0 || props.minChars !== void 0) && /* @__PURE__ */ jsxRuntime.jsxs(
+                    "div",
                     {
                       style: {
-                        fontSize: "11px",
-                        color: isOverLimit ? "#c4272c" : "var(--colorNeutralForeground3, #aaa)",
-                        fontWeight: isOverLimit ? 600 : 400,
-                        transition: "color 0.2s, font-weight 0.2s"
+                        position: "sticky",
+                        bottom: 0,
+                        display: "flex",
+                        justifyContent: "flex-end",
+                        gap: 10,
+                        paddingRight: 14,
+                        pointerEvents: "none",
+                        userSelect: "none"
                       },
                       children: [
-                        wordCount,
-                        " / ",
-                        props.wordLimit,
-                        " words"
+                        (props.wordLimit !== void 0 || props.maxWords !== void 0 || props.minWords !== void 0) && /* @__PURE__ */ jsxRuntime.jsxs(
+                          "span",
+                          {
+                            style: {
+                              fontSize: "11px",
+                              color: hasValidationError ? "#c4272c" : "var(--colorNeutralForeground3, #aaa)",
+                              fontWeight: hasValidationError ? 600 : 400,
+                              transition: "color 0.2s, font-weight 0.2s"
+                            },
+                            children: [
+                              wordCount,
+                              (props.maxWords ?? props.wordLimit) !== void 0 && ` / ${props.maxWords ?? props.wordLimit}`,
+                              props.minWords !== void 0 && props.maxWords === void 0 && props.wordLimit === void 0 && ` (min ${props.minWords})`,
+                              " words"
+                            ]
+                          }
+                        ),
+                        (props.maxChars !== void 0 || props.minChars !== void 0) && /* @__PURE__ */ jsxRuntime.jsxs(
+                          "span",
+                          {
+                            style: {
+                              fontSize: "11px",
+                              color: hasValidationError ? "#c4272c" : "var(--colorNeutralForeground3, #aaa)",
+                              fontWeight: hasValidationError ? 600 : 400,
+                              transition: "color 0.2s, font-weight 0.2s"
+                            },
+                            children: [
+                              metrics.chars,
+                              props.maxChars !== void 0 && ` / ${props.maxChars}`,
+                              props.minChars !== void 0 && props.maxChars === void 0 && ` (min ${props.minChars})`,
+                              " chars"
+                            ]
+                          }
+                        )
                       ]
                     }
                   )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(ReadOnlyPlugin, { readonly: isReadOnly }),
+            /* @__PURE__ */ jsxRuntime.jsx(BrowserSpellCheckPlugin, { enabled: !resolvedSpellCheck }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              FocusEventsPlugin,
+              {
+                onFocus: props.onFocus,
+                onBlur: props.onBlur,
+                setFocused,
+                containerRef
+              }
+            ),
+            props.autoFocus && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(LexicalAutoFocusPlugin.AutoFocusPlugin, {}),
+            /* @__PURE__ */ jsxRuntime.jsx(LexicalHistoryPlugin.HistoryPlugin, {}),
+            /* @__PURE__ */ jsxRuntime.jsx(LexicalListPlugin.ListPlugin, {}),
+            /* @__PURE__ */ jsxRuntime.jsx(LexicalLinkPlugin.LinkPlugin, { validateUrl }),
+            /* @__PURE__ */ jsxRuntime.jsx(LexicalAutoLinkPlugin.AutoLinkPlugin, { matchers: MATCHERS }),
+            /* @__PURE__ */ jsxRuntime.jsx(LexicalTablePlugin.TablePlugin, { hasCellMerge: true, hasCellBackgroundColor: true }),
+            !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(YoutubeDeletePlugin, {}),
+            !isReadOnly && floatingAnchorElem && /* @__PURE__ */ jsxRuntime.jsx(TableActionMenuPlugin, {}),
+            !isReadOnly && floatingAnchorElem && /* @__PURE__ */ jsxRuntime.jsx(TableCellResizerPlugin, { anchorElem: floatingAnchorElem }),
+            !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
+              FloatingLinkEditorPlugin,
+              {
+                anchorElem: floatingAnchorElem,
+                isLinkEditMode,
+                setIsLinkEditMode
+              }
+            ),
+            !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(ImagePlugin_default, {}),
+            !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(InlineImage_default, {}),
+            !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(PageBreakPlugin, {}),
+            !!resolvedQuery && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
+              AutocompletePlugin,
+              {
+                useQuery: resolvedQuery,
+                isReadOnly,
+                onSuggestionShown: props.onSuggestionShown,
+                onSuggestionAccept: props.onSuggestionAccept,
+                idleMs: props.suggestIdleMs ?? 300,
+                minWords: 4,
+                prefixWindow: 300
+              }
+            ),
+            !!resolvedSpellCheck && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
+              SpellCheckPlugin,
+              {
+                useSpellCheck: resolvedSpellCheck,
+                onSpellCheckAccept: props.onSpellCheckAccept,
+                idleMs: props.spellCheckIdleMs ?? 1200,
+                enabled: props.spellCheckEnabled !== false
+              }
+            ),
+            !isReadOnly && props.showFloatingToolbar && /* @__PURE__ */ jsxRuntime.jsx(CharacterStylesPopupPlugin, {}),
+            /* @__PURE__ */ jsxRuntime.jsx(CustomOnChangePlugin, { value: props.value, onChange: props.onChange }),
+            (props.wordLimit !== void 0 || props.required || props.minWords !== void 0 || props.maxWords !== void 0 || props.minChars !== void 0 || props.maxChars !== void 0 || props.noImages || props.maxImages !== void 0 || props.noLinks || props.maxLinks !== void 0 || props.noTables) && /* @__PURE__ */ jsxRuntime.jsx(ContentMetricsPlugin, { onMetricsChange: handleMetrics }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              RefApiPlugin,
+              {
+                forwardedRef: ref,
+                contentEditableDomRef,
+                focusedRef
+              }
+            ),
+            (validationErrors.length > 0 || trimmedErrorMessage) && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { flexShrink: 0, padding: "6px 20px 8px" }, children: [
+              validationErrors.map((err) => /* @__PURE__ */ jsxRuntime.jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    alignItems: "flex-start",
+                    gap: 6,
+                    marginTop: 2,
+                    color: "#c4272c",
+                    fontSize: 12,
+                    lineHeight: "18px"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { style: { fontWeight: 600, flexShrink: 0 }, children: "\u26A0" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { children: err.message })
+                  ]
+                },
+                err.type
+              )),
+              trimmedErrorMessage && /* @__PURE__ */ jsxRuntime.jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    alignItems: "flex-start",
+                    gap: 6,
+                    marginTop: 2,
+                    color: "#c4272c",
+                    fontSize: 12,
+                    lineHeight: "18px"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { style: { fontWeight: 600, flexShrink: 0 }, children: "\u26A0" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { children: trimmedErrorMessage })
+                  ]
                 }
               )
-            ]
-          }
-        ),
-        hasErrors && /* @__PURE__ */ jsxRuntime.jsx(
-          "div",
-          {
-            style: {
-              borderTop: "1px solid #fbd5d5",
-              background: "#fff8f8",
-              padding: "6px 12px 8px",
-              display: "flex",
-              flexDirection: "column",
-              gap: 4
-            },
-            children: allErrors.map((err, i) => /* @__PURE__ */ jsxRuntime.jsxs(
-              "div",
-              {
-                style: { display: "flex", alignItems: "center", gap: 6 },
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsx(
-                    reactIcons.ErrorCircleRegular,
-                    {
-                      style: { fontSize: 14, color: "#c4272c", flexShrink: 0 }
-                    }
-                  ),
-                  /* @__PURE__ */ jsxRuntime.jsx("span", { style: { fontSize: 12, color: "#c4272c" }, children: err })
-                ]
-              },
-              i
-            ))
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx(ReadOnlyPlugin, { readonly: isReadOnly }),
-        /* @__PURE__ */ jsxRuntime.jsx(BrowserSpellCheckPlugin, { enabled: !resolvedSpellCheck }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          FocusEventsPlugin,
-          {
-            onFocus: props.onFocus,
-            onBlur: () => {
-              setTouched(true);
-              props.onBlur?.();
-            },
-            setFocused,
-            containerRef
-          }
-        ),
-        props.autoFocus && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(LexicalAutoFocusPlugin.AutoFocusPlugin, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(LexicalHistoryPlugin.HistoryPlugin, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(LexicalListPlugin.ListPlugin, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(LexicalLinkPlugin.LinkPlugin, { validateUrl }),
-        /* @__PURE__ */ jsxRuntime.jsx(LexicalAutoLinkPlugin.AutoLinkPlugin, { matchers: MATCHERS }),
-        /* @__PURE__ */ jsxRuntime.jsx(LexicalTablePlugin.TablePlugin, { hasCellMerge: true, hasCellBackgroundColor: true }),
-        !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(YoutubeDeletePlugin, {}),
-        !isReadOnly && floatingAnchorElem && /* @__PURE__ */ jsxRuntime.jsx(TableActionMenuPlugin, {}),
-        !isReadOnly && floatingAnchorElem && /* @__PURE__ */ jsxRuntime.jsx(TableCellResizerPlugin, { anchorElem: floatingAnchorElem }),
-        !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
-          FloatingLinkEditorPlugin,
-          {
-            anchorElem: floatingAnchorElem,
-            isLinkEditMode,
-            setIsLinkEditMode
-          }
-        ),
-        !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(ImagePlugin_default, {}),
-        !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(InlineImage_default, {}),
-        !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(PageBreakPlugin, {}),
-        !!resolvedQuery && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
-          AutocompletePlugin,
-          {
-            useQuery: resolvedQuery,
-            isReadOnly,
-            onSuggestionShown: props.onSuggestionShown,
-            onSuggestionAccept: props.onSuggestionAccept,
-            idleMs: props.suggestIdleMs ?? 300,
-            minWords: 4,
-            prefixWindow: 300
-          }
-        ),
-        !!resolvedSpellCheck && !isReadOnly && /* @__PURE__ */ jsxRuntime.jsx(
-          SpellCheckPlugin,
-          {
-            useSpellCheck: resolvedSpellCheck,
-            onSpellCheckAccept: props.onSpellCheckAccept,
-            idleMs: props.spellCheckIdleMs ?? 1200,
-            enabled: props.spellCheckEnabled !== false
-          }
-        ),
-        !isReadOnly && props.showFloatingToolbar && /* @__PURE__ */ jsxRuntime.jsx(CharacterStylesPopupPlugin, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          CustomOnChangePlugin,
-          {
-            value: props.value,
-            onChange: props.onChange
-          }
-        ),
-        (props.wordLimit !== void 0 || props.required || props.minWords !== void 0) && /* @__PURE__ */ jsxRuntime.jsx(WordCountPlugin, { onCountChange: handleWordCount }),
-        (props.maxChars !== void 0 || props.minChars !== void 0) && /* @__PURE__ */ jsxRuntime.jsx(CharCountPlugin, { onCountChange: handleCharCount }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          RefApiPlugin,
-          {
-            forwardedRef: ref,
-            contentEditableDomRef,
-            focusedRef,
-            setRefErrors
-          }
-        )
-      ]
-    }
-  ) }) }) });
-});
+            ] })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsx(EditorReadyPlugin, { onReady: props.onReady })
+    ] }) });
+  }
+);
 
 exports.ContentEditorComponent = ContentEditorComponent;
 exports.ContentEditorLevel = ContentEditorLevel;
+exports.DEFAULT_VALIDATION_MESSAGES = DEFAULT_VALIDATION_MESSAGES;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map