@underverse-ui/underverse 1.0.203 → 1.0.205

package/dist/chunk-MJV7ETJM.js

@@ -0,0 +1,4501 @@
+import {
+  Tooltip,
+  chainEventHandlers,
+  cn,
+  mergeRefs,
+  setRefValue,
+  useSmartTranslations
+} from "./chunk-XJR7E6QB.js";
+
+// src/contexts/UnderverseConfigContext.tsx
+import * as React from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var UnderverseUIConfigContext = React.createContext(null);
+function useUnderverseUIConfig() {
+  return React.useContext(UnderverseUIConfigContext) ?? {};
+}
+function UnderverseConfigProvider({ children, config }) {
+  if (!config) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(UnderverseUIConfigContext.Provider, { value: config, children });
+}
+
+// src/utils/animations.ts
+import { useEffect } from "react";
+var shadcnAnimationStyles = `
+  /* ============================================
+   * DROPDOWN / POPOVER ANIMATIONS
+   * Uses spring-like cubic-bezier for natural feel
+   * ============================================ */
+  
+  /* Native-like Combobox Animation - Mimics browser default select */
+  [data-state="open"][data-combobox-dropdown] {
+    animation: comboboxOpen 150ms cubic-bezier(0.2, 0, 0, 1);
+    transform-origin: top center;
+  }
+
+  [data-state="closed"][data-combobox-dropdown] {
+    animation: comboboxClose 120ms cubic-bezier(0.4, 0, 1, 1);
+    transform-origin: top center;
+  }
+
+  @keyframes comboboxOpen {
+    0% {
+      opacity: 0;
+      transform: translateY(-4px) scaleY(0.9);
+    }
+    100% {
+      opacity: 1;
+      transform: translateY(0) scaleY(1);
+    }
+  }
+
+  @keyframes comboboxClose {
+    0% {
+      opacity: 1;
+      transform: translateY(0) scaleY(1);
+    }
+    100% {
+      opacity: 0;
+      transform: translateY(-4px) scaleY(0.9);
+    }
+  }
+
+  /* Generic dropdown open/close */
+  [data-state="open"] {
+    animation: slideDownAndFade 220ms cubic-bezier(0.16, 1, 0.3, 1);
+  }
+  
+  [data-state="closed"] {
+    animation: slideUpAndFade 180ms cubic-bezier(0.4, 0, 0.2, 1);
+  }
+  
+  @keyframes slideDownAndFade {
+    from {
+      opacity: 0;
+      transform: translateY(-4px) scale(0.98);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0) scale(1);
+    }
+  }
+  
+  @keyframes slideUpAndFade {
+    from {
+      opacity: 1;
+      transform: translateY(0) scale(1);
+    }
+    to {
+      opacity: 0;
+      transform: translateY(-4px) scale(0.98);
+    }
+  }
+  
+  /* ============================================
+   * DROPDOWN ITEMS - Native-like instant appearance
+   * ============================================ */
+
+  /* Fast staggered animation for native feel */
+  .dropdown-item {
+    opacity: 0;
+    animation: itemFadeIn 120ms cubic-bezier(0.2, 0, 0, 1) forwards;
+  }
+
+  @keyframes itemFadeIn {
+    from {
+      opacity: 0;
+      transform: translateX(-4px);
+    }
+    to {
+      opacity: 1;
+      transform: translateX(0);
+    }
+  }
+
+  /* Item stagger delays - minimal for speed */
+  .dropdown-item:nth-child(1) { animation-delay: 0ms; }
+  .dropdown-item:nth-child(2) { animation-delay: 15ms; }
+  .dropdown-item:nth-child(3) { animation-delay: 30ms; }
+  .dropdown-item:nth-child(4) { animation-delay: 45ms; }
+  .dropdown-item:nth-child(5) { animation-delay: 60ms; }
+  .dropdown-item:nth-child(6) { animation-delay: 75ms; }
+  .dropdown-item:nth-child(7) { animation-delay: 90ms; }
+  .dropdown-item:nth-child(8) { animation-delay: 105ms; }
+  .dropdown-item:nth-child(n+9) { animation-delay: 120ms; }
+
+  /* ============================================
+   * DATEPICKER ANIMATIONS
+   * ============================================ */
+
+  .datepicker-day {
+    opacity: 0;
+    animation: dayFadeIn 200ms cubic-bezier(0.16, 1, 0.3, 1) forwards;
+  }
+
+  @keyframes dayFadeIn {
+    from {
+      opacity: 0;
+      transform: scale(0.8);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+
+  /* ============================================
+   * TOOLTIP ANIMATIONS
+   * ============================================ */
+
+  [data-tooltip] {
+    animation: tooltipIn 150ms cubic-bezier(0.16, 1, 0.3, 1);
+  }
+
+  @keyframes tooltipIn {
+    from {
+      opacity: 0;
+      transform: scale(0.95);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+
+  /* ============================================
+   * MODAL / DIALOG ANIMATIONS
+   * ============================================ */
+
+  .modal-content {
+    animation: scaleIn 200ms cubic-bezier(0.34, 1.56, 0.64, 1);
+  }
+  
+  @keyframes scaleIn {
+    from {
+      opacity: 0;
+      transform: scale(0.9);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+  
+  /* Smooth backdrop blur transition */
+  .backdrop-animate {
+    transition: backdrop-filter 200ms ease, background-color 200ms ease;
+  }
+`;
+function ensureAnimationStylesInjected() {
+  if (typeof document !== "undefined") {
+    const styleId = "shadcn-animations";
+    if (!document.getElementById(styleId)) {
+      const styleElement = document.createElement("style");
+      styleElement.id = styleId;
+      styleElement.textContent = shadcnAnimationStyles;
+      document.head.appendChild(styleElement);
+    }
+  }
+}
+function useShadCNAnimations() {
+  useEffect(() => {
+    ensureAnimationStylesInjected();
+  }, []);
+}
+function injectAnimationStyles() {
+  ensureAnimationStylesInjected();
+}
+function getAnimationStyles() {
+  return shadcnAnimationStyles;
+}
+
+// src/components/Popover.tsx
+import * as React2 from "react";
+import { createPortal } from "react-dom";
+
+// src/utils/radius.ts
+var STANDARD_BORDER_MODES = ["none", "sm", "md", "lg", "xl", "2xl", "3xl", "full"];
+var CUSTOM_BORDER_MAP = {
+  daewoo: "rounded",
+  infiniq: "rounded-full"
+};
+var BORDER_MODE_DOCS_TYPE = `"${STANDARD_BORDER_MODES.join('" | "')}" | "${Object.keys(CUSTOM_BORDER_MAP).join('" | "')}"`;
+function getBorderRadiusClass(borderMode = "full") {
+  if (!borderMode) return "rounded-full";
+  if (borderMode in CUSTOM_BORDER_MAP) {
+    return CUSTOM_BORDER_MAP[borderMode];
+  }
+  if (STANDARD_BORDER_MODES.includes(borderMode)) {
+    return `rounded-${borderMode}`;
+  }
+  return borderMode;
+}
+function getPanelBorderRadiusClass(borderMode = "lg") {
+  const resolved = borderMode ?? "lg";
+  if (resolved === "full" || resolved === "infiniq") {
+    return "rounded-2xl";
+  }
+  return getBorderRadiusClass(resolved);
+}
+
+// src/components/Popover.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function getTransformOrigin(side, align) {
+  if (side === "top") return `${align === "end" ? "right" : "left"} bottom`;
+  if (side === "bottom") return `${align === "end" ? "right" : "left"} top`;
+  if (side === "left") return "right top";
+  return "left top";
+}
+function normalizePlacement(placement) {
+  switch (placement) {
+    case "top":
+      return { side: "top", align: "start" };
+    case "bottom":
+      return { side: "bottom", align: "start" };
+    case "left":
+      return { side: "left", align: "start" };
+    case "right":
+      return { side: "right", align: "start" };
+    default: {
+      const [side, align] = placement.split("-");
+      return { side, align };
+    }
+  }
+}
+var clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+function overflowAmount(left, width, viewportWidth, padding) {
+  const min = padding;
+  const max = viewportWidth - padding;
+  const overflowLeft = Math.max(0, min - left);
+  const overflowRight = Math.max(0, left + width - max);
+  return overflowLeft + overflowRight;
+}
+function computePopoverPosition(args) {
+  const { triggerRect, contentSize, placement, offset, padding, viewport } = args;
+  let { side, align } = normalizePlacement(placement);
+  if (side === "bottom") {
+    const bottomTop = triggerRect.bottom + offset;
+    const overflowsBottom = bottomTop + contentSize.height > viewport.height - padding;
+    const topTop = triggerRect.top - offset - contentSize.height;
+    const fitsTop = topTop >= padding;
+    if (overflowsBottom && fitsTop) side = "top";
+  } else if (side === "top") {
+    const topTop = triggerRect.top - offset - contentSize.height;
+    const overflowsTop = topTop < padding;
+    const bottomTop = triggerRect.bottom + offset;
+    const fitsBottom = bottomTop + contentSize.height <= viewport.height - padding;
+    if (overflowsTop && fitsBottom) side = "bottom";
+  } else if (side === "right") {
+    const rightLeft = triggerRect.right + offset;
+    const overflowsRight = rightLeft + contentSize.width > viewport.width - padding;
+    const leftLeft = triggerRect.left - offset - contentSize.width;
+    const fitsLeft = leftLeft >= padding;
+    if (overflowsRight && fitsLeft) side = "left";
+  } else if (side === "left") {
+    const leftLeft = triggerRect.left - offset - contentSize.width;
+    const overflowsLeft = leftLeft < padding;
+    const rightLeft = triggerRect.right + offset;
+    const fitsRight = rightLeft + contentSize.width <= viewport.width - padding;
+    if (overflowsLeft && fitsRight) side = "right";
+  }
+  let top = 0;
+  let left = 0;
+  if (side === "top" || side === "bottom") {
+    const leftStart = triggerRect.left;
+    const leftEnd = triggerRect.right - contentSize.width;
+    const startOverflow = overflowAmount(leftStart, contentSize.width, viewport.width, padding);
+    const endOverflow = overflowAmount(leftEnd, contentSize.width, viewport.width, padding);
+    if (align === "start" && startOverflow > 0 && endOverflow < startOverflow) align = "end";
+    if (align === "end" && endOverflow > 0 && startOverflow < endOverflow) align = "start";
+    left = align === "end" ? leftEnd : leftStart;
+    top = side === "top" ? triggerRect.top - offset - contentSize.height : triggerRect.bottom + offset;
+    left = clamp(left, padding, viewport.width - contentSize.width - padding);
+    top = clamp(top, padding, viewport.height - contentSize.height - padding);
+    return { top, left, side, align };
+  }
+  top = triggerRect.top;
+  left = side === "left" ? triggerRect.left - offset - contentSize.width : triggerRect.right + offset;
+  left = clamp(left, padding, viewport.width - contentSize.width - padding);
+  top = clamp(top, padding, viewport.height - contentSize.height - padding);
+  return { top, left, side, align };
+}
+var Popover = ({
+  trigger,
+  children,
+  className,
+  contentClassName,
+  contentProps,
+  contentScrollable = false,
+  placement = "bottom",
+  modal = false,
+  disabled = false,
+  open,
+  onOpenChange,
+  matchTriggerWidth = false,
+  contentWidth,
+  borderMode
+}) => {
+  const isControlled = open !== void 0;
+  const [internalOpen, setInternalOpen] = React2.useState(false);
+  const triggerRef = React2.useRef(null);
+  const positionerRef = React2.useRef(null);
+  const panelRef = React2.useRef(null);
+  const lastAppliedRef = React2.useRef(null);
+  useShadCNAnimations();
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.popover?.borderMode ?? globalConfig.borderMode;
+  const isOpen = isControlled ? open : internalOpen;
+  const setIsOpen = React2.useCallback(
+    (next) => {
+      if (!isControlled) setInternalOpen(next);
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const offset = 4;
+  const padding = 8;
+  const triggerSelector = React2.useId();
+  const initialPlacement = React2.useMemo(() => normalizePlacement(placement), [placement]);
+  React2.useLayoutEffect(() => {
+    if (typeof document === "undefined") return;
+    const triggerEl = document.querySelector(`[data-underverse-popover-trigger="${triggerSelector}"]`);
+    if (triggerEl) {
+      triggerRef.current = triggerEl;
+    }
+  }, [triggerSelector, trigger]);
+  const updatePosition = React2.useCallback(() => {
+    const triggerEl = triggerRef.current;
+    const positionerEl = positionerRef.current;
+    const panelEl = panelRef.current;
+    if (!triggerEl || !positionerEl || !panelEl) return;
+    const triggerRect = triggerEl.getBoundingClientRect();
+    const widthWanted = matchTriggerWidth ? triggerRect.width : contentWidth;
+    const widthPx = widthWanted == null ? void 0 : Math.max(0, Math.round(widthWanted));
+    if (widthPx == null) {
+      if (positionerEl.style.width) positionerEl.style.width = "";
+    } else if (positionerEl.style.width !== `${widthPx}px`) {
+      positionerEl.style.width = `${widthPx}px`;
+    }
+    const prevApplied = lastAppliedRef.current;
+    const measuredWidth = positionerEl.offsetWidth;
+    const measuredHeight = positionerEl.offsetHeight;
+    const contentRect = positionerEl.getBoundingClientRect();
+    const contentBoxWidth = measuredWidth || contentRect.width;
+    const contentBoxHeight = measuredHeight || contentRect.height;
+    const next = computePopoverPosition({
+      triggerRect,
+      contentSize: { width: contentBoxWidth, height: contentBoxHeight },
+      placement,
+      offset,
+      padding,
+      viewport: { width: window.innerWidth, height: window.innerHeight }
+    });
+    const top = Math.round(next.top);
+    const left = Math.round(next.left);
+    const applied = prevApplied && Math.abs(prevApplied.top - top) < 0.5 && Math.abs(prevApplied.left - left) < 0.5 && prevApplied.side === next.side && prevApplied.align === next.align && prevApplied.width === widthPx;
+    if (applied) return;
+    lastAppliedRef.current = { top, left, side: next.side, align: next.align, width: widthPx };
+    positionerEl.style.transform = `translate3d(${left}px, ${top}px, 0)`;
+    panelEl.style.transformOrigin = getTransformOrigin(next.side, next.align);
+    if (positionerEl.style.visibility !== "visible") positionerEl.style.visibility = "visible";
+    if (positionerEl.style.pointerEvents !== "auto") positionerEl.style.pointerEvents = "auto";
+  }, [placement, matchTriggerWidth, contentWidth]);
+  React2.useLayoutEffect(() => {
+    if (!isOpen) return;
+    updatePosition();
+    let raf1 = 0;
+    let raf2 = 0;
+    raf1 = window.requestAnimationFrame(() => {
+      updatePosition();
+      raf2 = window.requestAnimationFrame(() => updatePosition());
+    });
+    return () => {
+      cancelAnimationFrame(raf1);
+      cancelAnimationFrame(raf2);
+    };
+  }, [isOpen, updatePosition]);
+  React2.useEffect(() => {
+    if (!isOpen) return;
+    let raf = 0;
+    const tick = () => {
+      updatePosition();
+      raf = window.requestAnimationFrame(tick);
+    };
+    raf = window.requestAnimationFrame(tick);
+    return () => window.cancelAnimationFrame(raf);
+  }, [isOpen, updatePosition]);
+  React2.useEffect(() => {
+    if (!isOpen) return;
+    let raf = 0;
+    const handler = () => {
+      cancelAnimationFrame(raf);
+      raf = window.requestAnimationFrame(() => updatePosition());
+    };
+    handler();
+    window.addEventListener("resize", handler);
+    window.addEventListener("scroll", handler, true);
+    document.addEventListener("scroll", handler, true);
+    return () => {
+      cancelAnimationFrame(raf);
+      window.removeEventListener("resize", handler);
+      window.removeEventListener("scroll", handler, true);
+      document.removeEventListener("scroll", handler, true);
+    };
+  }, [isOpen, updatePosition]);
+  React2.useEffect(() => {
+    if (!isOpen) return;
+    if (typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => updatePosition());
+    if (positionerRef.current) ro.observe(positionerRef.current);
+    if (triggerRef.current) ro.observe(triggerRef.current);
+    return () => ro.disconnect();
+  }, [isOpen, updatePosition]);
+  React2.useLayoutEffect(() => {
+    if (!isOpen) {
+      lastAppliedRef.current = null;
+      return;
+    }
+  }, [isOpen]);
+  React2.useEffect(() => {
+    if (!isOpen) return;
+    const handleClickOutside = (event) => {
+      const target = event.target;
+      const triggerEl = triggerRef.current;
+      const popoverEl = positionerRef.current;
+      if (!triggerEl || !popoverEl) return;
+      if (triggerEl.contains(target)) return;
+      if (popoverEl.contains(target)) return;
+      if (target instanceof Element && target.closest("[data-popover]")) return;
+      setIsOpen(false);
+    };
+    const handleEscape = (event) => {
+      if (event.key === "Escape") {
+        setIsOpen(false);
+      }
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("mousedown", handleClickOutside);
+      document.addEventListener("keydown", handleEscape);
+      return () => {
+        document.removeEventListener("mousedown", handleClickOutside);
+        document.removeEventListener("keydown", handleEscape);
+      };
+    }
+  }, [isOpen, setIsOpen]);
+  const handleTriggerClick = () => {
+    if (!disabled) {
+      setIsOpen(!isOpen);
+    }
+  };
+  const popoverContent = isOpen && typeof window !== "undefined" ? createPortal(
+    /* @__PURE__ */ jsx2(
+      "div",
+      {
+        ref: positionerRef,
+        "data-popover": true,
+        style: {
+          position: "fixed",
+          top: 0,
+          left: 0,
+          transform: "translate3d(0, 0, 0)",
+          zIndex: 99999,
+          visibility: "hidden",
+          pointerEvents: "none",
+          willChange: "transform"
+        },
+        className: "z-[99999]",
+        children: /* @__PURE__ */ jsx2(
+          "div",
+          {
+            ref: panelRef,
+            "data-state": "open",
+            role: modal ? "dialog" : void 0,
+            "aria-modal": modal || void 0,
+            style: {
+              transformOrigin: getTransformOrigin(initialPlacement.side, initialPlacement.align)
+            },
+            className: cn(
+              // shadcn-like enter animation
+              "data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95",
+              className
+            ),
+            children: /* @__PURE__ */ jsx2(
+              "div",
+              {
+                ...contentProps,
+                className: cn(
+                  resolvedBorderMode ? getPanelBorderRadiusClass(resolvedBorderMode) : "rounded-2xl md:rounded-3xl",
+                  "border bg-popover text-popover-foreground shadow-md",
+                  "backdrop-blur-sm bg-popover/95 border-border/60 p-4",
+                  contentProps?.className,
+                  contentClassName
+                ),
+                tabIndex: contentProps?.tabIndex ?? -1,
+                children
+              }
+            )
+          }
+        )
+      }
+    ),
+    document.body
+  ) : null;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    (() => {
+      const triggerProps = trigger.props;
+      const childRef = triggerProps.ref;
+      return React2.cloneElement(trigger, {
+        ...triggerProps,
+        ref: mergeRefs(childRef, (node) => {
+          triggerRef.current = node;
+        }),
+        "data-underverse-popover-trigger": triggerSelector,
+        onClick: chainEventHandlers(
+          (e) => {
+            triggerRef.current = e.currentTarget;
+            e.preventDefault();
+            e.stopPropagation();
+            handleTriggerClick();
+          },
+          triggerProps.onClick
+        ),
+        onFocus: chainEventHandlers(
+          (e) => {
+            triggerRef.current = e.currentTarget;
+          },
+          triggerProps.onFocus
+        ),
+        "aria-expanded": isOpen,
+        "aria-haspopup": triggerProps["aria-haspopup"] ?? "dialog"
+      });
+    })(),
+    popoverContent
+  ] });
+};
+
+// src/components/DropdownMenu.tsx
+import React3, { useState as useState2 } from "react";
+import { ChevronRight } from "lucide-react";
+
+// src/constants/form-control-size.ts
+var formControlSizeStyles = {
+  sm: {
+    control: "h-8 px-3 text-sm leading-none md:h-7 md:text-xs",
+    compactControl: "h-8 px-2.5 text-sm leading-none md:h-7 md:text-xs",
+    input: "h-8 px-3 text-sm leading-none md:h-7 md:text-xs",
+    label: "text-xs",
+    icon: "h-4 w-4 md:h-3.5 md:w-3.5",
+    iconButton: "h-7 w-7 md:h-6 md:w-6",
+    tag: "h-5 max-w-24 px-2 text-[10px] leading-none"
+  },
+  md: {
+    control: "h-10 px-3 text-sm leading-none",
+    compactControl: "h-10 px-3 text-sm leading-none",
+    input: "h-10 px-4 text-sm leading-none",
+    label: "text-sm",
+    icon: "h-4 w-4",
+    iconButton: "h-8 w-8",
+    tag: "h-6 max-w-28 px-2 text-xs leading-none"
+  },
+  lg: {
+    control: "h-12 px-4 text-base leading-none",
+    compactControl: "h-12 px-4 text-base leading-none",
+    input: "h-12 px-5 text-base leading-none",
+    label: "text-base",
+    icon: "h-5 w-5",
+    iconButton: "h-10 w-10",
+    tag: "h-7 max-w-32 px-2.5 text-sm leading-none"
+  }
+};
+var formControlFixedClass = "min-h-0 overflow-hidden";
+var formControlValueClass = "max-h-full min-w-0 flex-1 truncate whitespace-nowrap";
+
+// src/components/DropdownMenu.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var DropdownMenuContext = React3.createContext(null);
+function useDropdownMenuClose() {
+  return React3.useContext(DropdownMenuContext)?.closeMenu ?? (() => {
+  });
+}
+function useResettingIndex(resetToken) {
+  const [state, setState] = React3.useState({ resetToken, index: -1 });
+  const activeIndex = Object.is(state.resetToken, resetToken) ? state.index : -1;
+  const setActiveIndex = React3.useCallback((nextIndex) => {
+    setState((prev) => {
+      const prevIndex = Object.is(prev.resetToken, resetToken) ? prev.index : -1;
+      return {
+        resetToken,
+        index: typeof nextIndex === "function" ? nextIndex(prevIndex) : nextIndex
+      };
+    });
+  }, [resetToken]);
+  return [activeIndex, setActiveIndex];
+}
+var DropdownMenu = ({
+  trigger,
+  children,
+  className,
+  contentClassName,
+  placement = "bottom-start",
+  closeOnSelect = true,
+  disabled = false,
+  isOpen,
+  onOpenChange,
+  openOnHover = false,
+  hoverCloseDelay = 120,
+  items,
+  borderMode
+}) => {
+  const [internalOpen, setInternalOpen] = useState2(false);
+  const open = isOpen !== void 0 ? isOpen : internalOpen;
+  const setOpen = React3.useCallback(
+    (nextOpen) => {
+      if (isOpen === void 0) {
+        setInternalOpen(nextOpen);
+      }
+      onOpenChange?.(nextOpen);
+    },
+    [isOpen, onOpenChange]
+  );
+  const triggerRef = React3.useRef(null);
+  const menuRef = React3.useRef(null);
+  const itemsRef = React3.useRef([]);
+  const [activeIndex, setActiveIndex] = useResettingIndex(open);
+  const parentMenu = React3.useContext(DropdownMenuContext);
+  const hoverCloseTimeoutRef = React3.useRef(null);
+  const cancelHoverClose = React3.useCallback(() => {
+    if (hoverCloseTimeoutRef.current === null) return;
+    clearTimeout(hoverCloseTimeoutRef.current);
+    hoverCloseTimeoutRef.current = null;
+  }, []);
+  const scheduleHoverClose = React3.useCallback(() => {
+    if (!openOnHover) return;
+    cancelHoverClose();
+    hoverCloseTimeoutRef.current = setTimeout(() => {
+      hoverCloseTimeoutRef.current = null;
+      setOpen(false);
+    }, hoverCloseDelay);
+  }, [cancelHoverClose, hoverCloseDelay, openOnHover, setOpen]);
+  React3.useEffect(() => () => cancelHoverClose(), [cancelHoverClose]);
+  const closeMenu = React3.useCallback(() => {
+    cancelHoverClose();
+    setOpen(false);
+    parentMenu?.closeMenu();
+  }, [cancelHoverClose, parentMenu, setOpen]);
+  const getEnabledMenuItems = React3.useCallback(() => {
+    const menuEl = menuRef.current;
+    if (!menuEl) return [];
+    return Array.from(menuEl.querySelectorAll("[data-dropdown-menu-item]")).filter((el) => !el.disabled);
+  }, []);
+  const focusMenuItem = React3.useCallback((index) => {
+    const enabled = getEnabledMenuItems();
+    const item = enabled[index];
+    if (!item) return;
+    setActiveIndex(index);
+    item.focus();
+    item.scrollIntoView({ block: "nearest" });
+  }, [getEnabledMenuItems, setActiveIndex]);
+  useShadCNAnimations();
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
+  React3.useEffect(() => {
+    if (!open) return;
+    const handleKeyNav = (e) => {
+      const active = document.activeElement;
+      const triggerEl = triggerRef.current;
+      const menuEl = menuRef.current;
+      if (!active || !triggerEl || !menuEl) return;
+      const isInMenu = menuEl.contains(active);
+      const isOnTrigger = triggerEl.contains(active);
+      const enabled = getEnabledMenuItems();
+      if (enabled.length === 0) return;
+      const currentIndex = enabled.findIndex((el) => el === active);
+      const baseIndex = currentIndex >= 0 ? currentIndex : activeIndex;
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        const next = (baseIndex + 1 + enabled.length) % enabled.length;
+        focusMenuItem(next);
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        const prev = (baseIndex - 1 + enabled.length) % enabled.length;
+        focusMenuItem(prev);
+      } else if (e.key === "Home") {
+        e.preventDefault();
+        focusMenuItem(0);
+      } else if (e.key === "End") {
+        e.preventDefault();
+        focusMenuItem(enabled.length - 1);
+      } else if (e.key === "Escape" && (isInMenu || isOnTrigger)) {
+        e.preventDefault();
+        closeMenu();
+      }
+    };
+    document.addEventListener("keydown", handleKeyNav, true);
+    return () => {
+      document.removeEventListener("keydown", handleKeyNav, true);
+    };
+  }, [open, activeIndex, closeMenu, focusMenuItem, getEnabledMenuItems]);
+  const menuContext = React3.useMemo(
+    () => ({
+      closeMenu,
+      closeOnSelect,
+      cancelHoverClose,
+      scheduleHoverClose
+    }),
+    [cancelHoverClose, closeMenu, closeOnSelect, scheduleHoverClose]
+  );
+  const handleItemClick = (itemOnClick) => {
+    itemOnClick();
+    if (closeOnSelect) {
+      closeMenu();
+    }
+  };
+  const menuBody = /* @__PURE__ */ jsx3(DropdownMenuContext.Provider, { value: menuContext, children: /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: menuRef,
+      "data-dropdown-menu": true,
+      "data-state": open ? "open" : "closed",
+      role: "menu",
+      className: cn("min-w-40", className),
+      onMouseEnter: openOnHover ? () => {
+        cancelHoverClose();
+        parentMenu?.cancelHoverClose();
+      } : void 0,
+      onMouseLeave: openOnHover ? () => {
+        scheduleHoverClose();
+        parentMenu?.scheduleHoverClose();
+      } : void 0,
+      children: items ? items.map((item, index) => {
+        const IconComponent = item.icon;
+        return /* @__PURE__ */ jsxs2(
+          "button",
+          {
+            ref: (el) => {
+              if (el) itemsRef.current[index] = el;
+            },
+            onClick: () => handleItemClick(item.onClick),
+            disabled: item.disabled,
+            role: "menuitem",
+            "data-dropdown-menu-item": "",
+            tabIndex: -1,
+            style: {
+              animationDelay: open ? `${Math.min(index * 20, 200)}ms` : "0ms"
+            },
+            className: cn(
+              "dropdown-item flex w-full items-center gap-2 px-2.5 py-1.5 text-sm",
+              resolvedBorderMode ? getBorderRadiusClass(resolvedBorderMode) : "rounded-lg",
+              "outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background",
+              "hover:bg-accent hover:text-accent-foreground",
+              "focus:bg-accent focus:text-accent-foreground",
+              "disabled:opacity-50 disabled:cursor-not-allowed",
+              item.destructive && "text-destructive hover:bg-destructive/10 focus:bg-destructive/10"
+            ),
+            children: [
+              IconComponent && /* @__PURE__ */ jsx3(IconComponent, { className: "h-4 w-4" }),
+              item.label
+            ]
+          },
+          index
+        );
+      }) : children
+    }
+  ) });
+  const triggerProps = trigger.props;
+  const {
+    ref: childRef,
+    onKeyDown: triggerOnKeyDown,
+    onClick: triggerOnClick,
+    onMouseEnter: triggerOnMouseEnter,
+    onMouseLeave: triggerOnMouseLeave
+  } = triggerProps;
+  const setTriggerNode = React3.useCallback((node) => {
+    setRefValue(childRef, node);
+    triggerRef.current = node;
+  }, [childRef]);
+  const handleTriggerKeyDown = React3.useCallback((event) => {
+    if (!disabled) {
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        setOpen(true);
+        requestAnimationFrame(() => focusMenuItem(0));
+      } else if (event.key === "ArrowUp") {
+        event.preventDefault();
+        setOpen(true);
+        requestAnimationFrame(() => {
+          const enabled = getEnabledMenuItems();
+          focusMenuItem(enabled.length - 1);
+        });
+      } else if (event.key === "Escape") {
+        event.preventDefault();
+        setOpen(false);
+      }
+    }
+    triggerOnKeyDown?.(event);
+  }, [disabled, focusMenuItem, getEnabledMenuItems, setOpen, triggerOnKeyDown]);
+  const handleTriggerClick = React3.useCallback((event) => {
+    if (openOnHover && !disabled) {
+      cancelHoverClose();
+      setOpen(true);
+    }
+    triggerOnClick?.(event);
+  }, [cancelHoverClose, disabled, openOnHover, setOpen, triggerOnClick]);
+  const handleTriggerMouseEnter = React3.useCallback((event) => {
+    if (openOnHover && !disabled) {
+      cancelHoverClose();
+      parentMenu?.cancelHoverClose();
+      setOpen(true);
+    }
+    triggerOnMouseEnter?.(event);
+  }, [cancelHoverClose, disabled, openOnHover, parentMenu, setOpen, triggerOnMouseEnter]);
+  const handleTriggerMouseLeave = React3.useCallback((event) => {
+    scheduleHoverClose();
+    triggerOnMouseLeave?.(event);
+  }, [scheduleHoverClose, triggerOnMouseLeave]);
+  const enhancedTrigger = React3.cloneElement(trigger, {
+    ...triggerProps,
+    ref: setTriggerNode,
+    "aria-haspopup": "menu",
+    "aria-expanded": open,
+    onKeyDown: handleTriggerKeyDown,
+    onClick: handleTriggerClick,
+    onMouseEnter: handleTriggerMouseEnter,
+    onMouseLeave: handleTriggerMouseLeave
+  });
+  return /* @__PURE__ */ jsx3(
+    Popover,
+    {
+      open,
+      onOpenChange: setOpen,
+      trigger: enhancedTrigger,
+      placement,
+      disabled,
+      borderMode: resolvedBorderMode,
+      contentClassName: cn("p-1", contentClassName),
+      children: menuBody
+    }
+  );
+};
+var DropdownMenuItem = ({
+  children,
+  label,
+  description,
+  icon: Icon,
+  onClick,
+  disabled,
+  destructive,
+  active,
+  shortcut,
+  className,
+  closeOnSelect,
+  borderMode
+}) => {
+  const menu = React3.useContext(DropdownMenuContext);
+  const shouldCloseOnSelect = closeOnSelect ?? menu?.closeOnSelect ?? false;
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
+  return /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      onClick: () => {
+        onClick?.();
+        if (shouldCloseOnSelect) {
+          menu?.closeMenu();
+        }
+      },
+      disabled,
+      onMouseDown: (e) => e.preventDefault(),
+      "data-dropdown-menu-item": "",
+      tabIndex: -1,
+      className: cn(
+        "flex w-full items-center gap-2 px-3 py-2 text-sm transition-colors group cursor-pointer",
+        resolvedBorderMode ? getBorderRadiusClass(resolvedBorderMode) : "rounded-lg",
+        "hover:bg-accent hover:text-accent-foreground",
+        "focus:bg-accent focus:text-accent-foreground focus:outline-none",
+        "disabled:opacity-50 disabled:cursor-not-allowed",
+        destructive && "text-destructive hover:bg-destructive/10 focus:bg-destructive/10",
+        active && "bg-primary/10 text-primary",
+        className
+      ),
+      children: [
+        Icon && /* @__PURE__ */ jsx3(Icon, { className: cn("w-4 h-4 shrink-0", active ? "text-primary" : "opacity-60 group-hover:opacity-100") }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex-1 text-left", children: [
+          label && /* @__PURE__ */ jsx3("div", { className: cn("font-medium", description && "leading-tight"), children: label }),
+          description && /* @__PURE__ */ jsx3("div", { className: "text-xs text-muted-foreground", children: description }),
+          children
+        ] }),
+        shortcut && /* @__PURE__ */ jsx3("span", { className: "ml-2 text-xs text-muted-foreground opacity-60", children: shortcut }),
+        active && /* @__PURE__ */ jsx3("svg", { className: "w-4 h-4 text-primary shrink-0", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: /* @__PURE__ */ jsx3("polyline", { points: "20 6 9 17 4 12" }) })
+      ]
+    }
+  );
+};
+var DropdownMenuSeparator = ({ className }) => /* @__PURE__ */ jsx3("div", { className: cn("h-px bg-border my-1", className) });
+var DropdownMenuSub = ({ label, icon: Icon, disabled, borderMode, children }) => {
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
+  return /* @__PURE__ */ jsx3(
+    DropdownMenu,
+    {
+      trigger: /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onMouseDown: (e) => e.preventDefault(),
+          className: cn(
+            "flex w-full items-center gap-2 px-3 py-2 text-sm transition-colors cursor-pointer",
+            resolvedBorderMode ? getBorderRadiusClass(resolvedBorderMode) : "rounded-lg",
+            "hover:bg-accent hover:text-accent-foreground",
+            "focus:bg-accent focus:text-accent-foreground focus:outline-none",
+            "disabled:opacity-50 disabled:cursor-not-allowed"
+          ),
+          children: [
+            Icon && /* @__PURE__ */ jsx3(Icon, { className: "w-4 h-4 shrink-0 opacity-60" }),
+            /* @__PURE__ */ jsx3("span", { className: "flex-1 text-left", children: label }),
+            /* @__PURE__ */ jsx3(ChevronRight, { className: "w-3 h-3 opacity-50" })
+          ]
+        }
+      ),
+      placement: "right",
+      openOnHover: true,
+      children
+    }
+  );
+};
+var SelectDropdown = ({ options, value, onChange, placeholder = "Select...", className, borderMode, size = "md" }) => {
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
+  return /* @__PURE__ */ jsx3(
+    DropdownMenu,
+    {
+      trigger: /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          className: cn(
+            "inline-flex items-center justify-between gap-2 border bg-background border-border/60",
+            resolvedBorderMode ? getBorderRadiusClass(resolvedBorderMode) : "rounded-2xl",
+            formControlFixedClass,
+            formControlSizeStyles[size].control,
+            "hover:bg-accent/50",
+            "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background",
+            className
+          ),
+          children: [
+            /* @__PURE__ */ jsx3("span", { className: cn(formControlValueClass, "max-w-64 text-foreground/90"), children: value || placeholder }),
+            /* @__PURE__ */ jsx3("svg", { width: "16", height: "16", viewBox: "0 0 20 20", fill: "none", className: "shrink-0 opacity-70", children: /* @__PURE__ */ jsx3("path", { d: "M6 8l4 4 4-4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+          ]
+        }
+      ),
+      items: options.map((option) => ({
+        label: option,
+        onClick: () => onChange(option)
+      })),
+      borderMode: resolvedBorderMode
+    }
+  );
+};
+var DropdownMenu_default = DropdownMenu;
+
+// src/components/UEditor/url-safety.ts
+var LINK_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+var IMAGE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var FILE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "blob:"]);
+function normalizeUrlInput(raw) {
+  return raw.trim().replace(/[\u0000-\u001F\u007F\s]+/g, "");
+}
+function isProtocolRelativeUrl(value) {
+  return value.startsWith("//");
+}
+function isRelativeUrl(value) {
+  return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("#");
+}
+function isValidIpv4Hostname(hostname) {
+  const parts = hostname.split(".");
+  return parts.length === 4 && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+function isValidWebHostname(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (normalized === "localhost" || isValidIpv4Hostname(normalized)) return true;
+  if (normalized.startsWith("[") && normalized.endsWith("]") && normalized.includes(":")) return true;
+  const labels = normalized.split(".");
+  if (labels.length < 2) return false;
+  const validLabel = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)$/;
+  return labels.every((label) => validLabel.test(label)) && /[a-z]/.test(labels.at(-1) ?? "");
+}
+function isValidLinkUrl(parsed) {
+  if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+    return isValidWebHostname(parsed.hostname);
+  }
+  if (parsed.protocol === "mailto:") {
+    return /^[^@]+@[^@]+\.[^@]+$/.test(decodeURIComponent(parsed.pathname));
+  }
+  if (parsed.protocol === "tel:") {
+    const number = decodeURIComponent(parsed.pathname);
+    return /^\+?[\d().-]+$/.test(number) && (number.match(/\d/g)?.length ?? 0) >= 3;
+  }
+  return false;
+}
+function isDataImageUrl(value) {
+  return /^data:image\/(?:png|jpe?g|gif|webp|svg\+xml|bmp|x-icon|avif);base64,/i.test(value);
+}
+function isDataFileUrl(value) {
+  return /^data:[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*(?:;[a-z0-9!#$&^_.+-]+=[^;,]*)*;base64,[a-z0-9+/]*={0,2}$/i.test(value);
+}
+function isSafeUEditorUrl(raw, kind) {
+  const value = normalizeUrlInput(raw);
+  if (!value) return false;
+  if (kind === "image" && isDataImageUrl(value)) return true;
+  if (kind === "file" && isDataFileUrl(value)) return true;
+  if (isProtocolRelativeUrl(value)) return false;
+  if (isRelativeUrl(value)) return true;
+  try {
+    const parsed = new URL(value);
+    if (kind === "image") return IMAGE_PROTOCOLS.has(parsed.protocol);
+    if (kind === "file") return FILE_PROTOCOLS.has(parsed.protocol);
+    return LINK_PROTOCOLS.has(parsed.protocol) && isValidLinkUrl(parsed);
+  } catch {
+    return false;
+  }
+}
+function sanitizeUEditorUrl(raw, kind) {
+  const value = raw.trim();
+  if (!value) return "";
+  if (isSafeUEditorUrl(value, kind)) return normalizeUrlInput(value);
+  if (kind === "link" && !isProtocolRelativeUrl(value) && !/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) {
+    const withProtocol = `https://${value}`;
+    return isSafeUEditorUrl(withProtocol, kind) ? withProtocol : "";
+  }
+  return "";
+}
+
+// src/components/UEditor/clipboard-images.ts
+import { Extension } from "@tiptap/core";
+import { Plugin } from "@tiptap/pm/state";
+
+// src/components/UEditor/clipboard-tables.ts
+var DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR = "#ffffff";
+var DEFAULT_HTML_TABLE_TEXT_COLOR = "#000000";
+function getClipboardData(dataTransfer, type) {
+  try {
+    return dataTransfer.getData(type) ?? "";
+  } catch {
+    return "";
+  }
+}
+function extractClipboardHtmlFragment(html) {
+  const startMarker = "<!--StartFragment-->";
+  const endMarker = "<!--EndFragment-->";
+  const start = html.indexOf(startMarker);
+  const end = html.indexOf(endMarker);
+  if (start >= 0 && end > start) {
+    return html.slice(start + startMarker.length, end);
+  }
+  return html;
+}
+function normalizeClipboardCellText(value) {
+  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u00a0/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n[ \t]+/g, "\n").replace(/\n+$/g, "").replace(/^\n+/g, "").trim();
+}
+function parseStyleDeclarations(styleText) {
+  const declarations = /* @__PURE__ */ new Map();
+  if (!styleText) return declarations;
+  for (const declaration of styleText.split(";")) {
+    const separatorIndex = declaration.indexOf(":");
+    if (separatorIndex <= 0) continue;
+    const property = declaration.slice(0, separatorIndex).trim().toLowerCase();
+    const value = cleanStyleValue(declaration.slice(separatorIndex + 1));
+    if (!property || !value) continue;
+    declarations.set(property, value);
+  }
+  return declarations;
+}
+function mergeStyleDeclarations(...sources) {
+  const declarations = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [property, value] of source.entries()) {
+      declarations.set(property, value);
+    }
+  }
+  return declarations;
+}
+function extractCssClassNames(selectorText) {
+  const classNames = /* @__PURE__ */ new Set();
+  const classNamePattern = /\.([_a-zA-Z-][\w-]*)/g;
+  let match;
+  while ((match = classNamePattern.exec(selectorText)) !== null) {
+    classNames.add(match[1]);
+  }
+  return classNames;
+}
+function parseClipboardCssClassStyles(doc) {
+  const styleMap = /* @__PURE__ */ new Map();
+  for (const styleElement of Array.from(doc.querySelectorAll("style"))) {
+    const cssText = (styleElement.textContent ?? "").replace(/<!--|-->/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const rulePattern = /([^{}]+)\{([^{}]*)\}/g;
+    let match;
+    while ((match = rulePattern.exec(cssText)) !== null) {
+      const classNames = extractCssClassNames(match[1]);
+      if (classNames.size === 0) continue;
+      const declarations = parseStyleDeclarations(match[2]);
+      if (declarations.size === 0) continue;
+      for (const className of classNames) {
+        styleMap.set(className, mergeStyleDeclarations(styleMap.get(className), declarations));
+      }
+    }
+  }
+  return styleMap;
+}
+function getElementStyleDeclarations(element, styleMap) {
+  const classDeclarations = Array.from(element.classList).map((className) => styleMap.get(className));
+  const inlineDeclarations = parseStyleDeclarations(element.getAttribute("style"));
+  return mergeStyleDeclarations(...classDeclarations, inlineDeclarations);
+}
+function cleanStyleValue(value) {
+  const normalized = value?.trim();
+  if (!normalized) return null;
+  if (/[\0<>;{}]/.test(normalized)) return null;
+  if (/\b(?:expression|url|(?:repeating-)?(?:linear|radial|conic)-gradient)\s*\(/i.test(normalized)) return null;
+  return normalized;
+}
+function normalizeColorValue(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  if (/^(?:auto|inherit|initial|none|transparent|unset)$/i.test(normalized)) return null;
+  return normalized;
+}
+function normalizeTextColorValue(value) {
+  const normalized = normalizeColorValue(value);
+  if (!normalized) return null;
+  if (/^(?:automatic|windowtext|black|#000|#000000|rgb\(\s*0\s*,\s*0\s*,\s*0\s*\))$/i.test(normalized)) {
+    return DEFAULT_HTML_TABLE_TEXT_COLOR;
+  }
+  return normalized;
+}
+function isWhiteColor(value) {
+  if (!value) return false;
+  return /^(?:white|#fff|#ffffff|rgb\(\s*255\s*,\s*255\s*,\s*255\s*\))$/i.test(value.trim());
+}
+function parseCssColorRgb(value) {
+  const normalized = normalizeColorValue(value);
+  if (!normalized) return null;
+  const lowerColor = normalized.toLowerCase();
+  if (lowerColor === "white") return { r: 255, g: 255, b: 255 };
+  if (lowerColor === "black") return { r: 0, g: 0, b: 0 };
+  const hexMatch = lowerColor.match(/^#([\da-f]{3}|[\da-f]{6})$/i);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    const fullHex = hex.length === 3 ? hex.split("").map((part) => part + part).join("") : hex;
+    return {
+      r: Number.parseInt(fullHex.slice(0, 2), 16),
+      g: Number.parseInt(fullHex.slice(2, 4), 16),
+      b: Number.parseInt(fullHex.slice(4, 6), 16)
+    };
+  }
+  const rgbMatch = lowerColor.match(/^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)/);
+  if (rgbMatch) {
+    return {
+      r: Math.max(0, Math.min(255, Number.parseFloat(rgbMatch[1]))),
+      g: Math.max(0, Math.min(255, Number.parseFloat(rgbMatch[2]))),
+      b: Math.max(0, Math.min(255, Number.parseFloat(rgbMatch[3])))
+    };
+  }
+  return null;
+}
+function getRelativeLuminance(value) {
+  const rgb = parseCssColorRgb(value);
+  if (!rgb) return null;
+  const toLinear = (channel) => {
+    const normalized = channel / 255;
+    return normalized <= 0.03928 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * toLinear(rgb.r) + 0.7152 * toLinear(rgb.g) + 0.0722 * toLinear(rgb.b);
+}
+function isLightTextColor(value) {
+  const luminance = getRelativeLuminance(value);
+  return luminance !== null && luminance >= 0.72;
+}
+function isDarkReadableBackground(value) {
+  const luminance = getRelativeLuminance(value);
+  return luminance !== null && luminance <= 0.45;
+}
+function splitCssTokens(value) {
+  const tokens = [];
+  let current = "";
+  let depth = 0;
+  for (const char of value) {
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (/\s/.test(char) && depth === 0) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+function extractColorFromShorthand(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  const explicitColor = normalized.match(/#[\da-f]{3,8}\b|rgba?\([^)]+\)|hsla?\([^)]+\)/i);
+  if (explicitColor) return explicitColor[0];
+  const ignoredKeywords = /* @__PURE__ */ new Set([
+    "border-box",
+    "center",
+    "contain",
+    "content-box",
+    "cover",
+    "fixed",
+    "inherit",
+    "initial",
+    "left",
+    "local",
+    "none",
+    "no-repeat",
+    "padding-box",
+    "repeat",
+    "repeat-x",
+    "repeat-y",
+    "right",
+    "scroll",
+    "top",
+    "transparent",
+    "unset"
+  ]);
+  return splitCssTokens(normalized).find((token) => !ignoredKeywords.has(token.toLowerCase())) ?? null;
+}
+function getBackgroundColor(styles) {
+  return normalizeColorValue(styles.get("background-color")) ?? normalizeColorValue(extractColorFromShorthand(styles.get("background")));
+}
+var BORDER_STYLES = /* @__PURE__ */ new Set([
+  "dashed",
+  "dotted",
+  "double",
+  "groove",
+  "hidden",
+  "inset",
+  "none",
+  "outset",
+  "ridge",
+  "solid"
+]);
+var BORDER_WIDTH_KEYWORDS = /* @__PURE__ */ new Set(["medium", "thick", "thin"]);
+function normalizeBorderStyle(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  const styles = splitCssTokens(normalized).filter((token) => BORDER_STYLES.has(token.toLowerCase()));
+  const usefulStyles = styles.filter((style) => !/^(?:hidden|none)$/i.test(style));
+  return usefulStyles.length > 0 ? usefulStyles.join(" ") : null;
+}
+function normalizeBorderWidth(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  const widths = splitCssTokens(normalized).filter((token) => {
+    const lowerToken = token.toLowerCase();
+    return BORDER_WIDTH_KEYWORDS.has(lowerToken) || /^\d*\.?\d+(?:px|pt|pc|in|cm|mm|em|rem)?$/i.test(token);
+  });
+  return widths.length > 0 ? widths.join(" ") : null;
+}
+function parseBorderShorthand(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  const tokens = splitCssTokens(normalized);
+  let borderStyle = null;
+  let borderWidth = null;
+  const colorTokens = [];
+  for (const token of tokens) {
+    const lowerToken = token.toLowerCase();
+    if (!borderStyle && BORDER_STYLES.has(lowerToken)) {
+      borderStyle = lowerToken;
+      continue;
+    }
+    if (!borderWidth && (BORDER_WIDTH_KEYWORDS.has(lowerToken) || /^\d*\.?\d+(?:px|pt|pc|in|cm|mm|em|rem)?$/i.test(token))) {
+      borderWidth = token;
+      continue;
+    }
+    colorTokens.push(token);
+  }
+  if (borderStyle && /^(?:hidden|none)$/i.test(borderStyle)) return null;
+  return {
+    borderColor: normalizeColorValue(colorTokens.join(" ")),
+    borderStyle,
+    borderWidth
+  };
+}
+function getFirstParsedBorder(styles) {
+  for (const property of ["border", "border-top", "border-right", "border-bottom", "border-left"]) {
+    const border = parseBorderShorthand(styles.get(property));
+    if (border) return border;
+  }
+  return null;
+}
+function getBorderAttrs(styles) {
+  const parsedBorder = getFirstParsedBorder(styles);
+  return {
+    borderColor: normalizeColorValue(styles.get("border-color")) ?? parsedBorder?.borderColor ?? void 0,
+    borderStyle: normalizeBorderStyle(styles.get("border-style")) ?? parsedBorder?.borderStyle ?? void 0,
+    borderWidth: normalizeBorderWidth(styles.get("border-width")) ?? parsedBorder?.borderWidth ?? void 0
+  };
+}
+function parsePositiveInteger(value, max = 100) {
+  if (!value) return null;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) return null;
+  return Math.min(parsed, max);
+}
+function parseCssSize(value) {
+  const normalized = cleanStyleValue(value);
+  if (!normalized) return null;
+  const match = normalized.match(/^(\d+(?:\.\d+)?)(px|pt)?$/i);
+  if (!match) return null;
+  const amount = Number.parseFloat(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  return Math.round(match[2]?.toLowerCase() === "pt" ? amount * (4 / 3) : amount);
+}
+function getCellWidth(cell, styles, colspan) {
+  if (colspan !== 1) return null;
+  const width = parseCssSize(cell.getAttribute("data-colwidth") ?? cell.getAttribute("width") ?? styles.get("width"));
+  return width ? [width] : null;
+}
+function getTableRowAttrs(row, styles) {
+  const rowHeight = parseCssSize(
+    row.getAttribute("data-row-height") ?? row.getAttribute("height") ?? styles.get("height")
+  );
+  return rowHeight ? { rowHeight } : void 0;
+}
+function getTableCellAttrs(cell, styles, defaultBackgroundColor) {
+  const colspan = parsePositiveInteger(cell.getAttribute("colspan")) ?? 1;
+  const rowspan = parsePositiveInteger(cell.getAttribute("rowspan")) ?? 1;
+  const backgroundColor = getBackgroundColor(styles) ?? normalizeColorValue(cell.getAttribute("data-background-color")) ?? normalizeColorValue(cell.getAttribute("bgcolor")) ?? defaultBackgroundColor;
+  const borderAttrs = getBorderAttrs(styles);
+  const colwidth = getCellWidth(cell, styles, colspan);
+  const attrs = {};
+  if (backgroundColor) attrs.backgroundColor = backgroundColor;
+  if (borderAttrs.borderColor) attrs.borderColor = borderAttrs.borderColor;
+  if (borderAttrs.borderStyle) attrs.borderStyle = borderAttrs.borderStyle;
+  if (borderAttrs.borderWidth) attrs.borderWidth = borderAttrs.borderWidth;
+  if (cell.getAttribute("data-cell-id")) attrs.cellId = cell.getAttribute("data-cell-id") ?? void 0;
+  if (cell.getAttribute("data-number-format")) attrs.numberFormat = cell.getAttribute("data-number-format") ?? void 0;
+  if (cell.getAttribute("data-formula")) attrs.formula = cell.getAttribute("data-formula") ?? void 0;
+  if (cell.getAttribute("data-computed-value")) attrs.computedValue = cell.getAttribute("data-computed-value") ?? void 0;
+  if (colspan > 1) attrs.colspan = colspan;
+  if (rowspan > 1) attrs.rowspan = rowspan;
+  if (colwidth) attrs.colwidth = colwidth;
+  return Object.keys(attrs).length > 0 ? attrs : void 0;
+}
+function marksEqual(left, right) {
+  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+function mergeMarks(base, additions) {
+  const next = [...base ?? []];
+  for (const addition of additions ?? []) {
+    const existingIndex = next.findIndex((mark) => mark.type === addition.type);
+    if (existingIndex >= 0) {
+      const existingMark = next[existingIndex];
+      next[existingIndex] = {
+        ...existingMark,
+        attrs: {
+          ...existingMark.attrs ?? {},
+          ...addition.attrs ?? {}
+        }
+      };
+      continue;
+    }
+    next.push(addition);
+  }
+  return next.length > 0 ? next : void 0;
+}
+function getMarkColor(marks, markType) {
+  const mark = marks?.find((candidate) => candidate.type === markType);
+  const color = mark?.attrs?.color;
+  return typeof color === "string" ? color : null;
+}
+function replaceTextStyleColor(marks, color) {
+  let replaced = false;
+  const next = (marks ?? []).map((mark) => {
+    if (mark.type !== "textStyle") return mark;
+    replaced = true;
+    return {
+      ...mark,
+      attrs: {
+        ...mark.attrs ?? {},
+        color
+      }
+    };
+  });
+  if (!replaced) {
+    next.unshift({ type: "textStyle", attrs: { color } });
+  }
+  return next;
+}
+function ensureReadableSpreadsheetSegments(segments, cellBackgroundColor) {
+  return segments.map((segment) => {
+    const textColor = getMarkColor(segment.marks, "textStyle");
+    if (!isLightTextColor(textColor)) return segment;
+    const inlineBackgroundColor = getMarkColor(segment.marks, "highlight");
+    if (isDarkReadableBackground(inlineBackgroundColor) || isDarkReadableBackground(cellBackgroundColor)) {
+      return segment;
+    }
+    return {
+      ...segment,
+      marks: replaceTextStyleColor(segment.marks, DEFAULT_HTML_TABLE_TEXT_COLOR)
+    };
+  });
+}
+function getElementInlineMarks(element, styles) {
+  const marks = [];
+  const tagName = element.tagName;
+  const color = normalizeTextColorValue(styles.get("color") ?? element.getAttribute("color"));
+  const backgroundColor = getBackgroundColor(styles);
+  const fontWeight = styles.get("font-weight")?.toLowerCase();
+  const fontStyle = styles.get("font-style")?.toLowerCase();
+  const textDecoration = styles.get("text-decoration")?.toLowerCase();
+  if (color) {
+    marks.push({ type: "textStyle", attrs: { color } });
+  }
+  if (backgroundColor && !isWhiteColor(backgroundColor)) {
+    marks.push({ type: "highlight", attrs: { color: backgroundColor } });
+  }
+  if (tagName === "B" || tagName === "STRONG" || fontWeight === "bold" || /^\d+$/.test(fontWeight ?? "") && Number(fontWeight) >= 600) {
+    marks.push({ type: "bold" });
+  }
+  if (tagName === "I" || tagName === "EM" || fontStyle === "italic") {
+    marks.push({ type: "italic" });
+  }
+  if (tagName === "U" || textDecoration?.includes("underline")) {
+    marks.push({ type: "underline" });
+  }
+  return marks.length > 0 ? marks : void 0;
+}
+function appendTextSegment(segments, segment) {
+  if (!segment.text) return;
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment && marksEqual(lastSegment.marks, segment.marks)) {
+    lastSegment.text += segment.text;
+    return;
+  }
+  segments.push(segment);
+}
+function segmentsEndWithNewline(segments) {
+  return segments.length > 0 && segments[segments.length - 1].text.endsWith("\n");
+}
+function normalizeClipboardTextSegments(segments) {
+  const normalizedSegments = [];
+  for (const segment of segments) {
+    appendTextSegment(normalizedSegments, {
+      text: segment.text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u00a0/g, " "),
+      marks: segment.marks
+    });
+  }
+  while (normalizedSegments.length > 0) {
+    const firstSegment = normalizedSegments[0];
+    firstSegment.text = firstSegment.text.replace(/^\s+/, "");
+    if (firstSegment.text) break;
+    normalizedSegments.shift();
+  }
+  while (normalizedSegments.length > 0) {
+    const lastSegment = normalizedSegments[normalizedSegments.length - 1];
+    lastSegment.text = lastSegment.text.replace(/\s+$/, "");
+    if (lastSegment.text) break;
+    normalizedSegments.pop();
+  }
+  return normalizedSegments;
+}
+function getClipboardCellText(node) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent ?? "";
+  }
+  if (!(node instanceof HTMLElement)) {
+    return "";
+  }
+  if (node.tagName === "BR") {
+    return "\n";
+  }
+  const childText = Array.from(node.childNodes).map(getClipboardCellText).join("");
+  if ((node.tagName === "P" || node.tagName === "DIV" || node.tagName === "LI") && childText && !childText.endsWith("\n")) {
+    return `${childText}
+`;
+  }
+  return childText;
+}
+function getClipboardCellSegments(node, styleMap, inheritedMarks) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return [{ text: node.textContent ?? "", marks: inheritedMarks }];
+  }
+  if (!(node instanceof HTMLElement)) {
+    return [];
+  }
+  if (node.tagName === "BR") {
+    return [{ text: "\n", marks: inheritedMarks }];
+  }
+  const styles = getElementStyleDeclarations(node, styleMap);
+  const marks = mergeMarks(inheritedMarks, getElementInlineMarks(node, styles));
+  const segments = [];
+  for (const childNode of Array.from(node.childNodes)) {
+    for (const segment of getClipboardCellSegments(childNode, styleMap, marks)) {
+      appendTextSegment(segments, segment);
+    }
+  }
+  if ((node.tagName === "P" || node.tagName === "DIV" || node.tagName === "LI") && segments.length > 0 && !segmentsEndWithNewline(segments)) {
+    appendTextSegment(segments, { text: "\n" });
+  }
+  return segments;
+}
+function getClipboardCellChildSegments(cell, styleMap, inheritedMarks) {
+  const segments = [];
+  for (const childNode of Array.from(cell.childNodes)) {
+    for (const segment of getClipboardCellSegments(childNode, styleMap, inheritedMarks)) {
+      appendTextSegment(segments, segment);
+    }
+  }
+  return normalizeClipboardTextSegments(segments);
+}
+function getHtmlTableRows(table, styleMap) {
+  const rows = Array.from(table.querySelectorAll("tr")).map(
+    (row) => ({
+      attrs: getTableRowAttrs(row, getElementStyleDeclarations(row, styleMap)),
+      cells: Array.from(row.children).filter((cell) => cell instanceof HTMLTableCellElement).map((cell) => {
+        const styles = getElementStyleDeclarations(cell, styleMap);
+        const textColor = normalizeTextColorValue(styles.get("color")) ?? DEFAULT_HTML_TABLE_TEXT_COLOR;
+        const inheritedMarks = [{ type: "textStyle", attrs: { color: textColor } }];
+        const attrs = getTableCellAttrs(cell, styles, DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR);
+        const segments = ensureReadableSpreadsheetSegments(
+          getClipboardCellChildSegments(cell, styleMap, inheritedMarks),
+          attrs?.backgroundColor
+        );
+        return {
+          text: normalizeClipboardCellText(getClipboardCellText(cell)),
+          isHeader: cell.tagName === "TH",
+          attrs,
+          segments: segments.length > 0 ? segments : void 0,
+          textColor
+        };
+      })
+    })
+  );
+  return rows.filter((row) => row.cells.length > 0);
+}
+function createTextMarks(cell) {
+  return cell.textColor ? [{ type: "textStyle", attrs: { color: cell.textColor } }] : void 0;
+}
+function createParagraphContent(text, marks) {
+  return text ? {
+    type: "paragraph",
+    content: [{ type: "text", text, ...marks ? { marks } : {} }]
+  } : { type: "paragraph" };
+}
+function createParagraphContentFromSegments(segments) {
+  const paragraphs = [[]];
+  for (const segment of segments) {
+    const parts = segment.text.split("\n");
+    parts.forEach((part, index) => {
+      if (part) {
+        paragraphs[paragraphs.length - 1].push({ text: part, marks: segment.marks });
+      }
+      if (index < parts.length - 1) {
+        paragraphs.push([]);
+      }
+    });
+  }
+  return paragraphs.map((paragraphSegments) => {
+    const content = paragraphSegments.map((segment) => ({
+      type: "text",
+      text: segment.text,
+      ...segment.marks ? { marks: segment.marks } : {}
+    }));
+    return content.length > 0 ? { type: "paragraph", content } : { type: "paragraph" };
+  });
+}
+function createTableCellContent(cell) {
+  const lines = cell.text.split("\n");
+  const marks = createTextMarks(cell);
+  const paragraphs = cell.segments && cell.segments.length > 0 ? createParagraphContentFromSegments(cell.segments) : (lines.length > 0 ? lines : [""]).map((line) => createParagraphContent(line, marks));
+  return {
+    type: cell.isHeader ? "tableHeader" : "tableCell",
+    ...cell.attrs ? { attrs: cell.attrs } : {},
+    content: paragraphs.length > 0 ? paragraphs : [{ type: "paragraph" }]
+  };
+}
+function getRowspanLimitedCell(cell, remainingRowCount) {
+  const attrs = cell.attrs;
+  if (!attrs?.rowspan || attrs.rowspan <= remainingRowCount) return cell;
+  if (remainingRowCount <= 1) {
+    const { rowspan: _rowspan, ...nextAttrs } = attrs;
+    return {
+      ...cell,
+      attrs: Object.keys(nextAttrs).length > 0 ? nextAttrs : void 0
+    };
+  }
+  return {
+    ...cell,
+    attrs: {
+      ...attrs,
+      rowspan: remainingRowCount
+    }
+  };
+}
+function normalizeTableRows(rows) {
+  const positionedRows = [];
+  let rowspans = [];
+  let columnCount = 0;
+  rows.forEach((row, rowIndex) => {
+    const coveredColumns = rowspans.map((span) => span > 0);
+    const nextRowspans = rowspans.map((span) => Math.max(0, span - 1));
+    const positionedCells = [];
+    let columnIndex = 0;
+    for (const rawCell of row.cells) {
+      while (coveredColumns[columnIndex]) columnIndex += 1;
+      const remainingRowCount = rows.length - rowIndex;
+      const cell = getRowspanLimitedCell(rawCell, remainingRowCount);
+      const colspan = Math.max(1, cell.attrs?.colspan ?? 1);
+      const rowspan = Math.max(1, cell.attrs?.rowspan ?? 1);
+      positionedCells.push({ startColumn: columnIndex, colspan, cell });
+      if (rowspan > 1) {
+        for (let offset = 0; offset < colspan; offset += 1) {
+          const spannedColumn = columnIndex + offset;
+          nextRowspans[spannedColumn] = Math.max(nextRowspans[spannedColumn] ?? 0, rowspan - 1);
+        }
+      }
+      columnIndex += colspan;
+    }
+    const lastCoveredColumn = coveredColumns.reduce((lastIndex, covered, index) => covered ? index : lastIndex, -1);
+    const lastFutureRowspanColumn = nextRowspans.reduce((lastIndex, span, index) => span > 0 ? index : lastIndex, -1);
+    columnCount = Math.max(columnCount, columnIndex, lastCoveredColumn + 1, lastFutureRowspanColumn + 1);
+    positionedRows.push({
+      attrs: row.attrs,
+      cells: positionedCells,
+      coveredColumns
+    });
+    rowspans = nextRowspans;
+  });
+  return { positionedRows, columnCount };
+}
+function createNormalizedRowContent(row, columnCount, fillerCellAttrs) {
+  const content = [];
+  const cellByStartColumn = new Map(row.cells.map((cell) => [cell.startColumn, cell]));
+  let columnIndex = 0;
+  while (columnIndex < columnCount) {
+    if (row.coveredColumns[columnIndex]) {
+      columnIndex += 1;
+      continue;
+    }
+    const positionedCell = cellByStartColumn.get(columnIndex);
+    if (positionedCell) {
+      content.push(createTableCellContent(positionedCell.cell));
+      columnIndex += positionedCell.colspan;
+      continue;
+    }
+    content.push(createTableCellContent({ text: "", isHeader: false, attrs: fillerCellAttrs }));
+    columnIndex += 1;
+  }
+  return content;
+}
+function createTableContent(rows, minColumnCount = 1, fillerCellAttrs) {
+  const tableRows = rows.filter((row) => row.cells.length > 0);
+  if (tableRows.length === 0) return null;
+  const { positionedRows, columnCount } = normalizeTableRows(tableRows);
+  if (columnCount < minColumnCount) return null;
+  return {
+    type: "table",
+    content: positionedRows.map((row) => ({
+      type: "tableRow",
+      ...row.attrs ? { attrs: row.attrs } : {},
+      content: createNormalizedRowContent(row, columnCount, fillerCellAttrs)
+    }))
+  };
+}
+function getClipboardTableContent(dataTransfer) {
+  const html = getClipboardData(dataTransfer, "text/html");
+  if (!/<table(?:\s|>)/i.test(html)) return null;
+  if (typeof DOMParser === "undefined") return null;
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  const fragment = extractClipboardHtmlFragment(html);
+  const fragmentDoc = new DOMParser().parseFromString(fragment, "text/html");
+  const styleMap = parseClipboardCssClassStyles(doc);
+  const table = fragmentDoc.querySelector("table") ?? doc.querySelector("table");
+  if (!(table instanceof HTMLTableElement)) return null;
+  return createTableContent(getHtmlTableRows(table, styleMap), 1, {
+    backgroundColor: DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR
+  });
+}
+function parseClipboardTsvRows(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let inQuotes = false;
+  const pushField = () => {
+    row.push(field);
+    field = "";
+  };
+  const pushRow = () => {
+    pushField();
+    rows.push(row);
+    row = [];
+  };
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const nextChar = text[index + 1];
+    if (inQuotes) {
+      if (char === '"' && nextChar === '"') {
+        field += '"';
+        index += 1;
+        continue;
+      }
+      if (char === '"') {
+        inQuotes = false;
+        continue;
+      }
+      field += char;
+      continue;
+    }
+    if (char === '"' && field.length === 0) {
+      inQuotes = true;
+      continue;
+    }
+    if (char === "	") {
+      pushField();
+      continue;
+    }
+    if (char === "\n") {
+      pushRow();
+      continue;
+    }
+    field += char;
+  }
+  pushRow();
+  while (rows.length > 0 && rows[rows.length - 1].every((cell) => cell === "")) {
+    rows.pop();
+  }
+  return rows;
+}
+function getClipboardTsvTableContent(dataTransfer) {
+  const text = getClipboardData(dataTransfer, "text/plain").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (!text.includes("	")) return null;
+  const rows = parseClipboardTsvRows(text);
+  return createTableContent(
+    rows.map((row) => ({
+      cells: row.map((cell) => ({ text: normalizeClipboardCellText(cell), isHeader: false }))
+    })),
+    2
+  );
+}
+
+// src/components/UEditor/clipboard-images.ts
+var DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_UEDITOR_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml"];
+function getImageFiles(dataTransfer) {
+  if (!dataTransfer) return [];
+  const itemFiles = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of Array.from(dataTransfer.items ?? [])) {
+    if (item.kind !== "file") continue;
+    if (!item.type.startsWith("image/")) continue;
+    const file = item.getAsFile();
+    if (!file) continue;
+    byKey.set(`${file.name}:${file.size}:${file.lastModified}`, file);
+  }
+  itemFiles.push(...Array.from(byKey.values()));
+  if (itemFiles.length > 0) return itemFiles;
+  for (const file of Array.from(dataTransfer.files ?? [])) {
+    if (!file.type.startsWith("image/")) continue;
+    byKey.set(`${file.name}:${file.size}:${file.lastModified}`, file);
+  }
+  return Array.from(byKey.values());
+}
+function fileToDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ""));
+    reader.onerror = () => reject(reader.error ?? new Error("Failed to read image file"));
+    reader.readAsDataURL(file);
+  });
+}
+async function resolveImageSrc(file, options) {
+  if (options.insertMode === "upload" && options.upload) {
+    try {
+      const result = await options.upload(file);
+      const src = typeof result === "string" ? sanitizeUEditorUrl(result, "image") : "";
+      if (src) return src;
+    } catch (err) {
+      if (!options.fallbackToDataUrl) throw err;
+    }
+  }
+  return fileToDataUrl(file);
+}
+var ClipboardImages = Extension.create({
+  name: "clipboardImages",
+  addOptions() {
+    return {
+      maxFileSize: DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE,
+      allowedMimeTypes: DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
+      upload: void 0,
+      fallbackToDataUrl: true,
+      insertMode: "base64"
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    const options = this.options;
+    const insertFiles = async (files, selectionPos) => {
+      if (selectionPos !== void 0) {
+        editor.commands.setTextSelection(selectionPos);
+      }
+      for (const file of files) {
+        if (file.size > options.maxFileSize) continue;
+        if (options.allowedMimeTypes.length > 0 && !options.allowedMimeTypes.includes(file.type)) continue;
+        try {
+          const src = await resolveImageSrc(file, options);
+          editor.chain().focus().setImage({ src, alt: file.name }).run();
+          editor.commands.createParagraphNear();
+        } catch {
+        }
+      }
+    };
+    return [
+      new Plugin({
+        props: {
+          handlePaste: (_view, event) => {
+            if (!event || !event.clipboardData) return false;
+            const tableContent = getClipboardTableContent(event.clipboardData);
+            if (tableContent) {
+              event.preventDefault();
+              editor.chain().focus().insertContent(tableContent).run();
+              return true;
+            }
+            const tsvTableContent = getClipboardTsvTableContent(event.clipboardData);
+            if (tsvTableContent) {
+              event.preventDefault();
+              editor.chain().focus().insertContent(tsvTableContent).run();
+              return true;
+            }
+            const files = getImageFiles(event.clipboardData);
+            if (files.length === 0) return false;
+            event.preventDefault();
+            void insertFiles(files);
+            return true;
+          },
+          handleDrop: (view, event, _slice, moved) => {
+            if (moved) return false;
+            if (!(event instanceof DragEvent)) return false;
+            const files = getImageFiles(event.dataTransfer);
+            if (files.length === 0) return false;
+            const pos = view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos;
+            event.preventDefault();
+            void insertFiles(files, pos);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/components/UEditor/inputs.tsx
+import { useEffect as useEffect3, useId as useId2, useRef as useRef2, useState as useState3 } from "react";
+import { Check, X } from "lucide-react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function normalizeUrl(raw) {
+  return sanitizeUEditorUrl(raw, "link");
+}
+var LinkInput = ({
+  onSubmit,
+  onCancel,
+  initialUrl = ""
+}) => {
+  const t = useSmartTranslations("UEditor");
+  const [url, setUrl] = useState3(initialUrl);
+  const [error, setError] = useState3("");
+  const inputRef = useRef2(null);
+  const errorId = useId2();
+  useEffect3(() => {
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, []);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    const normalized = normalizeUrl(url);
+    if (!normalized) {
+      setError(t("linkInput.invalid"));
+      return;
+    }
+    setError("");
+    onSubmit(normalized);
+  };
+  return /* @__PURE__ */ jsxs3("form", { onSubmit: handleSubmit, className: "p-2", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          ref: inputRef,
+          type: "text",
+          value: url,
+          onChange: (e) => {
+            setUrl(e.target.value);
+            if (error) setError("");
+          },
+          placeholder: t("linkInput.placeholder"),
+          "aria-invalid": Boolean(error),
+          "aria-describedby": error ? errorId : void 0,
+          className: "flex-1 px-3 py-2 text-sm bg-muted/50 border-0 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary/20 aria-invalid:ring-2 aria-invalid:ring-destructive/40"
+        }
+      ),
+      /* @__PURE__ */ jsx4("button", { type: "submit", className: "p-2 rounded-lg bg-primary text-primary-foreground hover:bg-primary/90 transition-colors", children: /* @__PURE__ */ jsx4(Check, { className: "w-4 h-4" }) }),
+      /* @__PURE__ */ jsx4("button", { type: "button", onClick: onCancel, className: "p-2 rounded-lg hover:bg-muted transition-colors text-muted-foreground", children: /* @__PURE__ */ jsx4(X, { className: "w-4 h-4" }) })
+    ] }),
+    error ? /* @__PURE__ */ jsx4("p", { id: errorId, role: "alert", className: "mt-1.5 px-1 text-xs text-destructive", children: error }) : null
+  ] });
+};
+var ImageInput = ({ onSubmit, onCancel }) => {
+  const t = useSmartTranslations("UEditor");
+  const [url, setUrl] = useState3("");
+  const [alt, setAlt] = useState3("");
+  const inputRef = useRef2(null);
+  useEffect3(() => {
+    inputRef.current?.focus();
+  }, []);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    const safeUrl = sanitizeUEditorUrl(url, "image");
+    if (safeUrl) {
+      onSubmit(safeUrl, alt);
+    }
+  };
+  return /* @__PURE__ */ jsxs3("form", { onSubmit: handleSubmit, className: "p-3 space-y-3", children: [
+    /* @__PURE__ */ jsxs3("div", { children: [
+      /* @__PURE__ */ jsx4("label", { className: "text-xs font-medium text-muted-foreground", children: t("imageInput.urlLabel") }),
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          ref: inputRef,
+          type: "text",
+          value: url,
+          onChange: (e) => setUrl(e.target.value),
+          placeholder: t("imageInput.urlPlaceholder"),
+          className: "w-full mt-1 px-3 py-2 text-sm bg-muted/50 border-0 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary/20"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { children: [
+      /* @__PURE__ */ jsx4("label", { className: "text-xs font-medium text-muted-foreground", children: t("imageInput.altLabel") }),
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          type: "text",
+          value: alt,
+          onChange: (e) => setAlt(e.target.value),
+          placeholder: t("imageInput.altPlaceholder"),
+          className: "w-full mt-1 px-3 py-2 text-sm bg-muted/50 border-0 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary/20"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "submit",
+          disabled: !url,
+          className: "flex-1 py-2 rounded-lg bg-primary text-primary-foreground hover:bg-primary/90 transition-colors disabled:opacity-50",
+          children: t("imageInput.addBtn")
+        }
+      ),
+      /* @__PURE__ */ jsx4("button", { type: "button", onClick: onCancel, className: "px-4 py-2 rounded-lg hover:bg-muted transition-colors text-muted-foreground", children: t("imageInput.cancelBtn") })
+    ] })
+  ] });
+};
+
+// src/components/UEditor/link-commands.ts
+import { TextSelection } from "@tiptap/pm/state";
+function applyEditorLink(editor, href) {
+  const isEditingLink = editor.isActive("link");
+  const hasSelectedText = !editor.state.selection.empty;
+  const chain = editor.chain().focus();
+  if (isEditingLink) {
+    chain.extendMarkRange("link");
+  }
+  chain.setLink({ href });
+  if (!hasSelectedText && !isEditingLink) {
+    chain.insertContent(href);
+  }
+  return chain.command(({ tr }) => {
+    tr.setSelection(TextSelection.create(tr.doc, tr.selection.to));
+    tr.removeStoredMark(editor.schema.marks.link);
+    return true;
+  }).run();
+}
+
+// src/components/UEditor/toolbar.tsx
+import React7, { useRef as useRef4, useState as useState4 } from "react";
+import { useEditorState } from "@tiptap/react";
+import {
+  AlignCenter,
+  AlignJustify,
+  AlignLeft,
+  AlignRight,
+  ArrowDown,
+  ArrowLeft,
+  ArrowRight,
+  ArrowUp,
+  CircleCheckBig,
+  FileCode,
+  Heading1 as Heading1Icon,
+  Heading2 as Heading2Icon,
+  Heading3 as Heading3Icon,
+  IndentDecrease,
+  IndentIncrease,
+  Link as LinkIcon,
+  List as ListIcon,
+  ListOrdered as ListOrderedIcon,
+  ListTodo,
+  Quote as QuoteIcon,
+  RotateCcw,
+  SquareCheckBig,
+  TableCellsMerge,
+  Trash2,
+  Type,
+  Upload,
+  AlignStartVertical,
+  AlignCenterVertical,
+  AlignEndVertical
+} from "lucide-react";
+import { setCellAttr } from "@tiptap/pm/tables";
+
+// src/components/UEditor/colors.tsx
+import { useMemo as useMemo2, useRef as useRef3 } from "react";
+import { Check as Check2, Palette, Paintbrush, Grid } from "lucide-react";
+
+// src/components/UEditor/figma-toolbar-icons.tsx
+import React5 from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function createToolbarIcon(displayName, width, height, path) {
+  const Icon = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+    "svg",
+    {
+      ref,
+      "aria-hidden": "true",
+      focusable: "false",
+      viewBox: `0 0 ${width} ${height}`,
+      className,
+      fill: "currentColor",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      children: /* @__PURE__ */ jsx5("path", { d: path })
+    }
+  ));
+  Icon.displayName = displayName;
+  return Icon;
+}
+var FigmaChevronDownIcon = createToolbarIcon(
+  "FigmaChevronDownIcon",
+  512,
+  512,
+  "M233.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L256 338.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z"
+);
+var FigmaTextStyleIcon = ({ className, ...props }) => /* @__PURE__ */ jsx5("svg", { "aria-hidden": "true", focusable: "false", viewBox: "0 0 24 24", className, fill: "currentColor", ...props, children: /* @__PURE__ */ jsx5("path", { d: "M4 4.25C4 3.56 4.56 3 5.25 3h13.5C19.44 3 20 3.56 20 4.25v2.5a1 1 0 1 1-2 0V5h-5v14h2a1 1 0 1 1 0 2H9a1 1 0 1 1 0-2h2V5H6v1.75a1 1 0 1 1-2 0v-2.5Z" }) });
+var FigmaLineHeightIcon = createToolbarIcon(
+  "FigmaLineHeightIcon",
+  576,
+  512,
+  "M64 128l0-32 64 0 0 320-32 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l128 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-32 0 0-320 64 0 0 32c0 17.7 14.3 32 32 32s32-14.3 32-32l0-48c0-26.5-21.5-48-48-48L160 32 48 32C21.5 32 0 53.5 0 80l0 48c0 17.7 14.3 32 32 32s32-14.3 32-32zM502.6 41.4c-12.5-12.5-32.8-12.5-45.3 0l-64 64c-9.2 9.2-11.9 22.9-6.9 34.9s16.6 19.8 29.6 19.8l32 0 0 192-32 0c-12.9 0-24.6 7.8-29.6 19.8s-2.2 25.7 6.9 34.9l64 64c12.5 12.5 32.8 12.5 45.3 0l64-64c9.2-9.2 11.9-22.9 6.9-34.9s-16.6-19.8-29.6-19.8l-32 0 0-192 32 0c12.9 0 24.6-7.8 29.6-19.8s2.2-25.7-6.9-34.9l-64-64z"
+);
+var FigmaLetterSpacingIcon = createToolbarIcon(
+  "FigmaLetterSpacingIcon",
+  448,
+  512,
+  "M64 128l0-32 128 0 0 128-16 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l96 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-16 0 0-128 128 0 0 32c0 17.7 14.3 32 32 32s32-14.3 32-32l0-48c0-26.5-21.5-48-48-48L224 32 48 32C21.5 32 0 53.5 0 80l0 48c0 17.7 14.3 32 32 32s32-14.3 32-32zM9.4 361.4c-12.5 12.5-12.5 32.8 0 45.3l64 64c9.2 9.2 22.9 11.9 34.9 6.9s19.8-16.6 19.8-29.6l0-32 192 0 0 32c0 12.9 7.8 24.6 19.8 29.6s25.7 2.2 34.9-6.9l64-64c12.5-12.5 12.5-32.8 0-45.3l-64-64c-9.2-9.2-22.9-11.9-34.9-6.9s-19.8 16.6-19.8 29.6l0 32-192 0 0-32c0-12.9-7.8-24.6-19.8-29.6s-25.7-2.2-34.9 6.9l-64 64z"
+);
+var FigmaBoldIcon = createToolbarIcon(
+  "FigmaBoldIcon",
+  384,
+  512,
+  "M0 64C0 46.3 14.3 32 32 32l48 0 16 0 128 0c70.7 0 128 57.3 128 128c0 31.3-11.3 60.1-30 82.3c37.1 22.4 62 63.1 62 109.7c0 70.7-57.3 128-128 128L96 480l-16 0-48 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l16 0 0-160L48 96 32 96C14.3 96 0 81.7 0 64zM224 224c35.3 0 64-28.7 64-64s-28.7-64-64-64L112 96l0 128 112 0zM112 288l0 128 144 0c35.3 0 64-28.7 64-64s-28.7-64-64-64l-32 0-112 0z"
+);
+var FigmaItalicIcon = createToolbarIcon(
+  "FigmaItalicIcon",
+  384,
+  512,
+  "M128 64c0-17.7 14.3-32 32-32l192 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-58.7 0L160 416l64 0c17.7 0 32 14.3 32 32s-14.3 32-32 32L32 480c-17.7 0-32-14.3-32-32s14.3-32 32-32l58.7 0L224 96l-64 0c-17.7 0-32-14.3-32-32z"
+);
+var FigmaUnderlineIcon = createToolbarIcon(
+  "FigmaUnderlineIcon",
+  448,
+  512,
+  "M16 64c0-17.7 14.3-32 32-32l96 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-16 0 0 128c0 53 43 96 96 96s96-43 96-96l0-128-16 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l96 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-16 0 0 128c0 88.4-71.6 160-160 160s-160-71.6-160-160L64 96 48 96C30.3 96 16 81.7 16 64zM0 448c0-17.7 14.3-32 32-32l384 0c17.7 0 32 14.3 32 32s-14.3 32-32 32L32 480c-17.7 0-32-14.3-32-32z"
+);
+var FigmaStrikeIcon = createToolbarIcon(
+  "FigmaStrikeIcon",
+  512,
+  512,
+  "M161.3 144c3.2-17.2 14-30.1 33.7-38.6c21.1-9 51.8-12.3 88.6-6.5c11.9 1.9 48.8 9.1 60.1 12c17.1 4.5 34.6-5.6 39.2-22.7s-5.6-34.6-22.7-39.2c-14.3-3.8-53.6-11.4-66.6-13.4c-44.7-7-88.3-4.2-123.7 10.9c-36.5 15.6-64.4 44.8-71.8 87.3c-.1 .6-.2 1.1-.2 1.7c-2.8 23.9 .5 45.6 10.1 64.6c4.5 9 10.2 16.9 16.7 23.9L32 224c-17.7 0-32 14.3-32 32s14.3 32 32 32l448 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-209.9 0-.4-.1-1.1-.3c-36-10.8-65.2-19.6-85.2-33.1c-9.3-6.3-15-12.6-18.2-19.1c-3.1-6.1-5.2-14.6-3.8-27.4zM348.9 337.2c2.7 6.5 4.4 15.8 1.9 30.1c-3 17.6-13.8 30.8-33.9 39.4c-21.1 9-51.7 12.3-88.5 6.5c-18-2.9-49.1-13.5-74.4-22.1c-5.6-1.9-11-3.7-15.9-5.4c-16.8-5.6-34.9 3.5-40.5 20.3s3.5 34.9 20.3 40.5c3.6 1.2 7.9 2.7 12.7 4.3c24.9 8.5 63.6 21.7 87.6 25.6l.2 0c44.7 7 88.3 4.2 123.7-10.9c36.5-15.6 64.4-44.8 71.8-87.3c3.6-21 2.7-40.4-3.1-58.1l-75.7 0c7 5.6 11.4 11.2 13.9 17.2z"
+);
+var FigmaCodeIcon = createToolbarIcon(
+  "FigmaCodeIcon",
+  640,
+  512,
+  "M392.8 1.2c-17-4.9-34.7 5-39.6 22l-128 448c-4.9 17 5 34.7 22 39.6s34.7-5 39.6-22l128-448c4.9-17-5-34.7-22-39.6zm80.6 120.1c-12.5 12.5-12.5 32.8 0 45.3L562.7 256l-89.4 89.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l112-112c12.5-12.5 12.5-32.8 0-45.3l-112-112c-12.5-12.5-32.8-12.5-45.3 0zm-306.7 0c-12.5-12.5-32.8-12.5-45.3 0l-112 112c-12.5 12.5-12.5 32.8 0 45.3l112 112c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L77.3 256l89.4-89.4c12.5-12.5 12.5-32.8 0-45.3z"
+);
+var FigmaSubscriptIcon = createToolbarIcon(
+  "FigmaSubscriptIcon",
+  512,
+  512,
+  "M32 64C14.3 64 0 78.3 0 96s14.3 32 32 32l15.3 0 89.6 128L47.3 384 32 384c-17.7 0-32 14.3-32 32s14.3 32 32 32l32 0c10.4 0 20.2-5.1 26.2-13.6L176 311.8l85.8 122.6c6 8.6 15.8 13.6 26.2 13.6l32 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-15.3 0L215.1 256l89.6-128 15.3 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-32 0c-10.4 0-20.2 5.1-26.2 13.6L176 200.2 90.2 77.6C84.2 69.1 74.4 64 64 64L32 64zM480 320c0-11.1-5.7-21.4-15.2-27.2s-21.2-6.4-31.1-1.4l-32 16c-15.8 7.9-22.2 27.1-14.3 42.9C393 361.5 404.3 368 416 368l0 80c-17.7 0-32 14.3-32 32s14.3 32 32 32l64 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l0-128z"
+);
+var FigmaSuperscriptIcon = createToolbarIcon(
+  "FigmaSuperscriptIcon",
+  512,
+  512,
+  "M480 32c0-11.1-5.7-21.4-15.2-27.2s-21.2-6.4-31.1-1.4l-32 16c-15.8 7.9-22.2 27.1-14.3 42.9C393 73.5 404.3 80 416 80l0 80c-17.7 0-32 14.3-32 32s14.3 32 32 32l64 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l0-128zM32 64C14.3 64 0 78.3 0 96s14.3 32 32 32l15.3 0 89.6 128L47.3 384 32 384c-17.7 0-32 14.3-32 32s14.3 32 32 32l32 0c10.4 0 20.2-5.1 26.2-13.6L176 311.8l85.8 122.6c6 8.6 15.8 13.6 26.2 13.6l32 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-15.3 0L215.1 256l89.6-128 15.3 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-32 0c-10.4 0-20.2 5.1-26.2 13.6L176 200.2 90.2 77.6C84.2 69.1 74.4 64 64 64L32 64z"
+);
+var FigmaLinkIcon = createToolbarIcon(
+  "FigmaLinkIcon",
+  640,
+  512,
+  "M579.8 267.7c56.5-56.5 56.5-148 0-204.5c-50-50-128.8-56.5-186.3-15.4l-1.6 1.1c-14.4 10.3-17.7 30.3-7.4 44.6s30.3 17.7 44.6 7.4l1.6-1.1c32.1-22.9 76-19.3 103.8 8.6c31.5 31.5 31.5 82.5 0 114L422.3 334.8c-31.5 31.5-82.5 31.5-114 0c-27.9-27.9-31.5-71.8-8.6-103.8l1.1-1.6c10.3-14.4 6.9-34.4-7.4-44.6s-34.4-6.9-44.6 7.4l-1.1 1.6C206.5 251.2 213 330 263 380c56.5 56.5 148 56.5 204.5 0L579.8 267.7zM60.2 244.3c-56.5 56.5-56.5 148 0 204.5c50 50 128.8 56.5 186.3 15.4l1.6-1.1c14.4-10.3 17.7-30.3 7.4-44.6s-30.3-17.7-44.6-7.4l-1.6 1.1c-32.1 22.9-76 19.3-103.8-8.6C74 372 74 321 105.5 289.5L217.7 177.2c31.5-31.5 82.5-31.5 114 0c27.9 27.9 31.5 71.8 8.6 103.9l-1.1 1.6c-10.3 14.4-6.9 34.4 7.4 44.6s34.4 6.9 44.6-7.4l1.1-1.6C433.5 260.8 427 182 377 132c-56.5-56.5-148-56.5-204.5 0L60.2 244.3z"
+);
+var FigmaSmileIcon = createToolbarIcon(
+  "FigmaSmileIcon",
+  512,
+  512,
+  "M464 256A208 208 0 1 0 48 256a208 208 0 1 0 416 0zM0 256a256 256 0 1 1 512 0A256 256 0 1 1 0 256zm177.6 62.1C192.8 334.5 218.8 352 256 352s63.2-17.5 78.4-33.9c9-9.7 24.2-10.4 33.9-1.4s10.4 24.2 1.4 33.9c-22 23.8-60 49.4-113.6 49.4s-91.7-25.5-113.6-49.4c-9-9.7-8.4-24.9 1.4-33.9s24.9-8.4 33.9 1.4zM144.4 208a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zm192-32a32 32 0 1 1 0 64 32 32 0 1 1 0-64z"
+);
+var FigmaAlignLeftIcon = createToolbarIcon(
+  "FigmaAlignLeftIcon",
+  448,
+  512,
+  "M288 64c0 17.7-14.3 32-32 32L32 96C14.3 96 0 81.7 0 64S14.3 32 32 32l224 0c17.7 0 32 14.3 32 32zm0 256c0 17.7-14.3 32-32 32L32 352c-17.7 0-32-14.3-32-32s14.3-32 32-32l224 0c17.7 0 32 14.3 32 32zM0 192c0-17.7 14.3-32 32-32l384 0c17.7 0 32 14.3 32 32s-14.3 32-32 32L32 224c-17.7 0-32-14.3-32-32zM448 448c0 17.7-14.3 32-32 32L32 480c-17.7 0-32-14.3-32-32s14.3-32 32-32l384 0c17.7 0 32 14.3 32 32z"
+);
+var FigmaListIcon = createToolbarIcon(
+  "FigmaListIcon",
+  512,
+  512,
+  "M64 144a48 48 0 1 0 0-96 48 48 0 1 0 0 96zM192 64c-17.7 0-32 14.3-32 32s14.3 32 32 32l288 0c17.7 0 32-14.3 32-32s-14.3-32-32-32L192 64zm0 160c-17.7 0-32 14.3-32 32s14.3 32 32 32l288 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-288 0zm0 160c-17.7 0-32 14.3-32 32s14.3 32 32 32l288 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-288 0zM64 464a48 48 0 1 0 0-96 48 48 0 1 0 0 96zm48-208a48 48 0 1 0-96 0 48 48 0 1 0 96 0z"
+);
+var FigmaQuoteIcon = createToolbarIcon(
+  "FigmaQuoteIcon",
+  448,
+  512,
+  "M0 216C0 149.7 53.7 96 120 96l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64l0-136zm256 0c0-66.3 53.7-120 120-120l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64l0-136z"
+);
+var FigmaImageIcon = createToolbarIcon(
+  "FigmaImageIcon",
+  512,
+  512,
+  "M0 96C0 60.7 28.7 32 64 32l384 0c35.3 0 64 28.7 64 64l0 320c0 35.3-28.7 64-64 64L64 480c-35.3 0-64-28.7-64-64L0 96zM323.8 202.5c-4.5-6.6-11.9-10.5-19.8-10.5s-15.4 3.9-19.8 10.5l-87 127.6L170.7 297c-4.6-5.7-11.5-9-18.7-9s-14.2 3.3-18.7 9l-64 80c-5.8 7.2-6.9 17.1-2.9 25.4s12.4 13.6 21.6 13.6l336 0c8.9 0 17.1-4.9 21.2-12.8s3.6-17.4-1.4-24.7l-120-176zM112 192a48 48 0 1 0 0-96 48 48 0 1 0 0 96z"
+);
+var FigmaTableIcon = createToolbarIcon(
+  "FigmaTableIcon",
+  512,
+  512,
+  "M64 256l0-96 160 0 0 96L64 256zm0 64l160 0 0 96L64 416l0-96zm224 96l0-96 160 0 0 96-160 0zM448 256l-160 0 0-96 160 0 0 96zM64 32C28.7 32 0 60.7 0 96L0 416c0 35.3 28.7 64 64 64l384 0c35.3 0 64-28.7 64-64l0-320c0-35.3-28.7-64-64-64L64 32z"
+);
+var FigmaUndoIcon = createToolbarIcon(
+  "FigmaUndoIcon",
+  512,
+  512,
+  "M48.5 224L40 224c-13.3 0-24-10.7-24-24L16 72c0-9.7 5.8-18.5 14.8-22.2s19.3-1.7 26.2 5.2l41.6 41.6c87.6-86.5 228.7-86.2 315.8 1c87.5 87.5 87.5 229.3 0 316.8s-229.3 87.5-316.8 0c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0c62.5 62.5 163.8 62.5 226.3 0s62.5-163.8 0-226.3c-62.2-62.2-162.7-62.5-225.3-1L185 183c6.9 6.9 8.9 17.2 5.2 26.2S177.7 224 168 224L48.5 224z"
+);
+var FigmaRedoIcon = createToolbarIcon(
+  "FigmaRedoIcon",
+  512,
+  512,
+  "M463.5 224l8.5 0c13.3 0 24-10.7 24-24l0-128c0-9.7-5.8-18.5-14.8-22.2s-19.3-1.7-26.2 5.2l-41.6 41.6c-87.6-86.5-228.7-86.2-315.8 1c-87.5 87.5-87.5 229.3 0 316.8s229.3 87.5 316.8 0c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0c-62.5 62.5-163.8 62.5-226.3 0s-62.5-163.8 0-226.3c62.2-62.2 162.7-62.5 225.3-1L327 183c-6.9 6.9-8.9 17.2-5.2 26.2S334.3 224 344 224l119.5 0z"
+);
+var FigmaHighlighterIcon = createToolbarIcon(
+  "FigmaHighlighterIcon",
+  576,
+  512,
+  "M315 315l158.4-215L444.1 70.6 229 229 315 315zm-187 5l0-71.7c0-15.3 7.2-29.6 19.5-38.6L420.6 8.4C428 2.9 437 0 446.2 0c11.4 0 22.4 4.5 30.5 12.6l54.8 54.8c8.1 8.1 12.6 19 12.6 30.5c0 9.2-2.9 18.2-8.4 25.6L334.4 396.5c-9 12.3-23.4 19.5-38.6 19.5L224 416l-25.4 25.4c-12.5 12.5-32.8 12.5-45.3 0l-50.7-50.7c-12.5-12.5-12.5-32.8 0-45.3L128 320zM7 466.3l63-63 70.6 70.6-31 31c-4.5 4.5-10.6 7-17 7L24 512c-13.3 0-24-10.7-24-24l0-4.7c0-6.4 2.5-12.5 7-17z"
+);
+
+// src/components/UEditor/colors.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var TextColorIcon = ({ color }) => {
+  const underlineColor = color && color !== "inherit" ? color : "currentColor";
+  return /* @__PURE__ */ jsxs4("span", { className: "relative flex h-5 w-5 items-center justify-center leading-none", children: [
+    /* @__PURE__ */ jsx6("span", { className: "text-[15px] font-semibold leading-none", children: "A" }),
+    /* @__PURE__ */ jsx6(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "absolute bottom-0 left-1/2 h-0.5 w-4 -translate-x-1/2 rounded-full",
+        style: { backgroundColor: underlineColor }
+      }
+    )
+  ] });
+};
+var HighlightColorIcon = ({ color }) => {
+  const underlineColor = color || "currentColor";
+  return /* @__PURE__ */ jsxs4("span", { className: "relative flex h-5 w-5 items-center justify-center leading-none", children: [
+    /* @__PURE__ */ jsx6(FigmaHighlighterIcon, { className: "h-4 w-4" }),
+    /* @__PURE__ */ jsx6(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "absolute bottom-0 left-1/2 h-0.5 w-4 -translate-x-1/2 rounded-full",
+        style: { backgroundColor: underlineColor }
+      }
+    )
+  ] });
+};
+var CellBgColorIcon = ({ color }) => {
+  const underlineColor = color && color !== "inherit" ? color : "currentColor";
+  return /* @__PURE__ */ jsxs4("span", { className: "relative flex h-5 w-5 items-center justify-center leading-none", children: [
+    /* @__PURE__ */ jsx6(Paintbrush, { className: "h-4 w-4" }),
+    /* @__PURE__ */ jsx6(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "absolute bottom-0 left-1/2 h-0.5 w-4 -translate-x-1/2 rounded-full",
+        style: { backgroundColor: underlineColor }
+      }
+    )
+  ] });
+};
+var CellBorderIcon = ({ color }) => {
+  const underlineColor = color && color !== "inherit" ? color : "currentColor";
+  return /* @__PURE__ */ jsxs4("span", { className: "relative flex h-5 w-5 items-center justify-center leading-none", children: [
+    /* @__PURE__ */ jsx6(Grid, { className: "h-4 w-4" }),
+    /* @__PURE__ */ jsx6(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "absolute bottom-0 left-1/2 h-0.5 w-4 -translate-x-1/2 rounded-full",
+        style: { backgroundColor: underlineColor }
+      }
+    )
+  ] });
+};
+var EDITOR_COLOR_SWATCHES = [
+  "#000000",
+  "#3f3f46",
+  "#713f12",
+  "#14532d",
+  "#164e63",
+  "#1e3a8a",
+  "#3730a3",
+  "#404040",
+  "#b91c1c",
+  "#c2410c",
+  "#a16207",
+  "#15803d",
+  "#0f766e",
+  "#2563eb",
+  "#4f46e5",
+  "#737373",
+  "#ef4444",
+  "#f97316",
+  "#eab308",
+  "#22c55e",
+  "#14b8a6",
+  "#3b82f6",
+  "#7c3aed",
+  "#a3a3a3",
+  "#f43f5e",
+  "#f59e0b",
+  "#facc15",
+  "#00e676",
+  "#22d3ee",
+  "#06b6d4",
+  "#be185d",
+  "#bdbdbd",
+  "#f9a8d4",
+  "#fecaca",
+  "#fde68a",
+  "#bbf7d0",
+  "#a7f3d0",
+  "#bae6fd",
+  "#c4b5fd",
+  "#f5f5f5"
+];
+var HIGHLIGHT_COLOR_SWATCHES = [
+  "#fef08a",
+  "#fde68a",
+  "#fed7aa",
+  "#fecaca",
+  "#fbcfe8",
+  "#e9d5ff",
+  "#c7d2fe",
+  "#bfdbfe",
+  "#bae6fd",
+  "#ccfbf1",
+  "#bbf7d0",
+  "#d9f99d",
+  "#e5e7eb",
+  "#fca5a5",
+  "#fdba74",
+  "#facc15",
+  "#86efac",
+  "#5eead4",
+  "#7dd3fc",
+  "#a5b4fc",
+  "#d8b4fe",
+  "#f0abfc",
+  "#f9a8d4",
+  "#d4d4d4"
+];
+function buildColorOptions(colors, prefix) {
+  return colors.map((color, index) => ({ name: `${prefix} ${index + 1}`, color }));
+}
+function getSwatchCheckClass(color) {
+  return /^#(?:fff|ffffff)$/i.test(color) ? "text-foreground" : "text-white drop-shadow-[0_1px_1px_rgba(0,0,0,0.8)]";
+}
+var useEditorColors = () => {
+  const t = useSmartTranslations("UEditor");
+  const textColors = useMemo2(
+    () => [
+      { name: t("colors.default"), color: "inherit", cssClass: "text-foreground" },
+      { name: t("colors.muted"), color: "var(--muted-foreground)", cssClass: "text-muted-foreground" },
+      { name: t("colors.primary"), color: "var(--primary)", cssClass: "text-primary" },
+      { name: t("colors.secondary"), color: "var(--secondary)", cssClass: "text-secondary" },
+      { name: t("colors.success"), color: "var(--success)", cssClass: "text-success" },
+      { name: t("colors.warning"), color: "var(--warning)", cssClass: "text-warning" },
+      { name: t("colors.destructive"), color: "var(--destructive)", cssClass: "text-destructive" },
+      { name: t("colors.info"), color: "var(--info)", cssClass: "text-info" },
+      ...buildColorOptions(EDITOR_COLOR_SWATCHES, t("colors.color"))
+    ],
+    [t]
+  );
+  const highlightColors = useMemo2(
+    () => [
+      { name: t("colors.default"), color: "", cssClass: "" },
+      { name: t("colors.muted"), color: "var(--muted)", cssClass: "bg-muted" },
+      { name: t("colors.primary"), color: "color-mix(in oklch, var(--primary) 20%, transparent)", cssClass: "bg-primary/20" },
+      { name: t("colors.secondary"), color: "color-mix(in oklch, var(--secondary) 20%, transparent)", cssClass: "bg-secondary/20" },
+      { name: t("colors.success"), color: "color-mix(in oklch, var(--success) 20%, transparent)", cssClass: "bg-success/20" },
+      { name: t("colors.warning"), color: "color-mix(in oklch, var(--warning) 20%, transparent)", cssClass: "bg-warning/20" },
+      { name: t("colors.destructive"), color: "color-mix(in oklch, var(--destructive) 20%, transparent)", cssClass: "bg-destructive/20" },
+      { name: t("colors.info"), color: "color-mix(in oklch, var(--info) 20%, transparent)", cssClass: "bg-info/20" },
+      { name: t("colors.accent"), color: "var(--accent)", cssClass: "bg-accent" },
+      ...buildColorOptions(HIGHLIGHT_COLOR_SWATCHES, t("colors.color"))
+    ],
+    [t]
+  );
+  return { textColors, highlightColors };
+};
+var EditorColorPalette = ({
+  colors,
+  currentColor,
+  onSelect,
+  label
+}) => {
+  const t = useSmartTranslations("UEditor");
+  const colorInputRef = useRef3(null);
+  const automaticColor = colors[0]?.color ?? "";
+  const paletteColors = colors.slice(1);
+  return /* @__PURE__ */ jsxs4("div", { className: "w-56 p-2", children: [
+    /* @__PURE__ */ jsx6("span", { className: "px-1 text-[11px] font-semibold uppercase tracking-wide text-muted-foreground", children: label }),
+    /* @__PURE__ */ jsxs4(
+      "button",
+      {
+        type: "button",
+        onMouseDown: (e) => e.preventDefault(),
+        onClick: () => onSelect(automaticColor),
+        className: cn(
+          "mt-2 flex h-9 w-full items-center gap-3 rounded-md border px-2 text-sm transition-colors",
+          "bg-muted/50 hover:bg-muted",
+          currentColor === automaticColor ? "border-primary text-primary" : "border-transparent text-foreground"
+        ),
+        children: [
+          /* @__PURE__ */ jsx6("span", { className: "flex h-5 w-5 items-center justify-center rounded border border-border bg-background", children: currentColor === automaticColor && /* @__PURE__ */ jsx6(Check2, { className: "h-3.5 w-3.5" }) }),
+          /* @__PURE__ */ jsx6("span", { className: "flex-1 text-center", children: t("colors.automatic") })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx6("div", { className: "mt-2 grid grid-cols-8 gap-1", children: paletteColors.map((c) => /* @__PURE__ */ jsx6(Tooltip, { placement: "top", content: /* @__PURE__ */ jsx6("span", { className: "text-xs font-medium", children: c.name }), children: /* @__PURE__ */ jsx6(
+      "button",
+      {
+        type: "button",
+        "aria-label": c.name,
+        onMouseDown: (e) => e.preventDefault(),
+        onClick: () => onSelect(c.color),
+        className: cn(
+          "relative h-5 w-5 rounded-[3px] border transition-transform hover:scale-110",
+          currentColor === c.color ? "border-primary ring-2 ring-primary/25" : "border-border/70"
+        ),
+        style: { backgroundColor: c.color || "transparent" },
+        children: currentColor === c.color && /* @__PURE__ */ jsx6("span", { className: "absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ jsx6(Check2, { className: cn("h-3.5 w-3.5", getSwatchCheckClass(c.color)) }) })
+      }
+    ) }, `${c.name}-${c.color}`)) }),
+    /* @__PURE__ */ jsxs4(
+      "button",
+      {
+        type: "button",
+        onMouseDown: (e) => e.preventDefault(),
+        onClick: () => colorInputRef.current?.click(),
+        className: "mt-3 flex h-9 w-full items-center gap-3 rounded-md px-2 text-sm text-foreground transition-colors hover:bg-muted",
+        children: [
+          /* @__PURE__ */ jsx6(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "h-5 w-5 rounded border border-border",
+              style: {
+                background: "linear-gradient(135deg, #ff004c 0%, #fffb00 22%, #00ff66 42%, #00d5ff 62%, #2446ff 78%, #ff00d4 100%)"
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx6("span", { className: "flex-1 text-center", children: t("colors.moreColors") }),
+          /* @__PURE__ */ jsx6(Palette, { className: "h-4 w-4 text-muted-foreground" }),
+          /* @__PURE__ */ jsx6(
+            "input",
+            {
+              ref: colorInputRef,
+              type: "color",
+              value: currentColor.startsWith("#") ? currentColor : "#000000",
+              onChange: (event) => onSelect(event.target.value),
+              className: "sr-only",
+              tabIndex: -1
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+// src/components/UEditor/image-commands.ts
+import { NodeSelection, TextSelection as TextSelection2 } from "@tiptap/pm/state";
+var IMAGE_WIDTHS_BY_LAYOUT = {
+  block: {
+    sm: 180,
+    md: 280,
+    lg: 380
+  },
+  wrap: {
+    sm: 140,
+    md: 200,
+    lg: 260
+  }
+};
+function isSelectedImage(editor) {
+  const { selection } = editor.state;
+  return selection instanceof NodeSelection && selection.node.type.name === "image";
+}
+function toPositiveNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+  }
+  return null;
+}
+function getImageElementAtSelection(editor, pos) {
+  const nodeDom = editor.view.nodeDOM(pos);
+  if (!(nodeDom instanceof HTMLElement)) return null;
+  if (nodeDom.tagName === "IMG") return nodeDom;
+  return nodeDom.querySelector("img");
+}
+function getImageAspectRatio(editor, attrs, pos) {
+  const widthAttr = toPositiveNumber(attrs.width);
+  const heightAttr = toPositiveNumber(attrs.height);
+  if (widthAttr && heightAttr) return widthAttr / heightAttr;
+  const imageElement = typeof pos === "number" ? getImageElementAtSelection(editor, pos) : null;
+  if (!imageElement) return null;
+  if (imageElement.naturalWidth > 0 && imageElement.naturalHeight > 0) {
+    return imageElement.naturalWidth / imageElement.naturalHeight;
+  }
+  const rect = imageElement.getBoundingClientRect();
+  if (rect.width > 0 && rect.height > 0) return rect.width / rect.height;
+  const width = toPositiveNumber(imageElement.getAttribute("width")) ?? toPositiveNumber(imageElement.style.width);
+  const height = toPositiveNumber(imageElement.getAttribute("height")) ?? toPositiveNumber(imageElement.style.height);
+  return width && height ? width / height : null;
+}
+function getImagePresetAttributes(editor, width, preset, attrs, pos) {
+  const aspect = getImageAspectRatio(editor, attrs, pos);
+  return {
+    width,
+    height: aspect ? Math.round(width / aspect) : toPositiveNumber(attrs.height),
+    imageWidthPreset: preset
+  };
+}
+function applyImageLayout(editor, layout) {
+  const { state, view } = editor;
+  const { selection, schema } = state;
+  if (!(selection instanceof NodeSelection) || selection.node.type.name !== "image") {
+    editor.chain().focus().updateAttributes("image", { imageLayout: layout }).run();
+    return;
+  }
+  let transaction = state.tr.setNodeMarkup(selection.from, void 0, {
+    ...selection.node.attrs,
+    imageLayout: layout
+  });
+  if (layout !== "block") {
+    const nextPos = transaction.mapping.map(selection.to);
+    const nextNode = transaction.doc.nodeAt(nextPos);
+    if (!nextNode || nextNode.type.name !== "paragraph") {
+      const paragraph = schema.nodes.paragraph?.create();
+      if (paragraph) {
+        transaction = transaction.insert(nextPos, paragraph);
+      }
+    }
+    const resolvedPos = transaction.doc.resolve(Math.min(nextPos + 1, transaction.doc.content.size));
+    transaction = transaction.setSelection(TextSelection2.near(resolvedPos));
+  } else {
+    const resolvedPos = transaction.doc.resolve(selection.from);
+    transaction = transaction.setSelection(NodeSelection.create(transaction.doc, resolvedPos.pos));
+  }
+  view.dispatch(transaction.scrollIntoView());
+  view.focus();
+}
+function applyImageWidthPreset(editor, preset) {
+  const attrs = editor.getAttributes("image");
+  const mode = attrs.imageLayout === "left" || attrs.imageLayout === "right" ? "wrap" : "block";
+  const width = IMAGE_WIDTHS_BY_LAYOUT[mode][preset];
+  if (!isSelectedImage(editor)) {
+    editor.chain().focus().updateAttributes("image", getImagePresetAttributes(editor, width, preset, attrs)).run();
+    return;
+  }
+  const { state, view } = editor;
+  const selection = state.selection;
+  const nextAttrs = getImagePresetAttributes(editor, width, preset, selection.node.attrs, selection.from);
+  const transaction = state.tr.setNodeMarkup(selection.from, void 0, {
+    ...selection.node.attrs,
+    ...nextAttrs
+  });
+  view.dispatch(transaction.scrollIntoView());
+  view.focus();
+}
+function resetImageSize(editor) {
+  if (!isSelectedImage(editor)) {
+    editor.chain().focus().updateAttributes("image", {
+      width: null,
+      height: null,
+      imageWidthPreset: null
+    }).run();
+    return;
+  }
+  const { state, view } = editor;
+  const selection = state.selection;
+  const transaction = state.tr.setNodeMarkup(selection.from, void 0, {
+    ...selection.node.attrs,
+    width: null,
+    height: null,
+    imageWidthPreset: null
+  });
+  view.dispatch(transaction.scrollIntoView());
+  view.focus();
+}
+function deleteSelectedImage(editor) {
+  if (!isSelectedImage(editor)) return;
+  editor.chain().focus().deleteSelection().run();
+}
+
+// src/components/UEditor/table-dom-utils.ts
+var DEFAULT_TABLE_ROW_HEIGHT = 25;
+var MIN_TABLE_ROW_HEIGHT = DEFAULT_TABLE_ROW_HEIGHT;
+var COLUMN_RESIZE_LINE_THICKNESS = 2;
+var ROW_RESIZE_LINE_THICKNESS = 2;
+var UEDITOR_TABLE_LAYOUT_CHANGE_EVENT = "ueditor-table-layout-change";
+var TABLE_RESIZE_HIT_ZONE = 10;
+function findTableRowNodeInfo(view, rowElement) {
+  const firstCell = rowElement.querySelector("th,td");
+  if (!firstCell) return null;
+  const cellPos = view.posAtDOM(firstCell, 0);
+  const $pos = view.state.doc.resolve(cellPos);
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type.name === "tableRow") {
+      return {
+        pos: $pos.before(depth),
+        node
+      };
+    }
+  }
+  return null;
+}
+function resolveEventElement(target) {
+  if (target instanceof Element) return target;
+  if (target instanceof Node) return target.parentElement;
+  return null;
+}
+function isPointOverRenderedText(root, clientX, clientY) {
+  const view = root.ownerDocument.defaultView;
+  if (!view) return false;
+  const walker = root.ownerDocument.createTreeWalker(root, view.NodeFilter.SHOW_TEXT);
+  let textNode = walker.nextNode();
+  while (textNode) {
+    if (textNode.textContent?.length) {
+      const range = root.ownerDocument.createRange();
+      range.selectNodeContents(textNode);
+      const textRects = Array.from(range.getClientRects());
+      range.detach?.();
+      if (textRects.some((rect) => clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom)) {
+        return true;
+      }
+    }
+    textNode = walker.nextNode();
+  }
+  return false;
+}
+function getSelectionTableCell(view) {
+  const browserSelection = window.getSelection();
+  const anchorElement = resolveEventElement(browserSelection?.anchorNode ?? null);
+  const anchorCell = anchorElement?.closest?.("th,td");
+  if (anchorCell instanceof HTMLElement) {
+    return anchorCell;
+  }
+  const { from } = view.state.selection;
+  const domAtPos = view.domAtPos(from);
+  const element = resolveEventElement(domAtPos.node);
+  const cell = element?.closest?.("th,td");
+  return cell instanceof HTMLElement ? cell : null;
+}
+function isRowResizeHotspot(cell, clientX, clientY) {
+  const rect = cell.getBoundingClientRect();
+  const nearBottom = rect.bottom - clientY <= TABLE_RESIZE_HIT_ZONE;
+  const nearRight = rect.right - clientX <= TABLE_RESIZE_HIT_ZONE;
+  return nearBottom && !nearRight;
+}
+function isColumnResizeHotspot(cell, clientX, clientY) {
+  const rect = cell.getBoundingClientRect();
+  const nearRight = rect.right - clientX <= TABLE_RESIZE_HIT_ZONE;
+  const nearBottom = rect.bottom - clientY <= TABLE_RESIZE_HIT_ZONE;
+  return nearRight && !nearBottom;
+}
+function getRelativeBoundaryMetrics(surface, table, row, cell) {
+  const surfaceRect = surface.getBoundingClientRect();
+  const tableRect = table.getBoundingClientRect();
+  const rowRect = row.getBoundingClientRect();
+  const cellRect = cell.getBoundingClientRect();
+  return {
+    left: tableRect.left - surfaceRect.left + surface.scrollLeft,
+    top: tableRect.top - surfaceRect.top + surface.scrollTop,
+    width: tableRect.width,
+    height: tableRect.height,
+    rowBottom: rowRect.bottom - surfaceRect.top + surface.scrollTop,
+    columnRight: cellRect.right - surfaceRect.left + surface.scrollLeft
+  };
+}
+function getRelativeCellMetrics(surface, cell) {
+  const surfaceRect = surface.getBoundingClientRect();
+  const cellRect = cell.getBoundingClientRect();
+  return {
+    left: cellRect.left - surfaceRect.left + surface.scrollLeft,
+    top: cellRect.top - surfaceRect.top + surface.scrollTop,
+    width: cellRect.width,
+    height: cellRect.height
+  };
+}
+function getRelativeSelectedCellsMetrics(surface) {
+  const selectedCells = Array.from(
+    surface.querySelectorAll("td.selectedCell, th.selectedCell")
+  );
+  if (selectedCells.length === 0) {
+    return null;
+  }
+  const surfaceRect = surface.getBoundingClientRect();
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  selectedCells.forEach((cell) => {
+    const rect = cell.getBoundingClientRect();
+    left = Math.min(left, rect.left);
+    top = Math.min(top, rect.top);
+    right = Math.max(right, rect.right);
+    bottom = Math.max(bottom, rect.bottom);
+  });
+  return {
+    left: left - surfaceRect.left + surface.scrollLeft,
+    top: top - surfaceRect.top + surface.scrollTop,
+    width: right - left,
+    height: bottom - top
+  };
+}
+
+// src/components/UEditor/table-align-utils.ts
+function findTableNodeInfoAtResolvedPos($pos) {
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type.name === "table") {
+      return {
+        depth,
+        pos: $pos.before(depth),
+        node
+      };
+    }
+  }
+  return null;
+}
+function findTableNodeInfoFromState(state, anchorPos) {
+  if (typeof anchorPos === "number" && Number.isFinite(anchorPos)) {
+    const safePos = Math.max(0, Math.min(anchorPos, state.doc.content.size));
+    return findTableNodeInfoAtResolvedPos(state.doc.resolve(safePos));
+  }
+  return findTableNodeInfoAtResolvedPos(state.selection.$from);
+}
+function applyTableAlignment(editor, tableAlign, anchorPos) {
+  const tableInfo = findTableNodeInfoFromState(editor.state, anchorPos);
+  if (!tableInfo) return false;
+  editor.view.dispatch(
+    editor.state.tr.setNodeMarkup(tableInfo.pos, tableInfo.node.type, {
+      ...tableInfo.node.attrs,
+      textAlign: tableAlign
+    })
+  );
+  const domAtTable = editor.view.domAtPos(Math.min(tableInfo.pos + 1, editor.state.doc.content.size)).node;
+  const domAtTableElement = resolveEventElement(domAtTable);
+  const tableDom = editor.view.nodeDOM(tableInfo.pos);
+  const tableElement = domAtTableElement?.closest?.("table") ?? (tableDom instanceof HTMLTableElement ? tableDom : tableDom instanceof HTMLElement ? tableDom.querySelector("table") : null) ?? (editor.view.dom.querySelectorAll("table").length === 1 ? editor.view.dom.querySelector("table") : null);
+  if (tableElement instanceof HTMLTableElement) {
+    if (tableAlign) {
+      tableElement.setAttribute("data-table-align", tableAlign);
+      tableElement.style.width = "max-content";
+      tableElement.style.maxWidth = "100%";
+      tableElement.style.marginLeft = tableAlign === "center" || tableAlign === "right" ? "auto" : "0";
+      tableElement.style.marginRight = tableAlign === "center" ? "auto" : tableAlign === "right" ? "0" : "auto";
+    } else {
+      tableElement.removeAttribute("data-table-align");
+      tableElement.style.removeProperty("width");
+      tableElement.style.removeProperty("max-width");
+      tableElement.style.removeProperty("margin-left");
+      tableElement.style.removeProperty("margin-right");
+    }
+  }
+  return true;
+}
+
+// src/components/UEditor/table-cell-commands.ts
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+import { selectedRect, TableMap } from "@tiptap/pm/tables";
+function getCellSelectionPositions(selection) {
+  const value = selection;
+  const anchor = value.$anchorCell?.pos;
+  const head = value.$headCell?.pos;
+  return typeof anchor === "number" && typeof head === "number" ? { anchor, head } : null;
+}
+function findTableInfoFromCellPos(editor, cellPos) {
+  const $pos = editor.state.doc.resolve(cellPos);
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type.name === "table") {
+      return {
+        table: node,
+        tablePos: $pos.before(depth),
+        tableStart: $pos.start(depth)
+      };
+    }
+  }
+  return null;
+}
+function getFocusableCellPos(editor, cellPos) {
+  const cellNode = editor.state.doc.nodeAt(cellPos);
+  if (!cellNode) return cellPos + 1;
+  let offset = cellPos + 1;
+  let node = cellNode.firstChild ?? null;
+  while (node && !node.isTextblock) {
+    offset += 1;
+    node = node.firstChild ?? null;
+  }
+  return node?.isTextblock ? offset + 1 : cellPos + 1;
+}
+function focusCell(editor, cellPos) {
+  const selection = TextSelection3.near(editor.state.doc.resolve(getFocusableCellPos(editor, cellPos)));
+  editor.view.dispatch(editor.state.tr.setSelection(selection));
+  editor.view.focus();
+}
+function collectChildren(node) {
+  const children = [];
+  node.forEach((child) => children.push(child));
+  return children;
+}
+function createEmptyCellNode(cellNode) {
+  return cellNode.type.createAndFill(cellNode.attrs) ?? cellNode;
+}
+function createCellCopyForColumnDuplicate(cellNode) {
+  return cellNode.type.create(cellNode.attrs, cellNode.content);
+}
+function createCellWithDuplicatedLogicalColumn(cellNode, widthIndex) {
+  const colspan = Math.max(1, Number(cellNode.attrs.colspan) || 1);
+  let nextColwidth = null;
+  if (Array.isArray(cellNode.attrs.colwidth)) {
+    nextColwidth = [...cellNode.attrs.colwidth];
+    const duplicateWidth = nextColwidth[widthIndex];
+    nextColwidth.splice(widthIndex + 1, 0, typeof duplicateWidth === "number" ? duplicateWidth : 0);
+  }
+  return cellNode.type.create({
+    ...cellNode.attrs,
+    colspan: colspan + 1,
+    ...nextColwidth ? { colwidth: nextColwidth } : null
+  }, cellNode.content);
+}
+function getTableRows(tableNode) {
+  const rows = [];
+  tableNode.forEach((rowNode, rowOffset) => {
+    const cells = [];
+    rowNode.forEach((cellNode, cellOffset, index) => {
+      cells.push({
+        index,
+        node: cellNode,
+        relativePos: rowOffset + 1 + cellOffset
+      });
+    });
+    rows.push({
+      node: rowNode,
+      cells
+    });
+  });
+  return rows;
+}
+function safeFindCell(map, relativePos) {
+  try {
+    return map.findCell(relativePos);
+  } catch {
+    return null;
+  }
+}
+function getSelectedTableRect(editor) {
+  const cellSelection = getCellSelectionPositions(editor.state.selection);
+  if (cellSelection) {
+    const tableInfo = findTableInfoFromCellPos(editor, cellSelection.anchor);
+    if (tableInfo) {
+      const map = TableMap.get(tableInfo.table);
+      const rect = map.rectBetween(
+        cellSelection.anchor - tableInfo.tableStart,
+        cellSelection.head - tableInfo.tableStart
+      );
+      return {
+        ...rect,
+        map,
+        table: tableInfo.table,
+        tableStart: tableInfo.tableStart
+      };
+    }
+  }
+  return selectedRect(editor.state);
+}
+function parsePixelWidth(value) {
+  if (!value) return null;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed) : null;
+}
+function getDomColumnWidths(editor, rect) {
+  const tableDom = editor.view.nodeDOM(rect.tableStart - 1);
+  if (!(tableDom instanceof HTMLTableElement)) return null;
+  const cols = Array.from(tableDom.querySelectorAll("colgroup > col"));
+  if (cols.length === 0) return null;
+  const widths = [];
+  for (let col = rect.left; col < rect.right; col += 1) {
+    const colElement = cols[col];
+    if (!colElement) return null;
+    const width = parsePixelWidth(colElement.style.width) ?? parsePixelWidth(colElement.getAttribute("width")) ?? Math.round(colElement.getBoundingClientRect().width);
+    if (!Number.isFinite(width) || width <= 0) return null;
+    widths.push(width);
+  }
+  return widths.length > 0 ? widths : null;
+}
+function getNodeColumnWidths(rect) {
+  const widths = [];
+  for (let col = rect.left; col < rect.right; col += 1) {
+    let width = null;
+    const seen = /* @__PURE__ */ new Set();
+    for (let row = 0; row < rect.map.height && width == null; row += 1) {
+      const cellPos = rect.map.map[row * rect.map.width + col];
+      if (seen.has(cellPos)) continue;
+      seen.add(cellPos);
+      const cell = rect.table.nodeAt(cellPos);
+      const colwidth = cell?.attrs.colwidth;
+      if (!Array.isArray(colwidth)) continue;
+      const cellLeft = rect.map.colCount(cellPos);
+      const widthIndex = col - cellLeft;
+      const candidate = colwidth[widthIndex];
+      if (typeof candidate === "number" && candidate > 0) {
+        width = candidate;
+      }
+    }
+    if (width == null) return null;
+    widths.push(width);
+  }
+  return widths.length > 0 ? widths : null;
+}
+function getSelectedColumnWidths(editor, rect) {
+  return getDomColumnWidths(editor, rect) ?? getNodeColumnWidths(rect);
+}
+function dispatchTableLayoutChange(editor) {
+  editor.view.dom.dispatchEvent(new CustomEvent(UEDITOR_TABLE_LAYOUT_CHANGE_EVENT, { bubbles: true }));
+}
+function mergeTableCellsPreservingColumnWidths(editor) {
+  const rect = getSelectedTableRect(editor);
+  const widths = getSelectedColumnWidths(editor, rect);
+  const merged = editor.chain().focus().mergeCells().run();
+  if (!merged) return merged;
+  if (!widths) {
+    dispatchTableLayoutChange(editor);
+    return merged;
+  }
+  const nextRect = getSelectedTableRect(editor);
+  const cellPos = nextRect.map.map[nextRect.top * nextRect.map.width + nextRect.left];
+  const absolutePos = nextRect.tableStart + cellPos;
+  const node = editor.state.doc.nodeAt(absolutePos);
+  if (!node) return merged;
+  editor.view.dispatch(
+    editor.state.tr.setNodeMarkup(absolutePos, node.type, {
+      ...node.attrs,
+      colwidth: widths
+    })
+  );
+  dispatchTableLayoutChange(editor);
+  return true;
+}
+function runTableCommandAtCellPos(editor, cellPos, command) {
+  if (cellPos == null) return false;
+  focusCell(editor, cellPos);
+  return command(editor.chain().focus(null, { scrollIntoView: false })).run();
+}
+function getTableCornerCellPos(editor, activePos) {
+  const tableInfo = findTableInfoFromCellPos(editor, activePos);
+  if (!tableInfo) return null;
+  const map = TableMap.get(tableInfo.table);
+  return tableInfo.tableStart + map.positionAt(map.height - 1, map.width - 1, tableInfo.table);
+}
+function replaceTableAtCellPos(editor, cellPos, updateTable) {
+  if (cellPos == null) return false;
+  const tableInfo = findTableInfoFromCellPos(editor, cellPos);
+  if (!tableInfo) return false;
+  const nextTable = updateTable(tableInfo.table);
+  if (!nextTable) return false;
+  editor.view.dispatch(editor.state.tr.replaceWith(tableInfo.tablePos, tableInfo.tablePos + tableInfo.table.nodeSize, nextTable));
+  dispatchTableLayoutChange(editor);
+  return true;
+}
+function duplicateTableRowAt(editor, rowIndex, cellPos) {
+  return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
+    const rows = collectChildren(tableNode);
+    const rowNode = rows[rowIndex];
+    if (!rowNode) return null;
+    rows.splice(rowIndex + 1, 0, rowNode.copy(rowNode.content));
+    return tableNode.type.create(tableNode.attrs, rows);
+  });
+}
+function clearTableRowAt(editor, rowIndex, cellPos) {
+  return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
+    const map = TableMap.get(tableNode);
+    if (rowIndex < 0 || rowIndex >= map.height) return null;
+    const rows = getTableRows(tableNode).map((rowInfo) => {
+      const cells = collectChildren(rowInfo.node);
+      for (const entry of rowInfo.cells) {
+        const rect = safeFindCell(map, entry.relativePos);
+        if (!rect || rect.top > rowIndex || rowIndex >= rect.bottom) continue;
+        cells[entry.index] = createEmptyCellNode(entry.node);
+      }
+      return rowInfo.node.type.create(rowInfo.node.attrs, cells);
+    });
+    return tableNode.type.create(tableNode.attrs, rows);
+  });
+}
+function duplicateTableColumnAt(editor, columnIndex, cellPos) {
+  return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
+    const map = TableMap.get(tableNode);
+    if (columnIndex < 0 || columnIndex >= map.width) return null;
+    const rows = getTableRows(tableNode).map((rowInfo, rowIndex) => {
+      const cells = collectChildren(rowInfo.node);
+      const sourceCell = rowInfo.cells.find((entry) => {
+        const rect = safeFindCell(map, entry.relativePos);
+        return rect && rect.top === rowIndex && rect.left <= columnIndex && columnIndex < rect.right;
+      });
+      if (!sourceCell) return rowInfo.node;
+      const sourceRect = safeFindCell(map, sourceCell.relativePos);
+      if (sourceRect && (sourceRect.left < columnIndex || sourceRect.right > columnIndex + 1)) {
+        cells[sourceCell.index] = createCellWithDuplicatedLogicalColumn(sourceCell.node, columnIndex - sourceRect.left);
+        return rowInfo.node.type.create(rowInfo.node.attrs, cells);
+      }
+      cells.splice(sourceCell.index + 1, 0, createCellCopyForColumnDuplicate(sourceCell.node));
+      return rowInfo.node.type.create(rowInfo.node.attrs, cells);
+    });
+    return tableNode.type.create(tableNode.attrs, rows);
+  });
+}
+function clearTableColumnAt(editor, columnIndex, cellPos) {
+  return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
+    const map = TableMap.get(tableNode);
+    if (columnIndex < 0 || columnIndex >= map.width) return null;
+    const rows = getTableRows(tableNode).map((rowInfo) => {
+      const cells = collectChildren(rowInfo.node);
+      for (const entry of rowInfo.cells) {
+        const rect = safeFindCell(map, entry.relativePos);
+        if (!rect || rect.left > columnIndex || columnIndex >= rect.right) continue;
+        cells[entry.index] = createEmptyCellNode(entry.node);
+      }
+      return rowInfo.node.type.create(rowInfo.node.attrs, cells);
+    });
+    return tableNode.type.create(tableNode.attrs, rows);
+  });
+}
+function expandTableFromCell(editor, activeCellPos, rows, columns) {
+  let cornerCellPos = getTableCornerCellPos(editor, activeCellPos);
+  if (cornerCellPos == null) return false;
+  for (let index = 0; index < rows; index += 1) {
+    const ok = runTableCommandAtCellPos(editor, cornerCellPos, (chain) => chain.addRowAfter());
+    if (!ok) return false;
+    cornerCellPos = getTableCornerCellPos(editor, cornerCellPos);
+    if (cornerCellPos == null) return false;
+  }
+  for (let index = 0; index < columns; index += 1) {
+    const ok = runTableCommandAtCellPos(editor, cornerCellPos, (chain) => chain.addColumnAfter());
+    if (!ok) return false;
+    cornerCellPos = getTableCornerCellPos(editor, cornerCellPos);
+    if (cornerCellPos == null) return false;
+  }
+  dispatchTableLayoutChange(editor);
+  return true;
+}
+
+// src/components/UEditor/typography-options.ts
+function normalizeStyleValue(value) {
+  return typeof value === "string" ? value.trim().replace(/^['"]|['"]$/g, "") : "";
+}
+function getDefaultFontFamilies(t) {
+  return [
+    { label: "Inter", value: '"Inter", "Noto Sans", "Noto Sans CJK KR", "Noto Sans CJK JP", "Segoe UI", sans-serif' },
+    { label: "\uAD74\uB9BC", value: '"Gulim", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif' },
+    { label: "\uAD74\uB9BC\uCCB4", value: '"GulimChe", "Gulim", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif' },
+    { label: "\uAD81\uC11C", value: '"Gungsuh", "Nanum Myeongjo", serif' },
+    { label: "\uAD81\uC11C\uCCB4", value: '"GungsuhChe", "Gungsuh", "Nanum Myeongjo", serif' },
+    { label: "\uB3CB\uC6C0", value: '"Dotum", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif' },
+    { label: "\uB3CB\uC6C0\uCCB4", value: '"DotumChe", "Dotum", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif' },
+    { label: "\uBC14\uD0D5", value: '"Batang", "Nanum Myeongjo", serif' },
+    { label: "\uBC14\uD0D5\uCCB4", value: '"BatangChe", "Batang", "Nanum Myeongjo", serif' },
+    { label: "\uB9D1\uC740\uACE0\uB515", value: '"Malgun Gothic", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif' },
+    { label: "\uB098\uB214\uBA85\uC870", value: '"Nanum Myeongjo", "Batang", serif' },
+    { label: "System UI", value: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif' },
+    { label: "Roboto", value: '"Roboto", "Noto Sans", "Apple SD Gothic Neo", "Hiragino Kaku Gothic ProN", sans-serif' },
+    { label: "Lexend", value: '"Lexend", "Be Vietnam Pro", "Segoe UI", sans-serif' },
+    { label: "Montserrat", value: '"Montserrat", "Segoe UI", sans-serif' },
+    { label: "Lora", value: '"Lora", "Georgia", "Times New Roman", "Nanum Myeongjo", "BIZ UDPMincho", serif' },
+    { label: "Playfair Display", value: '"Playfair Display", "Times New Roman", "Nanum Myeongjo", serif' },
+    { label: "Georgia", value: 'Georgia, "Nanum Myeongjo", "Batang", "Times New Roman", serif' },
+    { label: "Times New Roman", value: '"Times New Roman", Times, "BIZ UDPMincho", serif' },
+    { label: "Meiryo (JA)", value: '"Meiryo", "Hiragino Sans", "Noto Sans JP", sans-serif' },
+    { label: "Apple SD Gothic Neo (KO)", value: '"Apple SD Gothic Neo", "Malgun Gothic", "Noto Sans KR", sans-serif' },
+    { label: "JetBrains Mono", value: '"JetBrains Mono", "Fira Code", "SFMono-Regular", Consolas, "Noto Sans Mono CJK KR", "Noto Sans Mono CJK JP", monospace' }
+  ];
+}
+function getDefaultFontSizes() {
+  return [
+    { label: "8", value: "8px" },
+    { label: "9", value: "9px" },
+    { label: "10", value: "10px" },
+    { label: "11", value: "11px" },
+    { label: "12", value: "12px" },
+    { label: "13", value: "13px" },
+    { label: "14", value: "14px" },
+    { label: "15", value: "15px" },
+    { label: "16", value: "16px" },
+    { label: "17", value: "17px" },
+    { label: "18", value: "18px" },
+    { label: "19", value: "19px" },
+    { label: "20", value: "20px" },
+    { label: "21", value: "21px" },
+    { label: "22", value: "22px" },
+    { label: "23", value: "23px" },
+    { label: "24", value: "24px" },
+    { label: "25", value: "25px" },
+    { label: "26", value: "26px" },
+    { label: "27", value: "27px" },
+    { label: "28", value: "28px" },
+    { label: "36", value: "36px" },
+    { label: "48", value: "48px" },
+    { label: "72", value: "72px" },
+    { label: "96", value: "96px" }
+  ];
+}
+function getDefaultLineHeights() {
+  return [
+    { label: "1.2", value: "1.2" },
+    { label: "1.5", value: "1.5" },
+    { label: "1.75", value: "1.75" },
+    { label: "2", value: "2" }
+  ];
+}
+function getDefaultLetterSpacings() {
+  return [
+    { label: "-0.02em", value: "-0.02em" },
+    { label: "0", value: "0" },
+    { label: "0.02em", value: "0.02em" },
+    { label: "0.05em", value: "0.05em" },
+    { label: "0.08em", value: "0.08em" }
+  ];
+}
+
+// src/components/UEditor/toolbar.tsx
+import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function getTableAnchorPos(editor) {
+  const tableInfo = findTableNodeInfoFromState(editor.state);
+  if (tableInfo) return editor.state.selection.from;
+  const selectionAnchor = resolveEventElement(window.getSelection()?.anchorNode ?? null);
+  const selectionCell = selectionAnchor?.closest?.("th,td");
+  if (selectionCell instanceof HTMLTableCellElement && editor.view.dom.contains(selectionCell)) {
+    return editor.view.posAtDOM(selectionCell, 0) + 1;
+  }
+  const activeElement = document.activeElement instanceof Element ? document.activeElement : null;
+  const activeCell = activeElement?.closest?.("th,td");
+  if (activeCell instanceof HTMLTableCellElement && editor.view.dom.contains(activeCell)) {
+    return editor.view.posAtDOM(activeCell, 0) + 1;
+  }
+  const tables = editor.view.dom.querySelectorAll("table");
+  if (tables.length !== 1) return null;
+  const firstCell = tables[0]?.querySelector("th,td");
+  return firstCell instanceof HTMLTableCellElement ? editor.view.posAtDOM(firstCell, 0) + 1 : null;
+}
+var EDITOR_UI_ACTIVE_MARKS = [
+  "blockquote",
+  "bold",
+  "bulletList",
+  "code",
+  "codeBlock",
+  "formCheckbox",
+  "highlight",
+  "image",
+  "italic",
+  "link",
+  "orderedList",
+  "paragraph",
+  "strike",
+  "subscript",
+  "superscript",
+  "taskList",
+  "underline"
+];
+function computeEditorUiRenderState(editor) {
+  const textStyle = editor.getAttributes("textStyle");
+  const highlight = editor.getAttributes("highlight");
+  const image = editor.getAttributes("image");
+  const link = editor.getAttributes("link");
+  const tableCell = editor.getAttributes("tableCell");
+  const tableHeader = editor.getAttributes("tableHeader");
+  const hasTableContext = findTableNodeInfoFromState(editor.state) !== null;
+  const can = editor.can();
+  return {
+    active: EDITOR_UI_ACTIVE_MARKS.map((name) => editor.isActive(name)),
+    alignment: ["left", "center", "right", "justify"].map((textAlign) => editor.isActive({ textAlign })),
+    heading: [1, 2, 3].map((level) => editor.isActive("heading", { level })),
+    textStyle: {
+      color: textStyle.color ?? null,
+      fontFamily: textStyle.fontFamily ?? null,
+      fontSize: textStyle.fontSize ?? null,
+      letterSpacing: textStyle.letterSpacing ?? null,
+      lineHeight: textStyle.lineHeight ?? null
+    },
+    highlightColor: highlight.color ?? null,
+    image: {
+      imageLayout: image.imageLayout ?? null,
+      imageWidthPreset: image.imageWidthPreset ?? null
+    },
+    linkHref: link.href ?? null,
+    tableCell: {
+      backgroundColor: tableCell.backgroundColor ?? tableHeader.backgroundColor ?? null,
+      borderColor: tableCell.borderColor ?? tableHeader.borderColor ?? null,
+      borderStyle: tableCell.borderStyle ?? tableHeader.borderStyle ?? null,
+      borderWidth: tableCell.borderWidth ?? tableHeader.borderWidth ?? null,
+      formula: tableCell.formula ?? tableHeader.formula ?? null,
+      numberFormat: tableCell.numberFormat ?? tableHeader.numberFormat ?? null,
+      textDirection: tableCell.textDirection ?? tableHeader.textDirection ?? null,
+      verticalAlign: tableCell.verticalAlign ?? tableHeader.verticalAlign ?? null
+    },
+    can: {
+      addColumnAfter: hasTableContext && can.addColumnAfter(),
+      addColumnBefore: hasTableContext && can.addColumnBefore(),
+      addRowAfter: hasTableContext && can.addRowAfter(),
+      addRowBefore: hasTableContext && can.addRowBefore(),
+      decreaseIndent: can.decreaseIndent(),
+      increaseIndent: can.increaseIndent(),
+      mergeCells: hasTableContext && can.mergeCells(),
+      redo: can.redo(),
+      splitCell: hasTableContext && can.splitCell(),
+      undo: can.undo()
+    },
+    hasTableContext,
+    isEmpty: editor.isEmpty
+  };
+}
+var editorUiRenderStateCache = /* @__PURE__ */ new WeakMap();
+function getEditorUiRenderState(editor) {
+  const state = editor.state;
+  const cached = editorUiRenderStateCache.get(editor);
+  if (cached?.state === state) return cached.value;
+  const value = computeEditorUiRenderState(editor);
+  editorUiRenderStateCache.set(editor, { state, value });
+  return value;
+}
+var EditorUiRenderStateContext = React7.createContext(null);
+function EditorUiRenderStateProvider({
+  children,
+  editor
+}) {
+  const value = useEditorState({
+    editor,
+    selector: ({ editor: currentEditor }) => getEditorUiRenderState(currentEditor)
+  });
+  return /* @__PURE__ */ jsx7(EditorUiRenderStateContext.Provider, { value: { editor, value }, children });
+}
+function useSharedEditorUiRenderState(editor) {
+  const context = React7.useContext(EditorUiRenderStateContext);
+  if (!context || context.editor !== editor) {
+    throw new Error("UEditor chrome must be rendered inside EditorUiRenderStateProvider");
+  }
+  return context.value;
+}
+function fileToDataUrl2(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ""));
+    reader.onerror = () => reject(reader.error ?? new Error("Failed to read image file"));
+    reader.readAsDataURL(file);
+  });
+}
+function formatTableInsertLabel(template, rows, cols) {
+  return template.replace("{rows}", String(rows)).replace("{cols}", String(cols));
+}
+var ToolbarButton = React7.forwardRef(({ onClick, onMouseDown, active, disabled, children, title, className }, ref) => {
+  const button = /* @__PURE__ */ jsx7(
+    "button",
+    {
+      ref,
+      type: "button",
+      "aria-label": title,
+      onMouseDown: (e) => {
+        onMouseDown?.(e);
+        e.preventDefault();
+      },
+      onClick,
+      disabled,
+      className: cn(
+        "flex h-7 w-7 shrink-0 cursor-pointer items-center justify-center rounded-md transition-colors duration-150",
+        "gap-0.5 [&>svg]:h-3.5 [&>svg]:w-3.5 [&>svg]:shrink-0",
+        "hover:bg-accent",
+        "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/20",
+        "disabled:opacity-40 disabled:cursor-not-allowed",
+        active ? "bg-primary/10 text-primary shadow-sm" : "text-[#7B8184] hover:text-foreground dark:text-muted-foreground",
+        className
+      ),
+      children
+    }
+  );
+  if (title) {
+    return /* @__PURE__ */ jsx7(Tooltip, { content: title, placement: "top", delay: { open: 200, close: 0 }, children: button });
+  }
+  return button;
+});
+ToolbarButton.displayName = "ToolbarButton";
+var ToolbarDivider = () => /* @__PURE__ */ jsx7("div", { "aria-hidden": "true", className: "mx-1.5 h-7 w-px shrink-0 bg-[rgba(123,129,132,0.24)]" });
+var TableInsertGrid = ({
+  insertLabel,
+  previewTemplate,
+  onInsert
+}) => {
+  const [selection, setSelection] = React7.useState({ rows: 3, cols: 3 });
+  const maxRows = 8;
+  const maxCols = 8;
+  return /* @__PURE__ */ jsxs5("div", { className: "mb-2 rounded-xl border border-border/60 bg-muted/20 p-2", children: [
+    /* @__PURE__ */ jsx7("div", { className: "mb-2 text-sm font-medium text-foreground", children: formatTableInsertLabel(previewTemplate, selection.rows, selection.cols) }),
+    /* @__PURE__ */ jsx7("div", { className: "grid grid-cols-8 gap-1", children: Array.from({ length: maxRows }).map(
+      (_, rowIndex) => Array.from({ length: maxCols }).map((__, colIndex) => {
+        const rows = rowIndex + 1;
+        const cols = colIndex + 1;
+        const active = rows <= selection.rows && cols <= selection.cols;
+        return /* @__PURE__ */ jsx7(
+          "button",
+          {
+            type: "button",
+            "aria-label": formatTableInsertLabel(previewTemplate, rows, cols),
+            onMouseDown: (e) => e.preventDefault(),
+            onMouseEnter: () => setSelection({ rows, cols }),
+            onFocus: () => setSelection({ rows, cols }),
+            onClick: () => onInsert(rows, cols),
+            className: cn(
+              "h-5 w-5 rounded-sm border transition-colors",
+              active ? "border-primary bg-primary/20" : "border-border/70 bg-background hover:border-primary/60 hover:bg-primary/10"
+            )
+          },
+          `${rows}-${cols}`
+        );
+      })
+    ) }),
+    /* @__PURE__ */ jsx7("div", { className: "mt-2 text-xs text-muted-foreground", children: insertLabel })
+  ] });
+};
+function applyTableCellAttribute(editor, name, value) {
+  const { state, view } = editor;
+  const applied = setCellAttr(name, value)(state, view.dispatch.bind(view));
+  if (applied) {
+    view.focus();
+    return;
+  }
+  editor.chain().focus().setCellAttribute(name, value).run();
+}
+var EditorToolbar = ({
+  editor,
+  variant,
+  uploadImage,
+  imageInsertMode = "base64",
+  maxImageFileSize = DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE,
+  allowedImageMimeTypes = DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
+  fontFamilies,
+  fontSizes,
+  lineHeights,
+  letterSpacings
+}) => {
+  const t = useSmartTranslations("UEditor");
+  const editorUiState = useSharedEditorUiRenderState(editor);
+  const { textColors, highlightColors } = useEditorColors();
+  const [showImageInput, setShowImageInput] = useState4(false);
+  const [showLinkInput, setShowLinkInput] = useState4(false);
+  const [isTableMenuOpen, setIsTableMenuOpen] = useState4(false);
+  const fileInputRef = useRef4(null);
+  const [isUploadingImage, setIsUploadingImage] = useState4(false);
+  const [imageUploadError, setImageUploadError] = useState4(null);
+  const isImageSelected = editor.isActive("image");
+  const imageAttrs = editor.getAttributes("image");
+  const tableAnchorPos = getTableAnchorPos(editor);
+  const tableInfo = tableAnchorPos == null ? null : findTableNodeInfoFromState(editor.state, tableAnchorPos);
+  const textStyleAttrs = editor.getAttributes("textStyle");
+  const imageLayout = imageAttrs.imageLayout === "left" || imageAttrs.imageLayout === "right" ? imageAttrs.imageLayout : "block";
+  const imageWidthPreset = imageAttrs.imageWidthPreset === "sm" || imageAttrs.imageWidthPreset === "md" || imageAttrs.imageWidthPreset === "lg" ? imageAttrs.imageWidthPreset : null;
+  const isTableSelected = tableInfo !== null;
+  const hasTableContext = isTableSelected;
+  const canMergeCells = hasTableContext && editor.can().mergeCells();
+  const canSplitCell = hasTableContext && editor.can().splitCell();
+  const currentCellVerticalAlign = normalizeStyleValue(editor.getAttributes("tableCell").verticalAlign || editor.getAttributes("tableHeader").verticalAlign) || "";
+  const currentCellTextDirection = normalizeStyleValue(editor.getAttributes("tableCell").textDirection || editor.getAttributes("tableHeader").textDirection) || "horizontal";
+  const currentFontFamily = normalizeStyleValue(textStyleAttrs.fontFamily);
+  const currentFontSize = normalizeStyleValue(textStyleAttrs.fontSize);
+  const currentTextColor = normalizeStyleValue(textStyleAttrs.color) || "inherit";
+  const currentHighlightColor = normalizeStyleValue(editor.getAttributes("highlight").color) || "";
+  const currentLineHeight = normalizeStyleValue(textStyleAttrs.lineHeight);
+  const currentLetterSpacing = normalizeStyleValue(textStyleAttrs.letterSpacing);
+  const availableFontFamilies = React7.useMemo(() => fontFamilies ?? getDefaultFontFamilies(t), [fontFamilies, t]);
+  const availableFontSizes = React7.useMemo(() => fontSizes ?? getDefaultFontSizes(), [fontSizes]);
+  const availableLineHeights = React7.useMemo(() => lineHeights ?? getDefaultLineHeights(), [lineHeights]);
+  const availableLetterSpacings = React7.useMemo(() => letterSpacings ?? getDefaultLetterSpacings(), [letterSpacings]);
+  const currentFontFamilyDisplayValue = currentFontFamily.split(",")[0]?.trim() ?? currentFontFamily;
+  const currentFontFamilyLabel = availableFontFamilies.find((option) => normalizeStyleValue(option.value) === currentFontFamily)?.label ?? (currentFontFamilyDisplayValue || t("toolbar.fontDefault"));
+  const currentFontSizeLabel = availableFontSizes.find((option) => normalizeStyleValue(option.value) === currentFontSize)?.label ?? "13";
+  const currentLineHeightLabel = availableLineHeights.find((option) => normalizeStyleValue(option.value) === currentLineHeight)?.label ?? t("toolbar.lineHeightDefault");
+  const currentLetterSpacingLabel = availableLetterSpacings.find((option) => normalizeStyleValue(option.value) === currentLetterSpacing)?.label ?? t("toolbar.letterSpacingDefault");
+  const defaultFontFamily = availableFontFamilies[0];
+  const defaultFontFamilyValue = defaultFontFamily?.value ?? "";
+  const displayedFontFamilyLabel = currentFontFamily ? currentFontFamilyLabel : defaultFontFamily?.label ?? t("toolbar.fontDefault");
+  const displayedFontFamilyValue = currentFontFamily || defaultFontFamilyValue;
+  const displayedFontSizeLabel = currentFontSize ? currentFontSizeLabel : "13";
+  const activeFontSize = currentFontSize || "13px";
+  const isMedium = variant === "medium";
+  const isMediumFull = variant === "medium-full";
+  const isFull = variant === "default" || variant === "full" || variant === "notion" || !variant;
+  const insertImageFiles = async (files) => {
+    if (files.length === 0) return;
+    setIsUploadingImage(true);
+    setImageUploadError(null);
+    for (const file of files) {
+      if (!file.type.startsWith("image/")) continue;
+      if (file.size > maxImageFileSize) continue;
+      if (allowedImageMimeTypes.length > 0 && !allowedImageMimeTypes.includes(file.type)) continue;
+      try {
+        const src = imageInsertMode === "upload" && uploadImage ? await uploadImage(file) : await fileToDataUrl2(file);
+        const safeSrc = sanitizeUEditorUrl(src, "image");
+        if (!safeSrc) continue;
+        editor.chain().focus().setImage({ src: safeSrc, alt: file.name }).run();
+        editor.commands.createParagraphNear();
+      } catch {
+        setImageUploadError(t("imageInput.uploadError"));
+      }
+    }
+    setIsUploadingImage(false);
+  };
+  if (variant === "minimal") {
+    return /* @__PURE__ */ jsxs5("div", { className: "flex flex-wrap items-center gap-0.5 border-b border-border/35 bg-muted/30 p-1.5", children: [
+      /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().undo().run(), disabled: !editor.can().undo(), title: t("toolbar.undo"), children: /* @__PURE__ */ jsx7(FigmaUndoIcon, { className: "h-4 w-4" }) }),
+      /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().redo().run(), disabled: !editor.can().redo(), title: t("toolbar.redo"), children: /* @__PURE__ */ jsx7(FigmaRedoIcon, { className: "h-4 w-4" }) }),
+      /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+      /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleBold().run(), active: editor.isActive("bold"), title: t("toolbar.bold"), children: /* @__PURE__ */ jsx7(FigmaBoldIcon, { className: "h-4 w-4" }) }),
+      /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleItalic().run(), active: editor.isActive("italic"), title: t("toolbar.italic"), children: /* @__PURE__ */ jsx7(FigmaItalicIcon, { className: "h-4 w-4" }) }),
+      /* @__PURE__ */ jsx7(
+        ToolbarButton,
+        {
+          onClick: () => editor.chain().focus().toggleBulletList().run(),
+          active: editor.isActive("bulletList"),
+          title: t("toolbar.bulletList"),
+          children: /* @__PURE__ */ jsx7(FigmaListIcon, { className: "h-4 w-4" })
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        ToolbarButton,
+        {
+          onClick: () => editor.chain().focus().decreaseIndent().run(),
+          disabled: !editorUiState.can.decreaseIndent,
+          title: t("toolbar.decreaseIndent"),
+          children: /* @__PURE__ */ jsx7(IndentDecrease, { className: "h-4 w-4" })
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        ToolbarButton,
+        {
+          onClick: () => editor.chain().focus().increaseIndent().run(),
+          disabled: !editorUiState.can.increaseIndent,
+          title: t("toolbar.increaseIndent"),
+          children: /* @__PURE__ */ jsx7(IndentIncrease, { className: "h-4 w-4" })
+        }
+      ),
+      /* @__PURE__ */ jsxs5(
+        DropdownMenu,
+        {
+          trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+          }, active: editor.isActive("formCheckbox"), title: t("slashCommand.formCheckbox"), children: /* @__PURE__ */ jsx7(SquareCheckBig, { className: "w-4 h-4" }) }),
+          children: [
+            /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                icon: SquareCheckBig,
+                label: t("slashCommand.formCheckbox"),
+                onClick: () => editor.chain().focus().setFormCheckbox().run()
+              }
+            ),
+            /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                icon: CircleCheckBig,
+                label: t("slashCommand.roundCheckbox"),
+                onClick: () => editor.chain().focus().setFormCheckbox({ variant: "circle" }).run()
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        DropdownMenu,
+        {
+          contentClassName: "min-w-72",
+          trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => setShowLinkInput(!editor.isActive("link")), active: editor.isActive("link"), title: t("toolbar.link"), children: /* @__PURE__ */ jsx7(FigmaLinkIcon, { className: "h-4 w-4" }) }),
+          children: showLinkInput ? /* @__PURE__ */ jsx7(
+            LinkInput,
+            {
+              initialUrl: String(editor.getAttributes("link").href ?? ""),
+              onSubmit: (url) => {
+                applyEditorLink(editor, url);
+                setShowLinkInput(false);
+              },
+              onCancel: () => setShowLinkInput(false)
+            }
+          ) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+            /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                icon: LinkIcon,
+                label: t("toolbar.link"),
+                onClick: () => setShowLinkInput(true),
+                active: editor.isActive("link"),
+                closeOnSelect: false
+              }
+            ),
+            /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                icon: Trash2,
+                label: t("toolbar.removeLink"),
+                onClick: () => editor.chain().focus().extendMarkRange("link").unsetLink().run(),
+                disabled: !editor.isActive("link"),
+                destructive: true
+              }
+            )
+          ] })
+        }
+      )
+    ] });
+  }
+  const VerticalAlignActiveIcon = currentCellVerticalAlign === "middle" ? AlignCenterVertical : currentCellVerticalAlign === "bottom" ? AlignEndVertical : AlignStartVertical;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      role: "toolbar",
+      className: "flex min-h-12 flex-nowrap items-center gap-0.5 overflow-x-auto border-b border-[rgba(196,197,213,0.6)] bg-[#F4F4F4] px-2 py-2 dark:bg-muted/60",
+      children: [
+        isFull && /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsxs5(
+              ToolbarButton,
+              {
+                onClick: () => {
+                },
+                title: t("toolbar.fontFamily"),
+                className: "h-8 w-44 max-w-44 justify-between gap-2 border border-[rgba(196,197,213,0.6)] bg-white px-2.5 text-[#404040] shadow-[0_1px_2px_rgba(0,0,0,0.07)] hover:bg-white hover:text-[#404040] dark:bg-background dark:text-foreground",
+                children: [
+                  /* @__PURE__ */ jsx7("span", { className: "min-w-0 flex-1 truncate text-left text-sm font-normal", style: { fontFamily: displayedFontFamilyValue || void 0 }, children: displayedFontFamilyLabel }),
+                  /* @__PURE__ */ jsx7(FigmaChevronDownIcon, { className: "h-3 w-3 shrink-0 text-[#7B8184]" })
+                ]
+              }
+            ),
+            contentClassName: "max-h-80 overflow-y-auto min-w-56 p-2",
+            children: availableFontFamilies.map((option) => /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                label: option.label,
+                onClick: () => editor.chain().focus().setFontFamily(option.value).run(),
+                active: normalizeStyleValue(option.value) === (currentFontFamily || normalizeStyleValue(defaultFontFamilyValue)),
+                className: "font-medium"
+              },
+              option.value
+            ))
+          }
+        ),
+        (isMediumFull || isFull) && /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsxs5(
+              ToolbarButton,
+              {
+                onClick: () => {
+                },
+                title: t("toolbar.fontSize"),
+                className: "h-8 w-16 justify-between gap-2 border border-[rgba(196,197,213,0.6)] bg-white px-2.5 text-[#404040] shadow-[0_1px_2px_rgba(0,0,0,0.07)] hover:bg-white hover:text-[#404040] dark:bg-background dark:text-foreground",
+                children: [
+                  /* @__PURE__ */ jsx7("span", { className: "text-sm font-normal leading-none", children: displayedFontSizeLabel }),
+                  /* @__PURE__ */ jsx7(FigmaChevronDownIcon, { className: "h-3 w-3 shrink-0 text-[#7B8184]" })
+                ]
+              }
+            ),
+            contentClassName: "max-h-80 overflow-y-auto min-w-32 p-2",
+            children: availableFontSizes.map((option) => /* @__PURE__ */ jsx7(
+              DropdownMenuItem,
+              {
+                label: option.label,
+                onClick: () => editor.chain().focus().setFontSize(option.value).run(),
+                active: normalizeStyleValue(option.value) === activeFontSize
+              },
+              option.value
+            ))
+          }
+        ),
+        /* @__PURE__ */ jsxs5(
+          DropdownMenu,
+          {
+            contentClassName: "p-1",
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("toolbar.textStyle"), className: "px-1.5 w-auto gap-0.5", children: /* @__PURE__ */ jsx7(FigmaTextStyleIcon, { className: "h-4 w-4" }) }),
+            children: [
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Type,
+                  label: t("toolbar.normal"),
+                  onClick: () => editor.chain().focus().setParagraph().run(),
+                  active: editor.isActive("paragraph")
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Heading1Icon,
+                  label: t("toolbar.heading1"),
+                  onClick: () => editor.chain().focus().toggleHeading({ level: 1 }).run(),
+                  active: editor.isActive("heading", { level: 1 }),
+                  shortcut: "Ctrl+Alt+1"
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Heading2Icon,
+                  label: t("toolbar.heading2"),
+                  onClick: () => editor.chain().focus().toggleHeading({ level: 2 }).run(),
+                  active: editor.isActive("heading", { level: 2 }),
+                  shortcut: "Ctrl+Alt+2"
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Heading3Icon,
+                  label: t("toolbar.heading3"),
+                  onClick: () => editor.chain().focus().toggleHeading({ level: 3 }).run(),
+                  active: editor.isActive("heading", { level: 3 }),
+                  shortcut: "Ctrl+Alt+3"
+                }
+              )
+            ]
+          }
+        ),
+        isFull && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          /* @__PURE__ */ jsxs5(
+            DropdownMenu,
+            {
+              trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+              }, title: t("toolbar.lineHeight"), className: "gap-0.5", children: /* @__PURE__ */ jsx7(FigmaLineHeightIcon, { className: "h-4 w-4" }) }),
+              contentClassName: "max-h-72 overflow-y-auto p-1",
+              children: [
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: Type,
+                    label: t("toolbar.lineHeightDefault"),
+                    onClick: () => editor.chain().focus().unsetLineHeight().run(),
+                    active: !currentLineHeight
+                  }
+                ),
+                availableLineHeights.map((option) => /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    label: option.label,
+                    onClick: () => editor.chain().focus().setLineHeight(option.value).run(),
+                    active: normalizeStyleValue(option.value) === currentLineHeight
+                  },
+                  option.value
+                ))
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs5(
+            DropdownMenu,
+            {
+              trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+              }, title: t("toolbar.letterSpacing"), className: "gap-0.5", children: /* @__PURE__ */ jsx7(FigmaLetterSpacingIcon, { className: "h-4 w-4" }) }),
+              contentClassName: "max-h-72 overflow-y-auto p-1",
+              children: [
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: Type,
+                    label: t("toolbar.letterSpacingDefault"),
+                    onClick: () => editor.chain().focus().unsetLetterSpacing().run(),
+                    active: !currentLetterSpacing
+                  }
+                ),
+                availableLetterSpacings.map((option) => /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    label: option.label,
+                    onClick: () => editor.chain().focus().setLetterSpacing(option.value).run(),
+                    active: normalizeStyleValue(option.value) === currentLetterSpacing
+                  },
+                  option.value
+                ))
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+        /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleBold().run(), active: editor.isActive("bold"), title: t("toolbar.bold"), children: /* @__PURE__ */ jsx7(FigmaBoldIcon, { className: "h-4 w-4" }) }),
+        /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleItalic().run(), active: editor.isActive("italic"), title: t("toolbar.italic"), children: /* @__PURE__ */ jsx7(FigmaItalicIcon, { className: "h-4 w-4" }) }),
+        /* @__PURE__ */ jsx7(
+          ToolbarButton,
+          {
+            onClick: () => editor.chain().focus().toggleUnderline().run(),
+            active: editor.isActive("underline"),
+            title: t("toolbar.underline"),
+            children: /* @__PURE__ */ jsx7(FigmaUnderlineIcon, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleStrike().run(), active: editor.isActive("strike"), title: t("toolbar.strike"), children: /* @__PURE__ */ jsx7(FigmaStrikeIcon, { className: "h-4 w-4" }) }),
+        (isMediumFull || isFull) && /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleCode().run(), active: editor.isActive("code"), title: t("toolbar.code"), children: /* @__PURE__ */ jsx7(FigmaCodeIcon, { className: "h-4 w-4" }) }),
+        isFull && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().toggleSubscript().run(),
+              active: editor.isActive("subscript"),
+              title: t("toolbar.subscript"),
+              children: /* @__PURE__ */ jsx7(FigmaSubscriptIcon, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().toggleSuperscript().run(),
+              active: editor.isActive("superscript"),
+              title: t("toolbar.superscript"),
+              children: /* @__PURE__ */ jsx7(FigmaSuperscriptIcon, { className: "h-4 w-4" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            contentClassName: "min-w-72",
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => setShowLinkInput(!editor.isActive("link")), active: editor.isActive("link"), title: t("toolbar.link"), children: /* @__PURE__ */ jsx7(FigmaLinkIcon, { className: "h-4 w-4" }) }),
+            children: showLinkInput ? /* @__PURE__ */ jsx7(
+              LinkInput,
+              {
+                initialUrl: String(editor.getAttributes("link").href ?? ""),
+                onSubmit: (url) => {
+                  applyEditorLink(editor, url);
+                  setShowLinkInput(false);
+                },
+                onCancel: () => setShowLinkInput(false)
+              }
+            ) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: LinkIcon,
+                  label: t("toolbar.link"),
+                  onClick: () => setShowLinkInput(true),
+                  active: editor.isActive("link"),
+                  closeOnSelect: false
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Trash2,
+                  label: t("toolbar.removeLink"),
+                  onClick: () => editor.chain().focus().extendMarkRange("link").unsetLink().run(),
+                  disabled: !editor.isActive("link"),
+                  destructive: true
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+        /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("colors.textColor"), children: /* @__PURE__ */ jsx7(TextColorIcon, { color: currentTextColor }) }),
+            children: /* @__PURE__ */ jsx7(
+              EditorColorPalette,
+              {
+                colors: textColors,
+                currentColor: currentTextColor,
+                onSelect: (color) => {
+                  if (color === "inherit") {
+                    editor.chain().focus().unsetColor().run();
+                  } else {
+                    editor.chain().focus().setColor(color).run();
+                  }
+                },
+                label: t("colors.textColor")
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, active: editor.isActive("highlight"), title: t("colors.highlight"), children: /* @__PURE__ */ jsx7(HighlightColorIcon, { color: currentHighlightColor }) }),
+            children: /* @__PURE__ */ jsx7(
+              EditorColorPalette,
+              {
+                colors: highlightColors,
+                currentColor: currentHighlightColor,
+                onSelect: (color) => {
+                  if (color === "") {
+                    editor.chain().focus().unsetHighlight().run();
+                  } else {
+                    editor.chain().focus().toggleHighlight({ color }).run();
+                  }
+                },
+                label: t("colors.highlight")
+              }
+            )
+          }
+        ),
+        (isMediumFull || isFull) && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+          /* @__PURE__ */ jsxs5(
+            DropdownMenu,
+            {
+              trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+              }, title: t("toolbar.alignment"), children: /* @__PURE__ */ jsx7(FigmaAlignLeftIcon, { className: "h-4 w-4" }) }),
+              children: [
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: AlignLeft,
+                    label: t("toolbar.alignLeft"),
+                    onClick: () => editor.chain().focus().setTextAlign("left").run(),
+                    active: editor.isActive({ textAlign: "left" })
+                  }
+                ),
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: AlignCenter,
+                    label: t("toolbar.alignCenter"),
+                    onClick: () => editor.chain().focus().setTextAlign("center").run(),
+                    active: editor.isActive({ textAlign: "center" })
+                  }
+                ),
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: AlignRight,
+                    label: t("toolbar.alignRight"),
+                    onClick: () => editor.chain().focus().setTextAlign("right").run(),
+                    active: editor.isActive({ textAlign: "right" })
+                  }
+                ),
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: AlignJustify,
+                    label: t("toolbar.justify"),
+                    onClick: () => editor.chain().focus().setTextAlign("justify").run(),
+                    active: editor.isActive({ textAlign: "justify" })
+                  }
+                ),
+                hasTableContext && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+                  /* @__PURE__ */ jsx7("div", { className: "my-1 border-t" }),
+                  /* @__PURE__ */ jsx7(
+                    DropdownMenuItem,
+                    {
+                      icon: AlignStartVertical,
+                      label: t("tableMenu.alignVerticalTop") || "Align top",
+                      onClick: () => applyTableCellAttribute(editor, "verticalAlign", "top"),
+                      active: currentCellVerticalAlign === "top"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx7(
+                    DropdownMenuItem,
+                    {
+                      icon: AlignCenterVertical,
+                      label: t("tableMenu.alignVerticalMiddle") || "Align middle",
+                      onClick: () => applyTableCellAttribute(editor, "verticalAlign", "middle"),
+                      active: currentCellVerticalAlign === "middle"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx7(
+                    DropdownMenuItem,
+                    {
+                      icon: AlignEndVertical,
+                      label: t("tableMenu.alignVerticalBottom") || "Align bottom",
+                      onClick: () => applyTableCellAttribute(editor, "verticalAlign", "bottom"),
+                      active: currentCellVerticalAlign === "bottom"
+                    }
+                  )
+                ] })
+              ]
+            }
+          ),
+          hasTableContext && /* @__PURE__ */ jsxs5(
+            DropdownMenu,
+            {
+              trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+              }, title: t("tableMenu.textDirection"), children: currentCellTextDirection === "vertical" ? /* @__PURE__ */ jsx7(ArrowDown, { className: "w-4 h-4" }) : /* @__PURE__ */ jsx7(ArrowRight, { className: "w-4 h-4" }) }),
+              children: [
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: ArrowRight,
+                    label: t("tableMenu.horizontalText"),
+                    onClick: () => applyTableCellAttribute(editor, "textDirection", null),
+                    active: currentCellTextDirection === "horizontal"
+                  }
+                ),
+                /* @__PURE__ */ jsx7(
+                  DropdownMenuItem,
+                  {
+                    icon: ArrowDown,
+                    label: t("tableMenu.verticalText"),
+                    onClick: () => applyTableCellAttribute(editor, "textDirection", "vertical"),
+                    active: currentCellTextDirection === "vertical"
+                  }
+                )
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+        /* @__PURE__ */ jsxs5(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("toolbar.bulletList"), children: /* @__PURE__ */ jsx7(FigmaListIcon, { className: "h-4 w-4" }) }),
+            children: [
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: ListIcon,
+                  label: t("toolbar.bulletList"),
+                  onClick: () => editor.chain().focus().toggleBulletList().run(),
+                  active: editor.isActive("bulletList"),
+                  shortcut: "Ctrl+Shift+8"
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: ListOrderedIcon,
+                  label: t("toolbar.orderedList"),
+                  onClick: () => editor.chain().focus().toggleOrderedList().run(),
+                  active: editor.isActive("orderedList"),
+                  shortcut: "Ctrl+Shift+7"
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: ListTodo,
+                  label: t("toolbar.taskList"),
+                  onClick: () => editor.chain().focus().toggleTaskList().run(),
+                  active: editor.isActive("taskList"),
+                  shortcut: "Ctrl+Shift+9"
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          ToolbarButton,
+          {
+            onClick: () => editor.chain().focus().decreaseIndent().run(),
+            disabled: !editorUiState.can.decreaseIndent,
+            title: t("toolbar.decreaseIndent"),
+            children: /* @__PURE__ */ jsx7(IndentDecrease, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          ToolbarButton,
+          {
+            onClick: () => editor.chain().focus().increaseIndent().run(),
+            disabled: !editorUiState.can.increaseIndent,
+            title: t("toolbar.increaseIndent"),
+            children: /* @__PURE__ */ jsx7(IndentIncrease, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsxs5(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, active: editor.isActive("formCheckbox"), title: t("slashCommand.formCheckbox"), children: /* @__PURE__ */ jsx7(SquareCheckBig, { className: "w-4 h-4" }) }),
+            children: [
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: SquareCheckBig,
+                  label: t("slashCommand.formCheckbox"),
+                  onClick: () => editor.chain().focus().setFormCheckbox().run()
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: CircleCheckBig,
+                  label: t("slashCommand.roundCheckbox"),
+                  onClick: () => editor.chain().focus().setFormCheckbox({ variant: "circle" }).run()
+                }
+              )
+            ]
+          }
+        ),
+        isMediumFull && /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().toggleBlockquote().run(), active: editor.isActive("blockquote"), title: t("toolbar.quote"), children: /* @__PURE__ */ jsx7(FigmaQuoteIcon, { className: "h-4 w-4" }) }),
+        isFull && /* @__PURE__ */ jsxs5(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("toolbar.quote"), children: /* @__PURE__ */ jsx7(FigmaQuoteIcon, { className: "h-4 w-4" }) }),
+            children: [
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: QuoteIcon,
+                  label: t("toolbar.quote"),
+                  onClick: () => editor.chain().focus().toggleBlockquote().run(),
+                  active: editor.isActive("blockquote"),
+                  shortcut: "Ctrl+Shift+B"
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: FileCode,
+                  label: t("toolbar.codeBlock"),
+                  onClick: () => editor.chain().focus().toggleCodeBlock().run(),
+                  active: editor.isActive("codeBlock"),
+                  shortcut: "Ctrl+Alt+C"
+                }
+              )
+            ]
+          }
+        ),
+        (isMediumFull || isFull) && /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("toolbar.image"), children: /* @__PURE__ */ jsx7(FigmaImageIcon, { className: "h-4 w-4" }) }),
+            children: showImageInput ? /* @__PURE__ */ jsx7(
+              ImageInput,
+              {
+                onSubmit: (url, alt) => {
+                  editor.chain().focus().setImage({ src: url, alt }).run();
+                  setShowImageInput(false);
+                },
+                onCancel: () => setShowImageInput(false)
+              }
+            ) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+              /* @__PURE__ */ jsx7(DropdownMenuItem, { icon: LinkIcon, label: t("imageInput.addFromUrl"), onClick: () => setShowImageInput(true), closeOnSelect: false }),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Upload,
+                  label: isUploadingImage ? t("imageInput.uploading") : t("imageInput.uploadTab"),
+                  disabled: isUploadingImage,
+                  onClick: () => fileInputRef.current?.click(),
+                  closeOnSelect: false
+                }
+              ),
+              imageUploadError && /* @__PURE__ */ jsx7(DropdownMenuItem, { label: imageUploadError, disabled: true, destructive: true }),
+              /* @__PURE__ */ jsx7(
+                "input",
+                {
+                  ref: fileInputRef,
+                  type: "file",
+                  accept: "image/*",
+                  multiple: true,
+                  className: "hidden",
+                  onChange: (e) => {
+                    const files = Array.from(e.target.files ?? []);
+                    e.target.value = "";
+                    void insertImageFiles(files);
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx7("div", { className: "my-1 border-t" }),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: AlignCenter,
+                  label: t("toolbar.imageLayoutBlock"),
+                  onClick: () => applyImageLayout(editor, "block"),
+                  active: isImageSelected && imageLayout === "block",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: AlignLeft,
+                  label: t("toolbar.imageLayoutLeft"),
+                  onClick: () => applyImageLayout(editor, "left"),
+                  active: isImageSelected && imageLayout === "left",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: AlignRight,
+                  label: t("toolbar.imageLayoutRight"),
+                  onClick: () => applyImageLayout(editor, "right"),
+                  active: isImageSelected && imageLayout === "right",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7("div", { className: "my-1 border-t" }),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  label: t("toolbar.imageWidthSm"),
+                  onClick: () => applyImageWidthPreset(editor, "sm"),
+                  active: isImageSelected && imageWidthPreset === "sm",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  label: t("toolbar.imageWidthMd"),
+                  onClick: () => applyImageWidthPreset(editor, "md"),
+                  active: isImageSelected && imageWidthPreset === "md",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  label: t("toolbar.imageWidthLg"),
+                  onClick: () => applyImageWidthPreset(editor, "lg"),
+                  active: isImageSelected && imageWidthPreset === "lg",
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7("div", { className: "my-1 border-t" }),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: RotateCcw,
+                  label: t("toolbar.imageResetSize"),
+                  onClick: () => resetImageSize(editor),
+                  disabled: !isImageSelected
+                }
+              ),
+              /* @__PURE__ */ jsx7(
+                DropdownMenuItem,
+                {
+                  icon: Trash2,
+                  label: t("toolbar.imageDelete"),
+                  onClick: () => deleteSelectedImage(editor),
+                  disabled: !isImageSelected,
+                  destructive: true
+                }
+              )
+            ] })
+          }
+        ),
+        (isMediumFull || isFull) && /* @__PURE__ */ jsx7(
+          DropdownMenu,
+          {
+            isOpen: isTableMenuOpen,
+            onOpenChange: setIsTableMenuOpen,
+            trigger: /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => {
+            }, title: t("toolbar.table"), children: /* @__PURE__ */ jsx7(FigmaTableIcon, { className: "h-4 w-4" }) }),
+            contentClassName: "p-2 min-w-56",
+            children: /* @__PURE__ */ jsx7(
+              TableInsertGrid,
+              {
+                insertLabel: t("tableMenu.insertTable"),
+                previewTemplate: t("tableMenu.gridPreview"),
+                onInsert: (rows, cols) => {
+                  editor.chain().focus().insertTable({ rows, cols, withHeaderRow: true }).run();
+                  setIsTableMenuOpen(false);
+                }
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+        /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().undo().run(), disabled: !editor.can().undo(), title: t("toolbar.undo"), children: /* @__PURE__ */ jsx7(FigmaUndoIcon, { className: "h-4 w-4" }) }),
+        /* @__PURE__ */ jsx7(ToolbarButton, { onClick: () => editor.chain().focus().redo().run(), disabled: !editor.can().redo(), title: t("toolbar.redo"), children: /* @__PURE__ */ jsx7(FigmaRedoIcon, { className: "h-4 w-4" }) }),
+        hasTableContext && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          /* @__PURE__ */ jsx7(ToolbarDivider, {}),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().addColumnBefore().run(),
+              disabled: !editor.can().addColumnBefore(),
+              title: t("tableMenu.addColumnBefore"),
+              children: /* @__PURE__ */ jsx7(ArrowLeft, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().addColumnAfter().run(),
+              disabled: !editor.can().addColumnAfter(),
+              title: t("tableMenu.addColumnAfter"),
+              children: /* @__PURE__ */ jsx7(ArrowRight, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().addRowBefore().run(),
+              disabled: !editor.can().addRowBefore(),
+              title: t("tableMenu.addRowBefore"),
+              children: /* @__PURE__ */ jsx7(ArrowUp, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => editor.chain().focus().addRowAfter().run(),
+              disabled: !editor.can().addRowAfter(),
+              title: t("tableMenu.addRowAfter"),
+              children: /* @__PURE__ */ jsx7(ArrowDown, { className: "w-4 h-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            ToolbarButton,
+            {
+              onClick: () => {
+                if (canSplitCell) {
+                  editor.chain().focus().splitCell().run();
+                  return;
+                }
+                mergeTableCellsPreservingColumnWidths(editor);
+              },
+              active: canSplitCell,
+              disabled: !canMergeCells && !canSplitCell,
+              title: canSplitCell ? t("tableMenu.splitCell") : t("tableMenu.mergeCells"),
+              children: /* @__PURE__ */ jsx7(TableCellsMerge, { className: "w-4 h-4" })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/UEditor/editor-styles.ts
+var UEDITOR_PROSEMIRROR_CLASS_NAME = cn(
+  "prose prose-sm sm:prose dark:prose-invert max-w-none",
+  "focus:outline-none",
+  "px-4 py-4",
+  "[&_.is-editor-empty]:before:content-[attr(data-placeholder)]",
+  "[&_.is-editor-empty]:before:text-muted-foreground/50",
+  "[&_.is-editor-empty]:before:float-left",
+  "[&_.is-editor-empty]:before:pointer-events-none",
+  "[&_.is-editor-empty]:before:h-0",
+  "[&_.ProseMirror-gapcursor]:pointer-events-none",
+  "[&_.ProseMirror-gapcursor]:absolute",
+  "[&_.ProseMirror-gapcursor]:hidden",
+  "[&_.ProseMirror-gapcursor:after]:content-['']",
+  "[&_.ProseMirror-gapcursor:after]:block",
+  "[&_.ProseMirror-gapcursor:after]:absolute",
+  "[&_.ProseMirror-gapcursor:after]:top-[-2px]",
+  "[&_.ProseMirror-gapcursor:after]:w-8",
+  "[&_.ProseMirror-gapcursor:after]:border-t-2",
+  "[&_.ProseMirror-gapcursor:after]:border-primary",
+  "[&.ProseMirror-focused_.ProseMirror-gapcursor]:block",
+  "[&_ul[data-type='taskList']]:list-none",
+  "[&_ul[data-type='taskList']]:pl-0",
+  "[&_ul[data-type='taskList']_li]:flex",
+  "[&_ul[data-type='taskList']_li]:items-start",
+  "[&_ul[data-type='taskList']_li]:gap-2",
+  "[&_ul[data-type='taskList']_li>label]:mt-0.5",
+  "[&_ul[data-type='taskList']_li>label>input]:w-4",
+  "[&_ul[data-type='taskList']_li>label>input]:h-4",
+  "[&_ul[data-type='taskList']_li>label>input]:rounded",
+  "[&_ul[data-type='taskList']_li>label>input]:border-2",
+  "[&_ul[data-type='taskList']_li>label>input]:border-primary/50",
+  "[&_ul[data-type='taskList']_li>label>input]:accent-primary",
+  "[&_pre]:bg-muted/40!",
+  "[&_pre]:text-foreground!",
+  "[&_pre]:border!",
+  "[&_pre]:border-border/60!",
+  "[&_pre_code]:bg-transparent!",
+  "[&_.tableWrapper]:overflow-x-auto",
+  "[&_.tableWrapper]:pb-1.5",
+  "[&_.tableWrapper]:select-text",
+  "[&_.tableWrapper]:[scrollbar-width:thin]",
+  "[&_.tableWrapper]:[scrollbar-color:hsl(var(--border))_transparent]",
+  "[&_.tableWrapper::-webkit-scrollbar]:h-2",
+  "[&_.tableWrapper::-webkit-scrollbar]:w-2",
+  "[&_.tableWrapper::-webkit-scrollbar-track]:rounded-full",
+  "[&_.tableWrapper::-webkit-scrollbar-track]:bg-transparent",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb]:rounded-full",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb]:border",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb]:border-solid",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb]:border-transparent",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb]:bg-border/70",
+  "[&_.tableWrapper::-webkit-scrollbar-thumb:hover]:bg-muted-foreground/45",
+  "[&_table]:w-auto",
+  "[&_table]:table-fixed",
+  "[&_table]:overflow-hidden",
+  "[&_table]:select-text",
+  "[&_table[data-table-align]]:w-max",
+  "[&_table[data-table-align]]:max-w-full",
+  "[&_table[data-table-align='center']]:mx-auto",
+  "[&_table[data-table-align='right']]:ml-auto",
+  "[&_table[data-table-align='right']]:mr-0",
+  "[&_td]:relative",
+  "[&_td]:align-top",
+  "[&_td]:box-border",
+  "[&_td]:select-text",
+  "[&_td]:px-2",
+  "[&_td]:py-0",
+  "[&_td_p]:my-0",
+  "[&_th]:relative",
+  "[&_th]:align-top",
+  "[&_th]:box-border",
+  "[&_th]:select-text",
+  "[&_th]:px-2",
+  "[&_th]:py-0",
+  "[&_th_p]:my-0",
+  "[&_td[data-formula]]:pr-7",
+  "[&_th[data-formula]]:pr-7",
+  "[&_td[data-formula]]:before:pointer-events-none",
+  "[&_th[data-formula]]:before:pointer-events-none",
+  "[&_td[data-formula]]:before:absolute",
+  "[&_th[data-formula]]:before:absolute",
+  "[&_td[data-formula]]:before:right-1",
+  "[&_th[data-formula]]:before:right-1",
+  "[&_td[data-formula]]:before:top-1",
+  "[&_th[data-formula]]:before:top-1",
+  "[&_td[data-formula]]:before:z-[1]",
+  "[&_th[data-formula]]:before:z-[1]",
+  "[&_td[data-formula]]:before:rounded-sm",
+  "[&_th[data-formula]]:before:rounded-sm",
+  "[&_td[data-formula]]:before:bg-primary/10",
+  "[&_th[data-formula]]:before:bg-primary/10",
+  "[&_td[data-formula]]:before:px-1",
+  "[&_th[data-formula]]:before:px-1",
+  "[&_td[data-formula]]:before:font-mono",
+  "[&_th[data-formula]]:before:font-mono",
+  "[&_td[data-formula]]:before:text-[9px]",
+  "[&_th[data-formula]]:before:text-[9px]",
+  "[&_td[data-formula]]:before:font-semibold",
+  "[&_th[data-formula]]:before:font-semibold",
+  "[&_td[data-formula]]:before:leading-4",
+  "[&_th[data-formula]]:before:leading-4",
+  "[&_td[data-formula]]:before:text-primary",
+  "[&_th[data-formula]]:before:text-primary",
+  "[&_td[data-formula]]:before:content-['fx']",
+  "[&_th[data-formula]]:before:content-['fx']",
+  "[&_td[data-formula-state='error']]:bg-destructive/5",
+  "[&_th[data-formula-state='error']]:bg-destructive/5",
+  "[&_td[data-formula-state='error']]:before:bg-destructive/10",
+  "[&_th[data-formula-state='error']]:before:bg-destructive/10",
+  "[&_td[data-formula-state='error']]:before:text-destructive",
+  "[&_th[data-formula-state='error']]:before:text-destructive",
+  "[&_td[colwidth]]:min-w-0",
+  "[&_th[colwidth]]:min-w-0",
+  "[&_td[data-colwidth]]:min-w-0",
+  "[&_th[data-colwidth]]:min-w-0",
+  "[&_.selectedCell]:after:content-['']",
+  "[&_.selectedCell]:after:absolute",
+  "[&_.selectedCell]:after:inset-0",
+  "[&_.selectedCell]:after:z-[2]",
+  "[&_.selectedCell]:after:bg-primary/15",
+  "[&_.selectedCell]:after:pointer-events-none",
+  "[&_.column-resize-handle]:pointer-events-auto",
+  "[&_.column-resize-handle]:cursor-col-resize",
+  "[&_.column-resize-handle]:absolute",
+  "[&_.column-resize-handle]:top-[-1px]",
+  "[&_.column-resize-handle]:bottom-[-1px]",
+  "[&_.column-resize-handle]:right-[-5px]",
+  "[&_.column-resize-handle]:z-30",
+  "[&_.column-resize-handle]:w-2.5",
+  "[&_.column-resize-handle]:bg-transparent",
+  "[&_.column-resize-handle]:rounded-none",
+  "[&_.column-resize-handle]:opacity-0",
+  "[&_.column-resize-handle]:transition-opacity",
+  "[&_.column-resize-handle]:after:absolute",
+  "[&_.column-resize-handle]:after:top-0",
+  "[&_.column-resize-handle]:after:bottom-0",
+  "[&_.column-resize-handle]:after:left-1/2",
+  "[&_.column-resize-handle]:after:w-0.5",
+  "[&_.column-resize-handle]:after:-translate-x-1/2",
+  "[&_.column-resize-handle]:after:rounded-full",
+  "[&_.column-resize-handle]:after:bg-primary/75",
+  "[&_.column-resize-handle]:after:content-['']",
+  "[&.resize-cursor_.column-resize-handle]:opacity-100",
+  "[&.resize-cursor_.column-resize-handle]:after:bg-primary",
+  "[&_.column-resize-dragging]:min-w-0",
+  "[&.resize-cursor]:cursor-col-resize",
+  "[&.resize-row-cursor]:cursor-row-resize",
+  "[&_img.ProseMirror-selectednode]:ring-2",
+  "[&_img.ProseMirror-selectednode]:ring-primary/60",
+  "[&_img.ProseMirror-selectednode]:ring-offset-2",
+  "[&_img.ProseMirror-selectednode]:ring-offset-background",
+  "[&_hr]:border-t-2",
+  "[&_hr]:border-primary/30",
+  "[&_hr]:my-8",
+  "[&_h1]:text-3xl",
+  "[&_h1]:font-bold",
+  "[&_h1]:mt-6",
+  "[&_h1]:mb-4",
+  "[&_h1]:text-foreground",
+  "[&_h2]:text-2xl",
+  "[&_h2]:font-semibold",
+  "[&_h2]:mt-5",
+  "[&_h2]:mb-3",
+  "[&_h2]:text-foreground",
+  "[&_h3]:text-xl",
+  "[&_h3]:font-semibold",
+  "[&_h3]:mt-4",
+  "[&_h3]:mb-2",
+  "[&_h3]:text-foreground",
+  "[&_ul:not([data-type='taskList'])]:list-disc",
+  "[&_ul:not([data-type='taskList'])]:pl-6",
+  "[&_ul:not([data-type='taskList'])]:my-3",
+  "[&_ol]:list-decimal",
+  "[&_ol]:pl-6",
+  "[&_ol]:my-3",
+  "[&_li]:my-1",
+  "[&_li]:pl-1",
+  "[&_li_p]:my-0",
+  "[&_blockquote]:border-l-4",
+  "[&_blockquote]:border-primary",
+  "[&_blockquote]:pl-4",
+  "[&_blockquote]:py-2",
+  "[&_blockquote]:my-4",
+  "[&_blockquote]:bg-muted/30",
+  "[&_blockquote]:rounded-r-lg",
+  "[&_blockquote]:italic",
+  "[&_blockquote]:text-muted-foreground",
+  "[&_blockquote_p]:my-0",
+  "[&_[data-image-layout='left']+p]:mt-1",
+  "[&_[data-image-layout='left']+p]:min-h-[5rem]",
+  "[&_[data-image-layout='right']+p]:mt-1",
+  "[&_[data-image-layout='right']+p]:min-h-[5rem]",
+  "max-md:[&_[data-image-layout='left']]:float-none",
+  "max-md:[&_[data-image-layout='left']]:mr-0",
+  "max-md:[&_[data-image-layout='left']]:ml-0",
+  "max-md:[&_[data-image-layout='left']]:max-w-full",
+  "max-md:[&_[data-image-layout='right']]:float-none",
+  "max-md:[&_[data-image-layout='right']]:mr-0",
+  "max-md:[&_[data-image-layout='right']]:ml-0",
+  "max-md:[&_[data-image-layout='right']]:max-w-full",
+  "max-md:[&_[data-image-layout='left']+p]:min-h-0",
+  "max-md:[&_[data-image-layout='right']+p]:min-h-0"
+);
+
+export {
+  formControlSizeStyles,
+  formControlFixedClass,
+  formControlValueClass,
+  getBorderRadiusClass,
+  getPanelBorderRadiusClass,
+  useUnderverseUIConfig,
+  UnderverseConfigProvider,
+  shadcnAnimationStyles,
+  useShadCNAnimations,
+  injectAnimationStyles,
+  getAnimationStyles,
+  Popover,
+  useDropdownMenuClose,
+  DropdownMenu,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuSub,
+  SelectDropdown,
+  DropdownMenu_default,
+  isSafeUEditorUrl,
+  sanitizeUEditorUrl,
+  DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE,
+  DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
+  ClipboardImages,
+  DEFAULT_TABLE_ROW_HEIGHT,
+  MIN_TABLE_ROW_HEIGHT,
+  COLUMN_RESIZE_LINE_THICKNESS,
+  ROW_RESIZE_LINE_THICKNESS,
+  UEDITOR_TABLE_LAYOUT_CHANGE_EVENT,
+  findTableRowNodeInfo,
+  resolveEventElement,
+  isPointOverRenderedText,
+  getSelectionTableCell,
+  isRowResizeHotspot,
+  isColumnResizeHotspot,
+  getRelativeBoundaryMetrics,
+  getRelativeCellMetrics,
+  getRelativeSelectedCellsMetrics,
+  findTableNodeInfoFromState,
+  applyTableAlignment,
+  dispatchTableLayoutChange,
+  mergeTableCellsPreservingColumnWidths,
+  runTableCommandAtCellPos,
+  duplicateTableRowAt,
+  clearTableRowAt,
+  duplicateTableColumnAt,
+  clearTableColumnAt,
+  expandTableFromCell,
+  TextColorIcon,
+  HighlightColorIcon,
+  CellBgColorIcon,
+  CellBorderIcon,
+  useEditorColors,
+  EditorColorPalette,
+  applyImageLayout,
+  applyImageWidthPreset,
+  resetImageSize,
+  deleteSelectedImage,
+  LinkInput,
+  ImageInput,
+  applyEditorLink,
+  normalizeStyleValue,
+  getDefaultFontSizes,
+  getDefaultLineHeights,
+  getTableAnchorPos,
+  EditorUiRenderStateProvider,
+  useSharedEditorUiRenderState,
+  fileToDataUrl2 as fileToDataUrl,
+  ToolbarButton,
+  TableInsertGrid,
+  EditorToolbar,
+  UEDITOR_PROSEMIRROR_CLASS_NAME
+};
+//# sourceMappingURL=chunk-MJV7ETJM.js.map