@underverse-ui/underverse 2.0.28 → 2.0.30

package/dist/{chunk-KTOXCD6J.js → chunk-37MHVJMV.js}

@@ -11,7 +11,7 @@ import {
   setRefValue,
   useSmartTranslations,
   useUEditorPortalContainerGetter
-} from "./chunk-A4GUPKHM.js";
+} from "./chunk-ZP7F4ZD7.js";
 
 // src/contexts/UnderverseConfigContext.tsx
 import * as React from "react";
@@ -834,6 +834,8 @@ var DropdownMenu = ({
       } else if (e.key === "Escape" && (isInMenu || isOnTrigger)) {
         e.preventDefault();
         closeMenu();
+        const focusTarget = triggerEl.matches("button,a,input,select,textarea,[tabindex]") ? triggerEl : triggerEl.querySelector("button,a,input,select,textarea,[tabindex]");
+        focusTarget?.focus();
       }
     };
     const menuDocument = menuRef.current?.ownerDocument;
@@ -900,7 +902,7 @@ var DropdownMenu = ({
               item.destructive && "text-destructive hover:bg-destructive/10 focus:bg-destructive/10"
             ),
             children: [
-              IconComponent && /* @__PURE__ */ jsx3(IconComponent, { className: "h-4 w-4" }),
+              IconComponent && /* @__PURE__ */ jsx3(IconComponent, { "aria-hidden": "true", className: "h-4 w-4" }),
               item.label
             ]
           },
@@ -928,11 +930,11 @@ var DropdownMenu = ({
       else callback(0);
     };
     if (!disabled) {
-      if (event.key === "ArrowDown") {
+      if (!event.altKey && !event.ctrlKey && !event.metaKey && event.key === "ArrowDown") {
         event.preventDefault();
         setOpen(true);
         scheduleFrame(() => focusMenuItem(0));
-      } else if (event.key === "ArrowUp") {
+      } else if (!event.altKey && !event.ctrlKey && !event.metaKey && event.key === "ArrowUp") {
         event.preventDefault();
         setOpen(true);
         scheduleFrame(() => {
@@ -1011,6 +1013,8 @@ var DropdownMenuItem = ({
   return /* @__PURE__ */ jsxs2(
     "button",
     {
+      type: "button",
+      role: "menuitem",
       onClick: () => {
         onClick?.();
         if (shouldCloseOnSelect) {
@@ -1032,19 +1036,19 @@ var DropdownMenuItem = ({
         className
       ),
       children: [
-        Icon && /* @__PURE__ */ jsx3(Icon, { className: cn("w-4 h-4 shrink-0", active ? "text-primary" : "opacity-60 group-hover:opacity-100") }),
+        Icon && /* @__PURE__ */ jsx3(Icon, { "aria-hidden": "true", 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" }) })
+        active && /* @__PURE__ */ jsx3("svg", { "aria-hidden": "true", 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 DropdownMenuSeparator = ({ className }) => /* @__PURE__ */ jsx3("div", { role: "separator", className: cn("h-px bg-border my-1", className) });
 var DropdownMenuSub = ({ label, icon: Icon, disabled, borderMode, getPortalContainer, children }) => {
   const globalConfig = useUnderverseUIConfig();
   const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
@@ -1055,6 +1059,9 @@ var DropdownMenuSub = ({ label, icon: Icon, disabled, borderMode, getPortalConta
         "button",
         {
           type: "button",
+          role: "menuitem",
+          "data-dropdown-menu-item": "",
+          tabIndex: -1,
           disabled,
           onMouseDown: (e) => e.preventDefault(),
           className: cn(
@@ -1065,9 +1072,9 @@ var DropdownMenuSub = ({ label, icon: Icon, disabled, borderMode, getPortalConta
             "disabled:opacity-50 disabled:cursor-not-allowed"
           ),
           children: [
-            Icon && /* @__PURE__ */ jsx3(Icon, { className: "w-4 h-4 shrink-0 opacity-60" }),
+            Icon && /* @__PURE__ */ jsx3(Icon, { "aria-hidden": "true", 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" })
+            /* @__PURE__ */ jsx3(ChevronRight, { "aria-hidden": "true", className: "w-3 h-3 opacity-50" })
           ]
         }
       ),
@@ -1170,6 +1177,7 @@ function isDataFileUrl(value) {
 function isSafeUEditorUrl(raw, kind) {
   const value = normalizeUrlInput(raw);
   if (!value) return false;
+  if (/[<>'"`]/.test(value)) return false;
   if (kind === "image" && isDataImageUrl(value)) return true;
   if (kind === "file" && isDataFileUrl(value)) return true;
   if (isProtocolRelativeUrl(value)) return false;
@@ -1194,10 +1202,251 @@ function sanitizeUEditorUrl(raw, kind) {
   return "";
 }
 
+// src/components/UEditor/async-insertion-position.ts
+function trackEditorInsertionPosition(editor, initialPosition = editor.state.selection.from) {
+  let position = initialPosition;
+  const mapPosition = ({ transaction }) => {
+    position = transaction.mapping.map(position, 1);
+  };
+  editor.on("transaction", mapPosition);
+  return {
+    get current() {
+      return position;
+    },
+    stop() {
+      editor.off("transaction", mapPosition);
+    }
+  };
+}
+
+// src/components/UEditor/image-file-upload.ts
+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 resolveImageSource(file, options) {
+  if (options.insertMode === "upload") {
+    if (!options.upload) {
+      if (!options.fallbackToDataUrl) {
+        throw new Error("Image upload handler is not configured.");
+      }
+    } else {
+      try {
+        const uploadedUrl = await options.upload(file);
+        const safeUploadedUrl = sanitizeUEditorUrl(uploadedUrl, "image");
+        if (safeUploadedUrl) return safeUploadedUrl;
+        if (!options.fallbackToDataUrl) {
+          throw new Error("Image upload returned an invalid URL.");
+        }
+      } catch (error) {
+        if (!options.fallbackToDataUrl) throw error;
+      }
+    }
+  }
+  const dataUrl = await fileToDataUrl(file);
+  const safeDataUrl = sanitizeUEditorUrl(dataUrl, "image");
+  if (!safeDataUrl) throw new Error("Image file could not be converted to a safe data URL.");
+  return safeDataUrl;
+}
+async function resolveUEditorImageFiles(files, options) {
+  let hadError = false;
+  const reportError = (error, file) => {
+    hadError = true;
+    options.onError?.(error, file);
+  };
+  const validFiles = files.filter((file) => {
+    if (!file.type.startsWith("image/") || options.allowedMimeTypes.length > 0 && !options.allowedMimeTypes.includes(file.type)) {
+      reportError(new Error(`Unsupported image type: ${file.type || "unknown"}.`), file);
+      return false;
+    }
+    if (file.size > options.maxFileSize) {
+      reportError(new Error(`Image exceeds the ${options.maxFileSize}-byte size limit.`), file);
+      return false;
+    }
+    return true;
+  });
+  const results = await Promise.all(validFiles.map(async (file) => {
+    try {
+      return { file, src: await resolveImageSource(file, options) };
+    } catch (error) {
+      reportError(error instanceof Error ? error : new Error("Image upload failed."), file);
+      return null;
+    }
+  }));
+  return {
+    images: results.filter((image) => image !== null),
+    hadError
+  };
+}
+
 // src/components/UEditor/clipboard-images.ts
 import { Extension } from "@tiptap/core";
 import { Plugin } from "@tiptap/pm/state";
 
+// src/components/UEditor/table-width-model.ts
+var TABLE_WIDTH_BASIS_POINTS = 1e4;
+var DEFAULT_RESPONSIVE_TABLE_WIDTH_BP = TABLE_WIDTH_BASIS_POINTS;
+var MAX_RESPONSIVE_TABLE_WIDTH_BP = 1e5;
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+function clampTableBasisPoints(value, fallback = TABLE_WIDTH_BASIS_POINTS, maximum = TABLE_WIDTH_BASIS_POINTS) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(maximum, Math.max(0, Math.round(number)));
+}
+function clampResponsiveTableWidthBp(value, fallback = DEFAULT_RESPONSIVE_TABLE_WIDTH_BP) {
+  return Math.max(1, clampTableBasisPoints(value, fallback, MAX_RESPONSIVE_TABLE_WIDTH_BP));
+}
+function normalizeTableWidthMode(value) {
+  return value === "responsive" || value === "full" ? "responsive" : "fixed";
+}
+function parsePercentageToBasisPoints(value, maximum = MAX_RESPONSIVE_TABLE_WIDTH_BP) {
+  if (!value) return null;
+  const match = value.trim().match(/^(-?\d+(?:\.\d+)?)%$/);
+  if (!match) return null;
+  const percentage = Number.parseFloat(match[1]);
+  if (!Number.isFinite(percentage)) return null;
+  return clampTableBasisPoints(percentage * 100, TABLE_WIDTH_BASIS_POINTS, maximum);
+}
+function formatBasisPointsAsPercentage(value) {
+  const percentage = clampTableBasisPoints(value, 0, MAX_RESPONSIVE_TABLE_WIDTH_BP) / 100;
+  return `${Number.parseFloat(percentage.toFixed(2))}%`;
+}
+function parseColumnRatios(value) {
+  const parts = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  const ratios = parts.map((part) => Number(part));
+  return ratios.length > 0 && ratios.every((ratio) => Number.isFinite(ratio) && ratio > 0) ? ratios : null;
+}
+function normalizeColumnRatios(values, columnCount) {
+  if (columnCount <= 0) return [];
+  const source = values?.length === columnCount ? values.map((value) => positiveNumber(value, 1)) : Array.from({ length: columnCount }, () => 1);
+  const sourceTotal = source.reduce((sum, value) => sum + value, 0);
+  const normalized = source.map((value) => Math.max(1, Math.round(value / sourceTotal * TABLE_WIDTH_BASIS_POINTS)));
+  let difference = TABLE_WIDTH_BASIS_POINTS - normalized.reduce((sum, value) => sum + value, 0);
+  while (difference !== 0) {
+    let changed = false;
+    for (let index = normalized.length - 1; index >= 0 && difference !== 0; index -= 1) {
+      if (difference < 0 && normalized[index] <= 1) continue;
+      normalized[index] += difference > 0 ? 1 : -1;
+      difference += difference > 0 ? -1 : 1;
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return normalized;
+}
+function getLogicalTableColumnCount(table) {
+  const firstRow = table.firstChild;
+  if (!firstRow) return 0;
+  let count = 0;
+  firstRow.forEach((cell) => {
+    count += Math.max(1, Number(cell.attrs.colspan) || 1);
+  });
+  return count;
+}
+function getLegacyTableColumnWeights(table, fallback = 100) {
+  const weights = [];
+  const firstRow = table.firstChild;
+  if (!firstRow) return weights;
+  firstRow.forEach((cell) => {
+    const colspan = Math.max(1, Number(cell.attrs.colspan) || 1);
+    const colwidth = Array.isArray(cell.attrs.colwidth) ? cell.attrs.colwidth : [];
+    for (let index = 0; index < colspan; index += 1) {
+      weights.push(positiveNumber(colwidth[index], fallback));
+    }
+  });
+  return weights;
+}
+function getTableColumnRatios(table) {
+  const columnCount = getLogicalTableColumnCount(table);
+  const stored = parseColumnRatios(table.attrs.columnRatios);
+  return normalizeColumnRatios(
+    stored?.length === columnCount ? stored : getLegacyTableColumnWeights(table),
+    columnCount
+  );
+}
+function getResponsiveTableWidthBp(table) {
+  return clampResponsiveTableWidthBp(table.attrs.widthBp);
+}
+function getResponsiveTableOffsetBp(table) {
+  const width = getResponsiveTableWidthBp(table);
+  return resolveResponsiveTableOffsetBp(width, null, table.attrs.offsetBp);
+}
+function resolveResponsiveTableOffsetBp(widthBp, tableAlign, fallbackOffsetBp = 0) {
+  const availableGap = Math.max(
+    0,
+    TABLE_WIDTH_BASIS_POINTS - clampResponsiveTableWidthBp(widthBp)
+  );
+  if (tableAlign === "center") return Math.round(availableGap / 2);
+  if (tableAlign === "right") return availableGap;
+  if (tableAlign === "left") return 0;
+  return Math.min(availableGap, clampTableBasisPoints(fallbackOffsetBp, 0));
+}
+function insertResponsiveColumnRatio(ratios, insertIndex, sourceIndex) {
+  if (ratios.length === 0) return [TABLE_WIDTH_BASIS_POINTS];
+  const safeSourceIndex = Math.max(0, Math.min(sourceIndex, ratios.length - 1));
+  const next = [...ratios];
+  const sourceRatio = next[safeSourceIndex];
+  next.splice(Math.max(0, Math.min(insertIndex, next.length)), 0, sourceRatio);
+  return normalizeColumnRatios(next, next.length);
+}
+function deleteResponsiveColumnRatio(ratios, deleteIndex) {
+  if (ratios.length <= 1) return [];
+  const next = ratios.filter((_, index) => index !== deleteIndex);
+  return normalizeColumnRatios(next, next.length);
+}
+function moveResponsiveColumnRatio(ratios, from, to) {
+  if (from === to || from < 0 || from >= ratios.length || to < 0 || to >= ratios.length) return [...ratios];
+  const next = [...ratios];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return normalizeColumnRatios(next, next.length);
+}
+function insertResponsiveColumnLayout(widthBp, ratios, insertIndex, sourceIndex) {
+  if (ratios.length === 0) {
+    return {
+      widthBp: clampResponsiveTableWidthBp(widthBp),
+      columnRatios: [TABLE_WIDTH_BASIS_POINTS]
+    };
+  }
+  const normalized = normalizeColumnRatios(ratios, ratios.length);
+  const safeSourceIndex = Math.max(0, Math.min(sourceIndex, normalized.length - 1));
+  const sourceRatio = normalized[safeSourceIndex];
+  return {
+    // Growing by the source column's share preserves every existing column's
+    // rendered width instead of squeezing the whole table back into 100%.
+    widthBp: clampResponsiveTableWidthBp(
+      clampResponsiveTableWidthBp(widthBp) * (TABLE_WIDTH_BASIS_POINTS + sourceRatio) / TABLE_WIDTH_BASIS_POINTS
+    ),
+    columnRatios: insertResponsiveColumnRatio(normalized, insertIndex, safeSourceIndex)
+  };
+}
+function deleteResponsiveColumnLayout(widthBp, ratios, deleteIndex) {
+  const normalized = normalizeColumnRatios(ratios, ratios.length);
+  if (normalized.length <= 1 || deleteIndex < 0 || deleteIndex >= normalized.length) {
+    return {
+      widthBp: clampResponsiveTableWidthBp(widthBp),
+      columnRatios: normalized.length <= 1 ? [] : normalized
+    };
+  }
+  const remainingRatio = TABLE_WIDTH_BASIS_POINTS - normalized[deleteIndex];
+  const nextWidthBp = clampResponsiveTableWidthBp(
+    clampResponsiveTableWidthBp(widthBp) * remainingRatio / TABLE_WIDTH_BASIS_POINTS
+  );
+  return {
+    // Deletion is the inverse operation: remaining columns keep their rendered
+    // widths while the table gives the removed column's space back.
+    widthBp: Math.abs(nextWidthBp - DEFAULT_RESPONSIVE_TABLE_WIDTH_BP) <= 1 ? DEFAULT_RESPONSIVE_TABLE_WIDTH_BP : nextWidthBp,
+    columnRatios: deleteResponsiveColumnRatio(normalized, deleteIndex)
+  };
+}
+
 // src/components/UEditor/clipboard-tables.ts
 var DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR = "#ffffff";
 var DEFAULT_HTML_TABLE_TEXT_COLOR = "#000000";
@@ -1829,13 +2078,34 @@ function createNormalizedRowContent(row, columnCount, fillerCellAttrs) {
   }
   return content;
 }
-function createTableContent(rows, minColumnCount = 1, fillerCellAttrs) {
+function createTableContent(rows, minColumnCount = 1, fillerCellAttrs, layout) {
   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;
+  const inferredColumnWeights = Array.from({ length: columnCount }, () => 100);
+  positionedRows.forEach((row) => {
+    row.cells.forEach(({ cell, colspan, startColumn }) => {
+      const width = colspan === 1 ? cell.attrs?.colwidth?.[0] : null;
+      if (typeof width === "number" && Number.isFinite(width) && width > 0) {
+        inferredColumnWeights[startColumn] = width;
+      }
+    });
+  });
+  const columnRatios = normalizeColumnRatios(
+    layout?.columnRatios?.length === columnCount ? layout.columnRatios : inferredColumnWeights,
+    columnCount
+  );
+  const widthBp = clampResponsiveTableWidthBp(layout?.widthBp, DEFAULT_RESPONSIVE_TABLE_WIDTH_BP);
+  const offsetBp = resolveResponsiveTableOffsetBp(widthBp, null, layout?.offsetBp);
   return {
     type: "table",
+    attrs: {
+      widthMode: "responsive",
+      widthBp,
+      offsetBp,
+      columnRatios
+    },
     content: positionedRows.map((row) => ({
       type: "tableRow",
       ...row.attrs ? { attrs: row.attrs } : {},
@@ -1856,9 +2126,22 @@ function getClipboardTableContent(dataTransfer) {
   if (tables.length !== 1 || hasMeaningfulContentOutsideTable(sourceBody)) return null;
   const table = tables[0];
   if (!(table instanceof HTMLTableElement)) return null;
-  return createTableContent(getHtmlTableRows(table, styleMap), 1, {
-    backgroundColor: DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR
-  });
+  const storedWidthValue = table.getAttribute("data-table-width-bp");
+  const storedOffsetValue = table.getAttribute("data-table-offset-bp");
+  const storedWidthBp = Number(storedWidthValue);
+  const storedOffsetBp = Number(storedOffsetValue);
+  const widthBp = storedWidthValue !== null && Number.isFinite(storedWidthBp) && storedWidthBp > 0 ? storedWidthBp : parsePercentageToBasisPoints(table.getAttribute("data-table-width") ?? table.style.width) ?? DEFAULT_RESPONSIVE_TABLE_WIDTH_BP;
+  const offsetBp = storedOffsetValue !== null && Number.isFinite(storedOffsetBp) && storedOffsetBp >= 0 ? storedOffsetBp : parsePercentageToBasisPoints(table.getAttribute("data-table-offset") ?? table.style.marginLeft) ?? 0;
+  return createTableContent(
+    getHtmlTableRows(table, styleMap),
+    1,
+    { backgroundColor: DEFAULT_HTML_TABLE_CELL_BACKGROUND_COLOR },
+    {
+      widthBp,
+      offsetBp,
+      columnRatios: parseColumnRatios(table.getAttribute("data-table-column-ratios"))
+    }
+  );
 }
 function parseClipboardTsvRows(text) {
   const rows = [];
@@ -1944,26 +2227,6 @@ function getImageFiles(dataTransfer) {
   }
   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() {
@@ -1972,25 +2235,32 @@ var ClipboardImages = Extension.create({
       allowedMimeTypes: DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
       upload: void 0,
       fallbackToDataUrl: true,
-      insertMode: "base64"
+      insertMode: "base64",
+      onError: void 0
     };
   },
   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 {
-        }
+      const trackedPosition = trackEditorInsertionPosition(editor, selectionPos);
+      try {
+        const { images } = await resolveUEditorImageFiles(files, {
+          maxFileSize: options.maxFileSize,
+          allowedMimeTypes: options.allowedMimeTypes,
+          upload: options.upload,
+          fallbackToDataUrl: options.fallbackToDataUrl,
+          insertMode: options.insertMode,
+          onError: options.onError
+        });
+        if (editor.isDestroyed || images.length === 0) return;
+        const content = images.map((image) => ({
+          type: "image",
+          attrs: { src: image.src, alt: image.file.name }
+        }));
+        editor.commands.insertContentAt(trackedPosition.current, content, { updateSelection: false });
+      } finally {
+        trackedPosition.stop();
       }
     };
     return [
@@ -2019,7 +2289,8 @@ var ClipboardImages = Extension.create({
           },
           handleDrop: (view, event, _slice, moved) => {
             if (moved) return false;
-            if (!(event instanceof DragEvent)) return false;
+            const DragEventCtor = view.dom.ownerDocument.defaultView?.DragEvent;
+            if (!DragEventCtor || !(event instanceof DragEventCtor)) return false;
             const files = getImageFiles(event.dataTransfer);
             if (files.length === 0) return false;
             const pos = view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos;
@@ -2049,6 +2320,7 @@ var LinkInput = ({
   const [url, setUrl] = useState3(initialUrl);
   const [error, setError] = useState3("");
   const inputRef = useRef2(null);
+  const inputId = useId();
   const errorId = useId();
   useEffect3(() => {
     inputRef.current?.focus();
@@ -2065,12 +2337,17 @@ var LinkInput = ({
     onSubmit(normalized);
   };
   return /* @__PURE__ */ jsxs3("form", { onSubmit: handleSubmit, className: "p-2", children: [
+    /* @__PURE__ */ jsx4("label", { htmlFor: inputId, className: "sr-only", children: t("toolbar.link") }),
     /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-2", children: [
       /* @__PURE__ */ jsx4(
         "input",
         {
           ref: inputRef,
+          id: inputId,
           type: "text",
+          inputMode: "url",
+          name: "link-url",
+          autoComplete: "off",
           value: url,
           onChange: (e) => {
             setUrl(e.target.value);
@@ -2082,8 +2359,8 @@ var LinkInput = ({
           className: `flex-1 rounded-lg bg-muted/50 px-3 py-2 text-sm ${formControlOutlineClass} aria-invalid:border-destructive`
         }
       ),
-      /* @__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" }) })
+      /* @__PURE__ */ jsx4("button", { type: "submit", "aria-label": t("toolbar.link"), className: "p-2 rounded-lg bg-primary text-primary-foreground hover:bg-primary/90 transition-colors", children: /* @__PURE__ */ jsx4(Check, { "aria-hidden": "true", className: "w-4 h-4" }) }),
+      /* @__PURE__ */ jsx4("button", { type: "button", "aria-label": t("imageInput.cancelBtn"), onClick: onCancel, className: "p-2 rounded-lg hover:bg-muted transition-colors text-muted-foreground", children: /* @__PURE__ */ jsx4(X, { "aria-hidden": "true", 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
   ] });
@@ -2092,7 +2369,11 @@ var ImageInput = ({ onSubmit, onCancel }) => {
   const t = useSmartTranslations("UEditor");
   const [url, setUrl] = useState3("");
   const [alt, setAlt] = useState3("");
+  const [error, setError] = useState3("");
   const inputRef = useRef2(null);
+  const urlId = useId();
+  const altId = useId();
+  const errorId = useId();
   useEffect3(() => {
     inputRef.current?.focus();
   }, []);
@@ -2100,30 +2381,45 @@ var ImageInput = ({ onSubmit, onCancel }) => {
     e.preventDefault();
     const safeUrl = sanitizeUEditorUrl(url, "image");
     if (safeUrl) {
+      setError("");
       onSubmit(safeUrl, alt);
+    } else {
+      setError(t("imageInput.invalid"));
     }
   };
   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("label", { htmlFor: urlId, className: "text-xs font-medium text-muted-foreground", children: t("imageInput.urlLabel") }),
       /* @__PURE__ */ jsx4(
         "input",
         {
           ref: inputRef,
+          id: urlId,
           type: "text",
+          inputMode: "url",
+          name: "image-url",
+          autoComplete: "off",
           value: url,
-          onChange: (e) => setUrl(e.target.value),
+          onChange: (e) => {
+            setUrl(e.target.value);
+            if (error) setError("");
+          },
           placeholder: t("imageInput.urlPlaceholder"),
+          "aria-invalid": Boolean(error),
+          "aria-describedby": error ? errorId : void 0,
           className: `mt-1 w-full rounded-lg bg-muted/50 px-3 py-2 text-sm ${formControlOutlineClass}`
         }
       )
     ] }),
     /* @__PURE__ */ jsxs3("div", { children: [
-      /* @__PURE__ */ jsx4("label", { className: "text-xs font-medium text-muted-foreground", children: t("imageInput.altLabel") }),
+      /* @__PURE__ */ jsx4("label", { htmlFor: altId, className: "text-xs font-medium text-muted-foreground", children: t("imageInput.altLabel") }),
       /* @__PURE__ */ jsx4(
         "input",
         {
+          id: altId,
           type: "text",
+          name: "image-alt",
+          autoComplete: "off",
           value: alt,
           onChange: (e) => setAlt(e.target.value),
           placeholder: t("imageInput.altPlaceholder"),
@@ -2131,6 +2427,7 @@ var ImageInput = ({ onSubmit, onCancel }) => {
         }
       )
     ] }),
+    error ? /* @__PURE__ */ jsx4("p", { id: errorId, role: "alert", className: "text-xs text-destructive", children: error }) : null,
     /* @__PURE__ */ jsxs3("div", { className: "flex gap-2", children: [
       /* @__PURE__ */ jsx4(
         "button",
@@ -2986,10 +3283,14 @@ function findTableNodeInfoFromState(state, anchorPos) {
 function applyTableAlignment(editor, tableAlign, anchorPos) {
   const tableInfo = findTableNodeInfoFromState(editor.state, anchorPos);
   if (!tableInfo) return false;
+  const responsive = normalizeTableWidthMode(tableInfo.node.attrs.widthMode) === "responsive";
+  const widthBp = getResponsiveTableWidthBp(tableInfo.node);
+  const offsetBp = resolveResponsiveTableOffsetBp(widthBp, tableAlign);
   editor.view.dispatch(
     editor.state.tr.setNodeMarkup(tableInfo.pos, tableInfo.node.type, {
       ...tableInfo.node.attrs,
-      textAlign: tableAlign
+      textAlign: tableAlign,
+      ...responsive ? { offsetBp } : null
     })
   );
   const domAtTable = editor.view.domAtPos(Math.min(tableInfo.pos + 1, editor.state.doc.content.size)).node;
@@ -3006,8 +3307,8 @@ function applyTableAlignment(editor, tableAlign, anchorPos) {
     }
     if (tableAlign) {
       tableElement.setAttribute("data-table-align", tableAlign);
-      tableElement.style.marginLeft = tableAlign === "center" || tableAlign === "right" ? "auto" : "0";
-      tableElement.style.marginRight = tableAlign === "center" ? "auto" : tableAlign === "right" ? "0" : "auto";
+      tableElement.style.marginLeft = responsive ? formatBasisPointsAsPercentage(offsetBp) : tableAlign === "center" || tableAlign === "right" ? "auto" : "0";
+      tableElement.style.marginRight = responsive ? "auto" : tableAlign === "center" ? "auto" : tableAlign === "right" ? "0" : "auto";
     } else {
       tableElement.removeAttribute("data-table-align");
       tableElement.style.removeProperty("margin-left");
@@ -3020,6 +3321,609 @@ function applyTableAlignment(editor, tableAlign, anchorPos) {
 // src/components/UEditor/table-cell-commands.ts
 import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
 import { selectedRect, TableMap } from "@tiptap/pm/tables";
+
+// src/components/UEditor/table-formula.ts
+var CELL_ADDRESS_RE = /^(\$?)([A-Z]+)(\$?)([1-9]\d*)$/i;
+var CELL_RANGE_RE = /^(\$?[A-Z]+\$?[1-9]\d*):(\$?[A-Z]+\$?[1-9]\d*)$/i;
+var SUPPORTED_FUNCTIONS = /* @__PURE__ */ new Set(["SUM", "AVG", "MIN", "MAX", "COUNT"]);
+function columnNameToIndex(columnName) {
+  const normalized = columnName.trim().toUpperCase();
+  if (!/^[A-Z]+$/.test(normalized)) {
+    return -1;
+  }
+  let index = 0;
+  for (const char of normalized) {
+    index = index * 26 + char.charCodeAt(0) - 64;
+  }
+  return index - 1;
+}
+function indexToColumnName(index) {
+  if (!Number.isInteger(index) || index < 0) {
+    return "";
+  }
+  let value = index + 1;
+  let name = "";
+  while (value > 0) {
+    const remainder = (value - 1) % 26;
+    name = String.fromCharCode(65 + remainder) + name;
+    value = Math.floor((value - 1) / 26);
+  }
+  return name;
+}
+function parseTableCellAddress(input) {
+  const match = input.trim().match(CELL_ADDRESS_RE);
+  if (!match) {
+    return null;
+  }
+  const column = columnNameToIndex(match[2] ?? "");
+  const row = Number.parseInt(match[4] ?? "", 10) - 1;
+  if (column < 0 || row < 0) {
+    return null;
+  }
+  return {
+    column,
+    row,
+    label: `${indexToColumnName(column)}${row + 1}`
+  };
+}
+function parseTableCellRange(input) {
+  const match = input.trim().match(CELL_RANGE_RE);
+  if (!match) {
+    return null;
+  }
+  const from = parseTableCellAddress(match[1] ?? "");
+  const to = parseTableCellAddress(match[2] ?? "");
+  if (!from || !to) {
+    return null;
+  }
+  return { from, to };
+}
+function getTableCellRangeLabels(range) {
+  const startColumn = Math.min(range.from.column, range.to.column);
+  const endColumn = Math.max(range.from.column, range.to.column);
+  const startRow = Math.min(range.from.row, range.to.row);
+  const endRow = Math.max(range.from.row, range.to.row);
+  const labels = [];
+  for (let row = startRow; row <= endRow; row += 1) {
+    for (let column = startColumn; column <= endColumn; column += 1) {
+      labels.push(`${indexToColumnName(column)}${row + 1}`);
+    }
+  }
+  return labels;
+}
+function normalizeTableFormula(formula) {
+  return formula.trim().replace(/^=/, "").trim();
+}
+function isDraftTableFormula(formula) {
+  const normalized = normalizeTableFormula(formula);
+  if (!normalized) return true;
+  let depth = 0;
+  for (const char of normalized) {
+    if (char === "(") depth += 1;
+    if (char === ")") depth -= 1;
+    if (depth < 0) return false;
+  }
+  if (depth > 0) return true;
+  if (/^[A-Z]+\(\s*\)$/i.test(normalized)) return true;
+  if (/[+\-*/,(]\s*$/.test(normalized)) return true;
+  return false;
+}
+function formatFormulaError(error) {
+  return `#${error.toUpperCase()}`;
+}
+function normalizeTableNumberFormat(format) {
+  return format === "text" || format === "number" || format === "currency" || format === "percent" || format === "date" ? format : "text";
+}
+function formatTableFormulaDisplayValue(value, numberFormat) {
+  const stringValue = String(value);
+  if (stringValue.startsWith("#")) {
+    return stringValue;
+  }
+  const normalizedFormat = normalizeTableNumberFormat(numberFormat);
+  if (normalizedFormat === "text") {
+    return stringValue;
+  }
+  const numericValue = typeof value === "number" ? value : Number.parseFloat(stringValue.replace(/,/g, ""));
+  if (!Number.isFinite(numericValue)) {
+    return stringValue;
+  }
+  if (normalizedFormat === "number") {
+    return new Intl.NumberFormat("en-US", { maximumFractionDigits: 6 }).format(numericValue);
+  }
+  if (normalizedFormat === "currency") {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      maximumFractionDigits: 2
+    }).format(numericValue);
+  }
+  if (normalizedFormat === "percent") {
+    return new Intl.NumberFormat("en-US", {
+      style: "percent",
+      maximumFractionDigits: 2
+    }).format(numericValue);
+  }
+  const excelEpochMs = Date.UTC(1899, 11, 30);
+  const date = new Date(excelEpochMs + numericValue * 24 * 60 * 60 * 1e3);
+  if (Number.isNaN(date.getTime())) {
+    return stringValue;
+  }
+  return new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: "UTC"
+  }).format(date);
+}
+function getTableFormulaReferences(formula) {
+  const normalized = normalizeTableFormula(formula);
+  if (!normalized) return [];
+  const tokens = tokenizeFormula(normalized);
+  if (!tokens) return [];
+  const references = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    if (token.type === "cell") {
+      const address = parseTableCellAddress(token.value);
+      if (address) references.add(address.label);
+    } else if (token.type === "range") {
+      const range = parseTableCellRange(token.value);
+      if (!range) continue;
+      for (const label of getTableCellRangeLabels(range)) {
+        references.add(label);
+      }
+    }
+  }
+  return Array.from(references);
+}
+function buildTableFormulaDependencyGraph(cells) {
+  const dependencies = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const formulas = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    const label = cell.label.toUpperCase();
+    formulas.set(label, cell.formula);
+    dependencies.set(label, new Set(getTableFormulaReferences(cell.formula)));
+    if (!dependents.has(label)) {
+      dependents.set(label, /* @__PURE__ */ new Set());
+    }
+  }
+  for (const [label, refs] of dependencies) {
+    for (const ref of refs) {
+      if (!dependents.has(ref)) {
+        dependents.set(ref, /* @__PURE__ */ new Set());
+      }
+      dependents.get(ref)?.add(label);
+    }
+  }
+  return { dependencies, dependents, formulas };
+}
+function getTableFormulaCircularReferences(graph) {
+  const circular = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const startLabel of graph.formulas.keys()) {
+    if (visited.has(startLabel)) continue;
+    visited.add(startLabel);
+    const stack = [
+      {
+        label: startLabel,
+        references: Array.from(graph.dependencies.get(startLabel) ?? []).filter((ref) => graph.formulas.has(ref)),
+        nextIndex: 0
+      }
+    ];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) break;
+      const reference = frame.references[frame.nextIndex];
+      if (reference) {
+        frame.nextIndex += 1;
+        if (!visited.has(reference)) {
+          visited.add(reference);
+          stack.push({
+            label: reference,
+            references: Array.from(graph.dependencies.get(reference) ?? []).filter((ref) => graph.formulas.has(ref)),
+            nextIndex: 0
+          });
+        }
+        continue;
+      }
+      stack.pop();
+      finishOrder.push(frame.label);
+    }
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  for (let index = finishOrder.length - 1; index >= 0; index -= 1) {
+    const startLabel = finishOrder[index];
+    if (!startLabel || assigned.has(startLabel)) continue;
+    const component = [];
+    const stack = [startLabel];
+    assigned.add(startLabel);
+    while (stack.length > 0) {
+      const label = stack.pop();
+      if (!label) continue;
+      component.push(label);
+      for (const dependent of graph.dependents.get(label) ?? []) {
+        if (!graph.formulas.has(dependent) || assigned.has(dependent)) continue;
+        assigned.add(dependent);
+        stack.push(dependent);
+      }
+    }
+    if (component.length > 1) {
+      for (const label of component) circular.add(label);
+    } else {
+      const label = component[0];
+      if (label && graph.dependencies.get(label)?.has(label)) circular.add(label);
+    }
+  }
+  return circular;
+}
+function getTableFormulaRecalculationOrder(graph) {
+  const circular = getTableFormulaCircularReferences(graph);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const startLabel of graph.formulas.keys()) {
+    if (visited.has(startLabel) || circular.has(startLabel)) continue;
+    const stack = [];
+    const push = (label) => {
+      visiting.add(label);
+      stack.push({
+        label,
+        references: Array.from(graph.dependencies.get(label) ?? []).filter((ref) => graph.formulas.has(ref) && !circular.has(ref)),
+        nextIndex: 0
+      });
+    };
+    push(startLabel);
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) break;
+      const reference = frame.references[frame.nextIndex];
+      if (reference) {
+        frame.nextIndex += 1;
+        if (!visited.has(reference) && !visiting.has(reference)) {
+          push(reference);
+        }
+        continue;
+      }
+      stack.pop();
+      visiting.delete(frame.label);
+      visited.add(frame.label);
+      order.push(frame.label);
+    }
+  }
+  return { order, circular };
+}
+function getAffectedTableFormulaLabels(graph, changedLabels) {
+  const affected = /* @__PURE__ */ new Set();
+  const queue = Array.from(changedLabels, (label) => label.toUpperCase());
+  for (const label of queue) {
+    if (graph.formulas.has(label)) {
+      affected.add(label);
+    }
+  }
+  for (let index = 0; index < queue.length; index += 1) {
+    const label = queue[index];
+    if (!label) continue;
+    for (const dependent of graph.dependents.get(label) ?? []) {
+      if (affected.has(dependent)) continue;
+      affected.add(dependent);
+      queue.push(dependent);
+    }
+  }
+  return affected;
+}
+function evaluateBasicTableFormula(formula, getCellValue) {
+  const normalized = normalizeTableFormula(formula);
+  if (!normalized) {
+    return { value: null, error: "empty" };
+  }
+  if (normalized.includes("#REF!")) {
+    return { value: null, error: "invalid-reference" };
+  }
+  const tokens = tokenizeFormula(normalized);
+  if (!tokens) {
+    return { value: null, error: "invalid-formula" };
+  }
+  const parser = new FormulaParser(tokens, getCellValue);
+  const result = parser.parseExpression();
+  if (result.error) {
+    return result;
+  }
+  if (!parser.isComplete()) {
+    return { value: null, error: "invalid-formula" };
+  }
+  return result;
+}
+function tokenizeFormula(formula) {
+  const tokens = [];
+  let index = 0;
+  while (index < formula.length) {
+    const char = formula[index];
+    if (!char) break;
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    if (char === "," || char === "+" || char === "-" || char === "*" || char === "/" || char === "(" || char === ")") {
+      if (char === ",") tokens.push({ type: "comma", value: char });
+      else if (char === "(" || char === ")") tokens.push({ type: "paren", value: char });
+      else tokens.push({ type: "operator", value: char });
+      index += 1;
+      continue;
+    }
+    const numberMatch = formula.slice(index).match(/^(?:\d+(?:\.\d*)?|\.\d+)/);
+    if (numberMatch?.[0]) {
+      const value = Number.parseFloat(numberMatch[0]);
+      if (!Number.isFinite(value)) return null;
+      tokens.push({ type: "number", value });
+      index += numberMatch[0].length;
+      continue;
+    }
+    const identifierMatch = formula.slice(index).match(/^\$?[A-Z]+\$?[1-9]\d*(?::\$?[A-Z]+\$?[1-9]\d*)?|^[A-Z]+/i);
+    if (identifierMatch?.[0]) {
+      const value = identifierMatch[0].toUpperCase();
+      if (CELL_RANGE_RE.test(value)) tokens.push({ type: "range", value });
+      else if (parseTableCellAddress(value)) tokens.push({ type: "cell", value });
+      else if (SUPPORTED_FUNCTIONS.has(value)) tokens.push({ type: "function", value });
+      else return null;
+      index += identifierMatch[0].length;
+      continue;
+    }
+    return null;
+  }
+  return tokens;
+}
+function toFiniteFormulaResult(value) {
+  return Number.isFinite(value) ? { value, error: null } : { value: null, error: "invalid-formula" };
+}
+function parseTableCellNumericValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  let normalized = String(value ?? "").trim();
+  if (!normalized || normalized.startsWith("#")) return null;
+  const isPercent = normalized.endsWith("%");
+  if (isPercent) normalized = normalized.slice(0, -1).trim();
+  const currencyMatch = normalized.match(/^([+-]?)\$(.+)$/);
+  if (currencyMatch) {
+    normalized = `${currencyMatch[1] ?? ""}${currencyMatch[2] ?? ""}`.trim();
+  }
+  const groupedNumber = /^[+-]?\d{1,3}(?:,\d{3})+(?:\.\d*)?(?:[eE][+-]?\d+)?$/;
+  const plainNumber = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+  if (!groupedNumber.test(normalized) && !plainNumber.test(normalized)) return null;
+  const parsed = Number(normalized.replace(/,/g, ""));
+  if (!Number.isFinite(parsed)) return null;
+  return isPercent ? parsed / 100 : parsed;
+}
+var FormulaParser = class {
+  constructor(tokens, getCellValue) {
+    this.tokens = tokens;
+    this.getCellValue = getCellValue;
+    this.index = 0;
+  }
+  isComplete() {
+    return this.index >= this.tokens.length;
+  }
+  parseExpression() {
+    let left = this.parseTerm();
+    while (!left.error) {
+      const operator = this.peekOperator(["+", "-"]);
+      if (!operator) break;
+      this.index += 1;
+      const right = this.parseTerm();
+      if (right.error) return right;
+      left = toFiniteFormulaResult(operator.value === "+" ? left.value + right.value : left.value - right.value);
+    }
+    return left;
+  }
+  parseTerm() {
+    let left = this.parseFactor();
+    while (!left.error) {
+      const operator = this.peekOperator(["*", "/"]);
+      if (!operator) break;
+      this.index += 1;
+      const right = this.parseFactor();
+      if (right.error) return right;
+      if (operator.value === "/" && right.value === 0) {
+        return { value: null, error: "division-by-zero" };
+      }
+      left = toFiniteFormulaResult(operator.value === "*" ? left.value * right.value : left.value / right.value);
+    }
+    return left;
+  }
+  parseFactor() {
+    const token = this.tokens[this.index];
+    if (!token) {
+      return { value: null, error: "invalid-formula" };
+    }
+    if (token.type === "operator" && (token.value === "-" || token.value === "+")) {
+      this.index += 1;
+      const value = this.parseFactor();
+      if (value.error) return value;
+      return toFiniteFormulaResult(token.value === "-" ? -value.value : value.value);
+    }
+    if (token.type === "number") {
+      this.index += 1;
+      return { value: token.value, error: null };
+    }
+    if (token.type === "cell") {
+      this.index += 1;
+      return this.readCellNumber(token.value);
+    }
+    if (token.type === "function") {
+      return this.parseFunction(token.value);
+    }
+    if (token.type === "paren" && token.value === "(") {
+      this.index += 1;
+      const value = this.parseExpression();
+      if (value.error) return value;
+      if (!this.consumeParen(")")) {
+        return { value: null, error: "invalid-formula" };
+      }
+      return value;
+    }
+    return { value: null, error: "invalid-formula" };
+  }
+  parseFunction(name) {
+    this.index += 1;
+    if (!this.consumeParen("(")) {
+      return { value: null, error: "invalid-formula" };
+    }
+    const values = [];
+    while (true) {
+      const token = this.tokens[this.index];
+      if (!token) {
+        return { value: null, error: "invalid-formula" };
+      }
+      if (token.type === "range") {
+        this.index += 1;
+        const range = parseTableCellRange(token.value);
+        if (!range) return { value: null, error: "invalid-reference" };
+        for (const label of getTableCellRangeLabels(range)) {
+          if (name === "COUNT") {
+            const cellValue2 = this.readOptionalCellNumber(label);
+            if (cellValue2 != null) values.push(cellValue2);
+            continue;
+          }
+          const cellValue = this.readOptionalCellNumber(label);
+          if (cellValue != null) values.push(cellValue);
+        }
+      } else if (token.type === "cell") {
+        this.index += 1;
+        const cellValue = this.readOptionalCellNumber(token.value);
+        if (cellValue != null) values.push(cellValue);
+      } else {
+        const value = this.parseExpression();
+        if (value.error) return value;
+        values.push(value.value);
+      }
+      if (this.consumeComma()) {
+        continue;
+      }
+      if (this.consumeParen(")")) {
+        break;
+      }
+      return { value: null, error: "invalid-formula" };
+    }
+    if (name === "SUM") return toFiniteFormulaResult(values.reduce((sum, value) => sum + value, 0));
+    if (name === "AVG") {
+      return values.length > 0 ? toFiniteFormulaResult(values.reduce((sum, value) => sum + value, 0) / values.length) : { value: null, error: "division-by-zero" };
+    }
+    if (name === "MIN") return toFiniteFormulaResult(values.length > 0 ? Math.min(...values) : 0);
+    if (name === "MAX") return toFiniteFormulaResult(values.length > 0 ? Math.max(...values) : 0);
+    if (name === "COUNT") return { value: values.length, error: null };
+    return { value: null, error: "invalid-formula" };
+  }
+  readCellNumber(label) {
+    const address = parseTableCellAddress(label);
+    const parsed = address ? parseTableCellNumericValue(this.getCellValue(address.label)) : null;
+    if (parsed == null) {
+      return { value: null, error: "invalid-reference" };
+    }
+    return { value: parsed, error: null };
+  }
+  readOptionalCellNumber(label) {
+    const address = parseTableCellAddress(label);
+    return address ? parseTableCellNumericValue(this.getCellValue(address.label)) : null;
+  }
+  peekOperator(operators) {
+    const token = this.tokens[this.index];
+    return token?.type === "operator" && operators.includes(token.value) ? token : null;
+  }
+  consumeComma() {
+    if (this.tokens[this.index]?.type !== "comma") {
+      return false;
+    }
+    this.index += 1;
+    return true;
+  }
+  consumeParen(value) {
+    const token = this.tokens[this.index];
+    if (token?.type !== "paren" || token.value !== value) {
+      return false;
+    }
+    this.index += 1;
+    return true;
+  }
+};
+
+// src/components/UEditor/table-formula-references.ts
+var CELL_REFERENCE_RE = /(^|[^A-Z0-9_])(\$?)([A-Z]+)(\$?)([1-9]\d*)\b/gi;
+function rewriteTableFormulaReferences(formula, mapCoordinate) {
+  return formula.replace(CELL_REFERENCE_RE, (_match, prefix, columnMarker, columnName, rowMarker, rowNumber) => {
+    const column = columnNameToIndex(columnName);
+    const row = Number.parseInt(rowNumber, 10) - 1;
+    if (column < 0 || row < 0) return _match;
+    const mapped = mapCoordinate({
+      column,
+      row,
+      columnAbsolute: columnMarker === "$",
+      rowAbsolute: rowMarker === "$"
+    });
+    if (!mapped) return `${prefix}#REF!`;
+    return `${prefix}${columnMarker}${indexToColumnName(mapped.column)}${rowMarker}${mapped.row + 1}`;
+  });
+}
+function rewriteNodeFormulas(node, mapCoordinate) {
+  if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+    const formula = typeof node.attrs.formula === "string" ? node.attrs.formula : "";
+    if (!formula) return node;
+    const nextFormula = rewriteTableFormulaReferences(formula, mapCoordinate);
+    if (nextFormula === formula) return node;
+    return node.type.create({ ...node.attrs, formula: nextFormula, computedValue: null }, node.content, node.marks);
+  }
+  if (node.childCount === 0) return node;
+  const children = [];
+  let changed = false;
+  node.forEach((child) => {
+    const nextChild = rewriteNodeFormulas(child, mapCoordinate);
+    children.push(nextChild);
+    if (nextChild !== child) changed = true;
+  });
+  return changed ? node.type.create(node.attrs, children, node.marks) : node;
+}
+function rewriteTableNodeFormulaReferences(tableNode, mapCoordinate) {
+  return rewriteNodeFormulas(tableNode, mapCoordinate);
+}
+function rewriteTableNodeFormulaReferencesForInsertion(tableNode, axis, index, count = 1) {
+  return rewriteTableNodeFormulaReferences(tableNode, (coordinate) => {
+    const current = coordinate[axis];
+    return current >= index ? { ...coordinate, [axis]: current + count } : coordinate;
+  });
+}
+function rewriteTableNodeFormulaReferencesForDeletion(tableNode, axis, index, count = 1) {
+  const end = index + count;
+  return rewriteTableNodeFormulaReferences(tableNode, (coordinate) => {
+    const current = coordinate[axis];
+    if (current >= index && current < end) return null;
+    return current >= end ? { ...coordinate, [axis]: current - count } : coordinate;
+  });
+}
+function rewriteTableNodeFormulaReferencesForMove(tableNode, axis, from, to) {
+  if (from === to) return tableNode;
+  return rewriteTableNodeFormulaReferences(tableNode, (coordinate) => {
+    const current = coordinate[axis];
+    if (current === from) return { ...coordinate, [axis]: to };
+    if (from < to && current > from && current <= to) {
+      return { ...coordinate, [axis]: current - 1 };
+    }
+    if (from > to && current >= to && current < from) {
+      return { ...coordinate, [axis]: current + 1 };
+    }
+    return coordinate;
+  });
+}
+function shiftCopiedTableNodeFormulaReferences(node, axis, amount) {
+  return rewriteNodeFormulas(node, (coordinate) => {
+    const isAbsolute = axis === "column" ? coordinate.columnAbsolute : coordinate.rowAbsolute;
+    return {
+      ...coordinate,
+      [axis]: isAbsolute ? coordinate[axis] : Math.max(0, coordinate[axis] + amount)
+    };
+  });
+}
+
+// src/components/UEditor/table-cell-commands.ts
 function getCellSelectionPositions(selection) {
   const value = selection;
   const anchor = value.$anchorCell?.pos;
@@ -3062,7 +3966,11 @@ function collectChildren(node) {
   return children;
 }
 function createEmptyCellNode(cellNode) {
-  return cellNode.type.createAndFill(cellNode.attrs) ?? cellNode;
+  return cellNode.type.createAndFill({
+    ...cellNode.attrs,
+    formula: null,
+    computedValue: null
+  }) ?? cellNode;
 }
 function createCellCopyForColumnDuplicate(cellNode) {
   return cellNode.type.create(cellNode.attrs, cellNode.content);
@@ -3222,11 +4130,16 @@ function replaceTableAtCellPos(editor, cellPos, updateTable) {
 }
 function duplicateTableRowAt(editor, rowIndex, cellPos) {
   return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
-    const rows = collectChildren(tableNode);
+    const tableWithShiftedReferences = rewriteTableNodeFormulaReferencesForInsertion(
+      tableNode,
+      "row",
+      rowIndex + 1
+    );
+    const rows = collectChildren(tableWithShiftedReferences);
     const rowNode = rows[rowIndex];
     if (!rowNode) return null;
-    rows.splice(rowIndex + 1, 0, rowNode.copy(rowNode.content));
-    return tableNode.type.create(tableNode.attrs, rows);
+    rows.splice(rowIndex + 1, 0, shiftCopiedTableNodeFormulaReferences(rowNode, "row", 1));
+    return tableWithShiftedReferences.type.create(tableWithShiftedReferences.attrs, rows);
   });
 }
 function clearTableRowAt(editor, rowIndex, cellPos) {
@@ -3247,9 +4160,14 @@ function clearTableRowAt(editor, rowIndex, cellPos) {
 }
 function duplicateTableColumnAt(editor, columnIndex, cellPos) {
   return replaceTableAtCellPos(editor, cellPos, (tableNode) => {
-    const map = TableMap.get(tableNode);
+    const tableWithShiftedReferences = rewriteTableNodeFormulaReferencesForInsertion(
+      tableNode,
+      "column",
+      columnIndex + 1
+    );
+    const map = TableMap.get(tableWithShiftedReferences);
     if (columnIndex < 0 || columnIndex >= map.width) return null;
-    const rows = getTableRows(tableNode).map((rowInfo, rowIndex) => {
+    const rows = getTableRows(tableWithShiftedReferences).map((rowInfo, rowIndex) => {
       const cells = collectChildren(rowInfo.node);
       const sourceCell = rowInfo.cells.find((entry) => {
         const rect = safeFindCell(map, entry.relativePos);
@@ -3261,10 +4179,31 @@ function duplicateTableColumnAt(editor, columnIndex, cellPos) {
         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));
+      cells.splice(
+        sourceCell.index + 1,
+        0,
+        shiftCopiedTableNodeFormulaReferences(createCellCopyForColumnDuplicate(sourceCell.node), "column", 1)
+      );
       return rowInfo.node.type.create(rowInfo.node.attrs, cells);
     });
-    return tableNode.type.create(tableNode.attrs, rows);
+    const responsiveLayout = normalizeTableWidthMode(tableWithShiftedReferences.attrs.widthMode) === "responsive" ? insertResponsiveColumnLayout(
+      getResponsiveTableWidthBp(tableWithShiftedReferences),
+      getTableColumnRatios(tableWithShiftedReferences),
+      columnIndex + 1,
+      columnIndex
+    ) : null;
+    const tableAttrs = responsiveLayout ? {
+      ...tableWithShiftedReferences.attrs,
+      widthMode: "responsive",
+      widthBp: responsiveLayout.widthBp,
+      offsetBp: resolveResponsiveTableOffsetBp(
+        responsiveLayout.widthBp,
+        tableWithShiftedReferences.attrs.textAlign,
+        tableWithShiftedReferences.attrs.offsetBp
+      ),
+      columnRatios: responsiveLayout.columnRatios
+    } : tableWithShiftedReferences.attrs;
+    return tableWithShiftedReferences.type.create(tableAttrs, rows);
   });
 }
 function clearTableColumnAt(editor, columnIndex, cellPos) {
@@ -3500,14 +4439,6 @@ function useSharedEditorUiRenderState(editor) {
   }
   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));
 }
@@ -3553,7 +4484,7 @@ var TableInsertGrid = ({
   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(
+    /* @__PURE__ */ jsx7("div", { className: "grid grid-cols-8 gap-1", role: "grid", "aria-label": insertLabel, children: Array.from({ length: maxRows }).map(
       (_, rowIndex) => Array.from({ length: maxCols }).map((__, colIndex) => {
         const rows = rowIndex + 1;
         const cols = colIndex + 1;
@@ -3562,10 +4493,22 @@ var TableInsertGrid = ({
           "button",
           {
             type: "button",
+            role: "gridcell",
+            tabIndex: rows === selection.rows && cols === selection.cols ? 0 : -1,
+            "aria-selected": rows === selection.rows && cols === selection.cols,
+            "data-table-grid-cell": `${rows}-${cols}`,
             "aria-label": formatTableInsertLabel(previewTemplate, rows, cols),
             onMouseDown: (e) => e.preventDefault(),
             onMouseEnter: () => setSelection({ rows, cols }),
             onFocus: () => setSelection({ rows, cols }),
+            onKeyDown: (event) => {
+              const nextRows = event.key === "ArrowUp" ? Math.max(1, rows - 1) : event.key === "ArrowDown" ? Math.min(maxRows, rows + 1) : rows;
+              const nextCols = event.key === "ArrowLeft" ? Math.max(1, cols - 1) : event.key === "ArrowRight" ? Math.min(maxCols, cols + 1) : cols;
+              if (nextRows === rows && nextCols === cols) return;
+              event.preventDefault();
+              setSelection({ rows: nextRows, cols: nextCols });
+              event.currentTarget.parentElement?.querySelector(`[data-table-grid-cell="${nextRows}-${nextCols}"]`)?.focus();
+            },
             onClick: () => onInsert(rows, cols),
             className: cn(
               "h-5 w-5 rounded-sm border transition-colors",
@@ -3597,6 +4540,8 @@ var EditorToolbar = ({
   imageInsertMode = "base64",
   maxImageFileSize = DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE,
   allowedImageMimeTypes = DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
+  onImageUploadError,
+  fallbackToDataUrl = true,
   fontFamilies,
   defaultFontFamily = "Inter",
   fontSizes,
@@ -3655,28 +4600,36 @@ var EditorToolbar = ({
   const applyFontSizeDraft = () => {
     const parsed = Number.parseFloat(fontSizeDraft);
     if (!Number.isFinite(parsed)) return;
-    editor.chain().focus().setFontSize(`${parsed}px`).run();
-    setFontSizeDraft(String(parsed));
+    const clamped = Math.min(512, Math.max(8, parsed));
+    editor.chain().focus().setFontSize(`${clamped}px`).run();
+    setFontSizeDraft(String(clamped));
   };
   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"));
+    const trackedPosition = trackEditorInsertionPosition(editor);
+    try {
+      const { images, hadError } = await resolveUEditorImageFiles(files, {
+        maxFileSize: maxImageFileSize,
+        allowedMimeTypes: allowedImageMimeTypes,
+        upload: uploadImage,
+        fallbackToDataUrl,
+        insertMode: imageInsertMode,
+        onError: onImageUploadError
+      });
+      if (hadError) setImageUploadError(t("imageInput.uploadError"));
+      if (!editor.isDestroyed && images.length > 0) {
+        const content = images.map((image) => ({
+          type: "image",
+          attrs: { src: image.src, alt: image.file.name }
+        }));
+        editor.commands.insertContentAt(trackedPosition.current, content, { updateSelection: false });
       }
+    } finally {
+      trackedPosition.stop();
+      setIsUploadingImage(false);
     }
-    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: [
@@ -3831,6 +4784,8 @@ var EditorToolbar = ({
                 "input",
                 {
                   type: "number",
+                  min: 8,
+                  max: 512,
                   step: 1,
                   value: isEditingFontSize ? fontSizeDraft : displayedFontSizeLabel,
                   onFocus: () => {
@@ -4380,7 +5335,7 @@ var EditorToolbar = ({
                 {
                   ref: fileInputRef,
                   type: "file",
-                  accept: "image/*",
+                  accept: allowedImageMimeTypes.length > 0 ? allowedImageMimeTypes.join(",") : "image/*",
                   multiple: true,
                   className: "hidden",
                   onChange: (e) => {
@@ -4769,6 +5724,25 @@ export {
   DropdownMenu_default,
   isSafeUEditorUrl,
   sanitizeUEditorUrl,
+  TABLE_WIDTH_BASIS_POINTS,
+  DEFAULT_RESPONSIVE_TABLE_WIDTH_BP,
+  clampResponsiveTableWidthBp,
+  normalizeTableWidthMode,
+  parsePercentageToBasisPoints,
+  formatBasisPointsAsPercentage,
+  parseColumnRatios,
+  normalizeColumnRatios,
+  getLogicalTableColumnCount,
+  getLegacyTableColumnWeights,
+  getTableColumnRatios,
+  getResponsiveTableWidthBp,
+  getResponsiveTableOffsetBp,
+  resolveResponsiveTableOffsetBp,
+  moveResponsiveColumnRatio,
+  insertResponsiveColumnLayout,
+  deleteResponsiveColumnLayout,
+  trackEditorInsertionPosition,
+  resolveUEditorImageFiles,
   DEFAULT_UEDITOR_IMAGE_MAX_FILE_SIZE,
   DEFAULT_UEDITOR_IMAGE_MIME_TYPES,
   ClipboardImages,
@@ -4796,6 +5770,21 @@ export {
   getRelativeSelectedCellsMetrics,
   findTableNodeInfoFromState,
   applyTableAlignment,
+  indexToColumnName,
+  parseTableCellRange,
+  getTableCellRangeLabels,
+  normalizeTableFormula,
+  isDraftTableFormula,
+  formatFormulaError,
+  formatTableFormulaDisplayValue,
+  getTableFormulaReferences,
+  buildTableFormulaDependencyGraph,
+  getTableFormulaRecalculationOrder,
+  getAffectedTableFormulaLabels,
+  evaluateBasicTableFormula,
+  rewriteTableNodeFormulaReferencesForInsertion,
+  rewriteTableNodeFormulaReferencesForDeletion,
+  rewriteTableNodeFormulaReferencesForMove,
   dispatchTableLayoutChange,
   mergeTableCellsPreservingColumnWidths,
   runTableCommandAtCellPos,
@@ -4823,10 +5812,9 @@ export {
   getTableAnchorPos,
   EditorUiRenderStateProvider,
   useSharedEditorUiRenderState,
-  fileToDataUrl2 as fileToDataUrl,
   ToolbarButton,
   TableInsertGrid,
   EditorToolbar,
   UEDITOR_PROSEMIRROR_CLASS_NAME
 };
-//# sourceMappingURL=chunk-KTOXCD6J.js.map
+//# sourceMappingURL=chunk-37MHVJMV.js.map