@superdoc-dev/cli 0.8.0-next.35 → 0.8.0-next.37

package/dist/index.js

@@ -65806,7 +65806,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-BTy5lByv.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-Dchjy0My.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -114303,18 +114303,78 @@ var isRegExp = (value) => {
     return twipsToPixels(resolveContentWidthTwips() * percent / 100);
   }
   return null;
+}, getRawRowGridMetadata = (row) => {
+  const trPr = row?.elements?.find((element) => element.name === "w:trPr");
+  const getChild = (name) => trPr?.elements?.find((element) => element.name === name);
+  const parseCount = (name) => {
+    const rawValue = getChild(name)?.attributes?.["w:val"];
+    const value = typeof rawValue === "number" ? rawValue : Number.parseInt(rawValue || "0", 10);
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  };
+  const parseMeasurement = (name) => {
+    const node3 = getChild(name);
+    if (!node3?.attributes)
+      return null;
+    const rawValue = node3.attributes["w:w"];
+    const value = typeof rawValue === "number" ? rawValue : Number.parseInt(rawValue || "", 10);
+    if (!Number.isFinite(value) || value <= 0)
+      return null;
+    return {
+      value,
+      type: node3.attributes["w:type"] || "dxa"
+    };
+  };
+  return {
+    gridBefore: parseCount("w:gridBefore"),
+    gridAfter: parseCount("w:gridAfter"),
+    wBefore: parseMeasurement("w:wBefore"),
+    wAfter: parseMeasurement("w:wAfter")
+  };
 }, countColumnsInRow = (row) => {
   if (!row?.elements?.length)
     return 0;
-  return row.elements.reduce((count2, element) => {
+  const { gridBefore, gridAfter } = getRawRowGridMetadata(row);
+  return gridBefore + row.elements.reduce((count2, element) => {
     if (element.name !== "w:tc")
       return count2;
     const gridSpan = element.elements?.find((el) => el.name === "w:tcPr")?.elements?.find((el) => el.name === "w:gridSpan");
     const spanValue = parseInt(gridSpan?.attributes?.["w:val"] || "1", 10);
     return count2 + (Number.isFinite(spanValue) && spanValue > 0 ? spanValue : 1);
-  }, 0);
-}, clampColumnWidthTwips = (value) => Math.max(Math.round(value), MIN_COLUMN_WIDTH_TWIPS), createFallbackGrid = (columnCount, columnWidthTwips) => Array.from({ length: columnCount }, () => ({ col: clampColumnWidthTwips(columnWidthTwips) })), buildFallbackGridForTable = ({ params: params3, rows, tableWidth, tableWidthMeasurement }) => {
-  const columnCount = countColumnsInRow(rows.find((row) => row.elements?.some((el) => el.name === "w:tc")));
+  }, 0) + gridAfter;
+}, clampColumnWidthTwips = (value) => Math.max(Math.round(value), MIN_COLUMN_WIDTH_TWIPS), resolveSkippedColumnSeedWidthsTwips = (measurement, span) => {
+  if (!measurement || !Number.isFinite(span) || span <= 0)
+    return [];
+  const resolvedPx = resolveMeasurementWidthPx(measurement);
+  if (resolvedPx == null || resolvedPx <= 0)
+    return [];
+  const totalTwips = clampColumnWidthTwips(pixelsToTwips(resolvedPx));
+  const baseWidth = Math.floor(totalTwips / span);
+  const remainder = totalTwips - baseWidth * span;
+  return Array.from({ length: span }, (_, index2) => clampColumnWidthTwips(baseWidth + (index2 < remainder ? 1 : 0)));
+}, buildFallbackColumnWidthTwips = ({ columnCount, totalWidthTwips, rows }) => {
+  const seededWidths = new Array(columnCount).fill(null);
+  for (const row of rows) {
+    const { gridBefore, gridAfter, wBefore, wAfter } = getRawRowGridMetadata(row);
+    if (gridBefore > 0)
+      resolveSkippedColumnSeedWidthsTwips(wBefore, gridBefore).forEach((widthTwips, index2) => {
+        if (index2 < columnCount)
+          seededWidths[index2] = Math.max(seededWidths[index2] ?? 0, widthTwips);
+      });
+    if (gridAfter > 0)
+      resolveSkippedColumnSeedWidthsTwips(wAfter, gridAfter).forEach((widthTwips, index2) => {
+        const targetIndex = columnCount - gridAfter + index2;
+        if (targetIndex >= 0 && targetIndex < columnCount)
+          seededWidths[targetIndex] = Math.max(seededWidths[targetIndex] ?? 0, widthTwips);
+      });
+  }
+  const seededTotalTwips = seededWidths.reduce((sum, widthTwips) => sum + (widthTwips ?? 0), 0);
+  const remainingColumns = seededWidths.filter((widthTwips) => widthTwips == null).length;
+  const minimumRemainingTwips = remainingColumns * MIN_COLUMN_WIDTH_TWIPS;
+  const effectiveTotalTwips = Math.max(totalWidthTwips, seededTotalTwips + minimumRemainingTwips);
+  const defaultRemainingTwips = remainingColumns > 0 ? clampColumnWidthTwips((effectiveTotalTwips - seededTotalTwips) / remainingColumns) : 0;
+  return seededWidths.map((widthTwips) => clampColumnWidthTwips(widthTwips ?? defaultRemainingTwips));
+}, buildFallbackGridForTable = ({ params: params3, rows, tableWidth, tableWidthMeasurement }) => {
+  const columnCount = rows.reduce((max4, row) => Math.max(max4, countColumnsInRow(row)), 0);
   if (!columnCount)
     return null;
   const schemaDefaultPx = getSchemaDefaultColumnWidthPx(params3);
@@ -114329,11 +114389,15 @@ var isRegExp = (value) => {
     totalWidthPx = tableWidth.width;
   if (totalWidthPx == null)
     totalWidthPx = twipsToPixels(DEFAULT_CONTENT_WIDTH_TWIPS);
-  const columnWidthTwips = clampColumnWidthTwips(pixelsToTwips(Math.max(totalWidthPx / columnCount, minimumColumnWidthPx)));
-  const fallbackColumnWidthPx = twipsToPixels(columnWidthTwips);
+  const minimumColumnWidthTwips = clampColumnWidthTwips(pixelsToTwips(minimumColumnWidthPx));
+  const fallbackColumnWidthTwips = buildFallbackColumnWidthTwips({
+    columnCount,
+    totalWidthTwips: Math.max(clampColumnWidthTwips(pixelsToTwips(totalWidthPx)), minimumColumnWidthTwips * columnCount),
+    rows
+  });
   return {
-    grid: createFallbackGrid(columnCount, columnWidthTwips),
-    columnWidths: Array(columnCount).fill(fallbackColumnWidthPx)
+    grid: fallbackColumnWidthTwips.map((columnWidthTwips) => ({ col: clampColumnWidthTwips(columnWidthTwips) })),
+    columnWidths: fallbackColumnWidthTwips.map((columnWidthTwips) => twipsToPixels(columnWidthTwips))
   };
 }, translator$69, XML_NODE_NAME$26 = "w:tblGrid", SD_ATTR_KEY$2 = "grid", cellMinWidth, encode$43 = (params3) => {
   const { nodes } = params3;
@@ -118203,7 +118267,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_BTy5lByv_es = __esm(() => {
+var init_SuperConverter_Dchjy0My_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -155798,7 +155862,7 @@ var init_SuperConverter_BTy5lByv_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-k6nNYL53.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-CEcVKzGV.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -158434,8 +158498,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, Extension = class Extension2 {
     }
   };
 };
-var init_create_headless_toolbar_k6nNYL53_es = __esm(() => {
-  init_SuperConverter_BTy5lByv_es();
+var init_create_headless_toolbar_CEcVKzGV_es = __esm(() => {
+  init_SuperConverter_Dchjy0My_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   CSS_DIMENSION_REGEX = /[\d-.]+(\w+)$/;
@@ -207122,7 +207186,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-BzRjWTpH.es.js
+// ../../packages/superdoc/dist/chunks/src-DAF1K-X-.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -207377,7 +207441,7 @@ function getCellSpacingPx(cellSpacing) {
   const v = cellSpacing.value;
   if (typeof v !== "number" || !Number.isFinite(v))
     return 0;
-  const asPx = (cellSpacing.type ?? "").toLowerCase() === "dxa" && v >= 20 ? v / TWIPS_PER_PX$2 : v;
+  const asPx = (cellSpacing.type ?? "").toLowerCase() === "dxa" && v >= 20 ? v / TWIPS_PER_PX$3 : v;
   return Math.max(0, asPx);
 }
 function coerceRelativeHeight(raw) {
@@ -208961,6 +209025,7 @@ function createStructuredContentSelectPlugin(editor) {
         return false;
       const { state } = view;
       const { selection } = state;
+      const isEditableSlotText = (text5) => text5.replace(/\u200B/g, "").length === 0;
       const resolveBoundaryExit = ($pos) => {
         for (let depth = $pos.depth;depth > 0; depth -= 1) {
           const node3 = $pos.node(depth);
@@ -208972,9 +209037,13 @@ function createStructuredContentSelectPlugin(editor) {
           const beforePos = nodePos;
           const afterPos = nodePos + node3.nodeSize;
           if (selection.empty) {
-            if (event.key === "ArrowRight" && selection.from >= contentTo - 1)
+            const trailingSlice = state.doc.textBetween(selection.from, contentTo, "", INLINE_LEAF_TEXT);
+            const leadingSlice = state.doc.textBetween(contentFrom, selection.from, "", INLINE_LEAF_TEXT);
+            const onlyTrailingEditableSlots = trailingSlice.length > 0 && isEditableSlotText(trailingSlice);
+            const onlyLeadingEditableSlots = leadingSlice.length > 0 && isEditableSlotText(leadingSlice);
+            if (event.key === "ArrowRight" && (selection.from >= contentTo - 1 || onlyTrailingEditableSlots))
               return afterPos;
-            if (event.key === "ArrowLeft" && selection.from <= contentFrom + 1)
+            if (event.key === "ArrowLeft" && (selection.from <= contentFrom + 1 || onlyLeadingEditableSlots))
               return beforePos;
             return null;
           }
@@ -234562,29 +234631,12 @@ function toTableFailure(code7, message, details) {
     }
   };
 }
-function createSeparatorParagraph(schema) {
-  const paragraphType = schema.nodes.paragraph;
-  if (!paragraphType)
-    return null;
-  const separatorAttrs = {
-    sdBlockId: v4_default(),
-    paraId: generateDocxHexId()
-  };
-  return paragraphType.createAndFill(separatorAttrs) ?? paragraphType.createAndFill();
-}
-function buildTableSuccess(tableAddress, trackedChangeRefs) {
-  return {
-    success: true,
-    table: tableAddress,
-    trackedChangeRefs
-  };
-}
 function syncExtractedTableAttrs(tp) {
   const extracted = {};
   extracted.tableStyleId = tp.tableStyleId ?? null;
   extracted.justification = tp.justification ?? null;
   extracted.tableLayout = tp.tableLayout ?? null;
-  extracted.borders = convertTableBordersToPixelUnits(tp.borders) ?? tp.borders ?? null;
+  extracted.borders = convertTableBordersToPixelUnits(tp.borders) ?? {};
   const indent2 = tp.tableIndent;
   if (indent2?.value != null)
     extracted.tableIndent = {
@@ -234596,7 +234648,7 @@ function syncExtractedTableAttrs(tp) {
   const spacing = tp.tableCellSpacing;
   if (spacing?.value != null) {
     extracted.tableCellSpacing = {
-      w: String(spacing.value),
+      value: twipsToPixels(spacing.value),
       type: spacing.type ?? "dxa"
     };
     extracted.borderCollapse = "separate";
@@ -234604,23 +234656,23 @@ function syncExtractedTableAttrs(tp) {
     extracted.tableCellSpacing = null;
     extracted.borderCollapse = null;
   }
-  const tw = tp.tableWidth;
-  if (tw)
-    if (tw.type === "pct" && typeof tw.value === "number")
+  const width = tp.tableWidth;
+  if (width)
+    if (width.type === "pct" && typeof width.value === "number")
       extracted.tableWidth = {
-        value: tw.value,
+        value: width.value,
         type: "pct"
       };
-    else if (tw.type === "auto")
+    else if (width.type === "auto")
       extracted.tableWidth = {
         width: 0,
         type: "auto"
       };
-    else if (tw.value != null) {
-      const widthPx = twipsToPixels(tw.value);
+    else if (width.value != null) {
+      const widthPx = twipsToPixels(width.value);
       extracted.tableWidth = widthPx != null ? {
         width: widthPx,
-        type: tw.type
+        type: width.type
       } : null;
     } else
       extracted.tableWidth = null;
@@ -234635,6 +234687,95 @@ function convertTableBordersToPixelUnits(value) {
   mapBorderSizes(clone, eighthPointsToPixels);
   return Object.keys(clone).length > 0 ? clone : undefined;
 }
+function buildWidthAuthoringTableAttrs(currentAttrs, attrOverrides = {}, tablePropertyOverrides = {}) {
+  const currentTableProps = currentAttrs.tableProperties ?? {};
+  const nextTableWidth = resolveWidthAuthoringTableWidth(currentAttrs, attrOverrides, tablePropertyOverrides);
+  const updatedTableProps = {
+    ...currentTableProps,
+    ...tablePropertyOverrides,
+    tableLayout: "fixed"
+  };
+  if (nextTableWidth)
+    updatedTableProps.tableWidth = nextTableWidth;
+  else
+    delete updatedTableProps.tableWidth;
+  return {
+    ...currentAttrs,
+    tableProperties: updatedTableProps,
+    ...attrOverrides,
+    ...syncExtractedTableAttrs(updatedTableProps),
+    userEdited: true
+  };
+}
+function resolveWidthAuthoringTableWidth(currentAttrs, attrOverrides, tablePropertyOverrides) {
+  const explicitOverride = normalizeTableWidthMeasurement(tablePropertyOverrides.tableWidth);
+  if (explicitOverride)
+    return explicitOverride;
+  const gridWidth = sumGridColumnTwips(attrOverrides.grid ?? currentAttrs.grid);
+  if (gridWidth != null)
+    return {
+      value: gridWidth,
+      type: "dxa"
+    };
+  return null;
+}
+function sumGridColumnTwips(grid) {
+  const columns = normalizeGridColumns$1(grid);
+  if (!columns || columns.length === 0)
+    return null;
+  const total = columns.reduce((sum, column) => sum + column.col, 0);
+  return total > 0 ? total : null;
+}
+function normalizeGridColumns$1(grid) {
+  if (Array.isArray(grid)) {
+    const columns = grid.map((width) => normalizeGridWidth$1(width)).filter((width) => width != null);
+    return columns.length > 0 ? columns : null;
+  }
+  if (grid && typeof grid === "object") {
+    const rawColWidths = grid.colWidths;
+    if (Array.isArray(rawColWidths)) {
+      const columns = rawColWidths.map((width) => normalizeGridWidth$1(width)).filter((width) => width != null);
+      return columns.length > 0 ? columns : null;
+    }
+  }
+  return null;
+}
+function normalizeGridWidth$1(width) {
+  if (typeof width === "number" && Number.isFinite(width) && width > 0)
+    return { col: Math.round(width) };
+  const value = width?.col;
+  if (typeof value === "number" && Number.isFinite(value) && value > 0)
+    return { col: Math.round(value) };
+  return null;
+}
+function normalizeTableWidthMeasurement(width) {
+  if (!width || typeof width !== "object")
+    return null;
+  const value = width.value;
+  if (width.type !== "dxa" || typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return null;
+  return {
+    value: Math.round(value),
+    type: "dxa"
+  };
+}
+function createSeparatorParagraph(schema) {
+  const paragraphType = schema.nodes.paragraph;
+  if (!paragraphType)
+    return null;
+  const separatorAttrs = {
+    sdBlockId: v4_default(),
+    paraId: generateDocxHexId()
+  };
+  return paragraphType.createAndFill(separatorAttrs) ?? paragraphType.createAndFill();
+}
+function buildTableSuccess(tableAddress, trackedChangeRefs) {
+  return {
+    success: true,
+    table: tableAddress,
+    trackedChangeRefs
+  };
+}
 function normalizeGridWidth(width) {
   if (typeof width === "number" && Number.isFinite(width))
     return { col: Math.round(width) };
@@ -234697,6 +234838,30 @@ function removeGridColumnWidth(grid, deleteIndex) {
     columns: colWidths
   });
 }
+function buildFirstRowCellWidthProps(attrs, cellStartCol, colspan, colwidth, gridColumns) {
+  const currentCellProps = attrs.tableCellProperties && typeof attrs.tableCellProperties === "object" ? attrs.tableCellProperties : {};
+  const spanTwips = resolveSpanWidthTwips(cellStartCol, colspan, colwidth, gridColumns);
+  if (spanTwips == null)
+    return Object.keys(currentCellProps).length > 0 ? currentCellProps : undefined;
+  return {
+    ...currentCellProps,
+    cellWidth: {
+      value: spanTwips,
+      type: "dxa"
+    }
+  };
+}
+function resolveSpanWidthTwips(cellStartCol, colspan, colwidth, gridColumns) {
+  const boundedSpan = Math.max(1, colspan);
+  if (Array.isArray(gridColumns) && cellStartCol >= 0 && cellStartCol + boundedSpan <= gridColumns.length) {
+    const gridSpanTwips = gridColumns.slice(cellStartCol, cellStartCol + boundedSpan).reduce((sum, column) => sum + normalizeGridWidth(column).col, 0);
+    if (gridSpanTwips > 0)
+      return gridSpanTwips;
+  }
+  const spanWidthPx = colwidth.slice(0, boundedSpan).reduce((sum, width) => sum + (Number.isFinite(width) ? width : 0), 0);
+  if (spanWidthPx > 0)
+    return Math.round(spanWidthPx * PIXELS_TO_TWIPS);
+}
 function normalizeCellAttrsForSingleCell(attrs) {
   const currentColwidth = Array.isArray(attrs.colwidth) ? attrs.colwidth : null;
   const tableCellProperties = { ...attrs.tableCellProperties ?? {} };
@@ -235574,8 +235739,13 @@ function tablesSetColumnWidthAdapter(editor, input2, options) {
     const tablePos = table2.candidate.pos;
     const tableStart = tablePos + 1;
     const tableNode = table2.candidate.node;
+    const tableAttrs = tableNode.attrs;
     const map$12 = TableMap.get(tableNode);
     const widthPx = Math.round(input2.widthPt * (96 / 72));
+    const normalizedGrid = normalizeGridColumns(tableAttrs.grid);
+    const nextGridColumns = normalizedGrid?.columns.slice();
+    if (nextGridColumns && columnIndex < nextGridColumns.length)
+      nextGridColumns[columnIndex] = { col: Math.round(input2.widthPt * POINTS_TO_TWIPS) };
     const processed = /* @__PURE__ */ new Set;
     for (let row2 = 0;row2 < map$12.height; row2++) {
       const index2 = row2 * map$12.width + columnIndex;
@@ -235589,29 +235759,31 @@ function tablesSetColumnWidthAdapter(editor, input2, options) {
       const attrs = cell2.attrs;
       const colspan = attrs.colspan || 1;
       const colwidth = attrs.colwidth?.slice() ?? [];
-      const withinCol = columnIndex - map$12.colCount(pos);
+      const cellStartCol = map$12.colCount(pos);
+      const withinCol = columnIndex - cellStartCol;
       while (colwidth.length < colspan)
         colwidth.push(0);
       colwidth[withinCol] = widthPx;
-      tr.setNodeMarkup(tableStart + pos, null, {
+      const nextAttrs = {
         ...attrs,
         colwidth
-      });
+      };
+      if (row2 === 0) {
+        const nextCellProps = buildFirstRowCellWidthProps(attrs, cellStartCol, colspan, colwidth, nextGridColumns);
+        if (nextCellProps)
+          nextAttrs.tableCellProperties = nextCellProps;
+        else
+          delete nextAttrs.tableCellProperties;
+      }
+      tr.setNodeMarkup(tableStart + pos, null, nextAttrs);
     }
-    const tableAttrs = tableNode.attrs;
-    const normalizedGrid = normalizeGridColumns(tableAttrs.grid);
-    if (normalizedGrid && columnIndex < normalizedGrid.columns.length) {
-      const newColumns = normalizedGrid.columns.slice();
-      newColumns[columnIndex] = { col: Math.round(input2.widthPt * POINTS_TO_TWIPS) };
-      tr.setNodeMarkup(tablePos, null, {
-        ...tableAttrs,
-        grid: serializeGridColumns(tableAttrs.grid, {
-          ...normalizedGrid,
-          columns: newColumns
-        }),
-        userEdited: true
+    const tableAttrUpdates = {};
+    if (normalizedGrid && nextGridColumns)
+      tableAttrUpdates.grid = serializeGridColumns(tableAttrs.grid, {
+        ...normalizedGrid,
+        columns: nextGridColumns
       });
-    }
+    tr.setNodeMarkup(tablePos, null, buildWidthAuthoringTableAttrs(tableAttrs, tableAttrUpdates));
     applyDirectMutationMeta(tr);
     editor.dispatch(tr);
     clearIndexCache(editor);
@@ -235635,7 +235807,10 @@ function tablesDistributeColumnsAdapter(editor, input2, options) {
     const tablePos = candidate.pos;
     const tableStart = tablePos + 1;
     const tableNode = candidate.node;
+    const tableAttrs = tableNode.attrs;
     const map$12 = TableMap.get(tableNode);
+    const normalizedGrid = normalizeGridColumns(tableAttrs.grid);
+    const nextGridColumns = normalizedGrid?.columns.slice();
     const rangeStart = input2.columnRange?.start ?? 0;
     const rangeEnd = input2.columnRange?.end ?? map$12.width - 1;
     const rangeWidth = rangeEnd - rangeStart + 1;
@@ -235651,6 +235826,12 @@ function tablesDistributeColumnsAdapter(editor, input2, options) {
       totalWidth += colwidth?.[withinCol] ?? 100;
     }
     const evenWidth = Math.round(totalWidth / rangeWidth);
+    if (nextGridColumns) {
+      const evenWidthTwips = Math.max(1, Math.round(evenWidth * PIXELS_TO_TWIPS));
+      const maxColumn = Math.min(rangeEnd, nextGridColumns.length - 1);
+      for (let col = Math.max(rangeStart, 0);col <= maxColumn; col++)
+        nextGridColumns[col] = { col: evenWidthTwips };
+    }
     const processed = /* @__PURE__ */ new Set;
     for (let row2 = 0;row2 < map$12.height; row2++)
       for (let col = rangeStart;col <= rangeEnd; col++) {
@@ -235673,29 +235854,26 @@ function tablesDistributeColumnsAdapter(editor, input2, options) {
           if (absCol >= rangeStart && absCol <= rangeEnd)
             newColwidth[c] = evenWidth;
         }
-        tr.setNodeMarkup(tableStart + pos, null, {
+        const nextAttrs = {
           ...attrs,
           colwidth: newColwidth
-        });
+        };
+        if (row2 === 0) {
+          const nextCellProps = buildFirstRowCellWidthProps(attrs, cellStartCol, colspan, newColwidth, nextGridColumns);
+          if (nextCellProps)
+            nextAttrs.tableCellProperties = nextCellProps;
+          else
+            delete nextAttrs.tableCellProperties;
+        }
+        tr.setNodeMarkup(tableStart + pos, null, nextAttrs);
       }
-    const tableAttrs = tableNode.attrs;
-    const normalizedGrid = normalizeGridColumns(tableAttrs.grid);
-    const tableAttrUpdates = {
-      ...tableAttrs,
-      userEdited: true
-    };
-    if (normalizedGrid) {
-      const newColumns = normalizedGrid.columns.slice();
-      const evenWidthTwips = Math.max(1, Math.round(evenWidth * PIXELS_TO_TWIPS));
-      const maxColumn = Math.min(rangeEnd, newColumns.length - 1);
-      for (let col = Math.max(rangeStart, 0);col <= maxColumn; col++)
-        newColumns[col] = { col: evenWidthTwips };
+    const tableAttrUpdates = {};
+    if (normalizedGrid && nextGridColumns)
       tableAttrUpdates.grid = serializeGridColumns(tableAttrs.grid, {
         ...normalizedGrid,
-        columns: newColumns
+        columns: nextGridColumns
       });
-    }
-    tr.setNodeMarkup(tablePos, null, tableAttrUpdates);
+    tr.setNodeMarkup(tablePos, null, buildWidthAuthoringTableAttrs(tableAttrs, tableAttrUpdates));
     applyDirectMutationMeta(tr);
     editor.dispatch(tr);
     clearIndexCache(editor);
@@ -236279,6 +236457,10 @@ function tablesSetCellPropertiesAdapter(editor, input2, options) {
       }
     };
     tr.setNodeMarkup(cellPos, null, newAttrs);
+    if (input2.preferredWidthPt !== undefined) {
+      const tableAttrs = table2.candidate.node.attrs;
+      tr.setNodeMarkup(table2.candidate.pos, null, buildWidthAuthoringTableAttrs(tableAttrs));
+    }
     applyDirectMutationMeta(tr);
     editor.dispatch(tr);
     clearIndexCache(editor);
@@ -250810,7 +250992,7 @@ function normalizeFieldAnnotationMetadata(attrs) {
     borderColor: normalizeColorValue2(attrs.borderColor),
     highlighted: toBoolean$2(attrs.highlighted, true),
     fontFamily: toNullableString(attrs.fontFamily),
-    fontSize: normalizeFontSize$1(attrs.fontSize),
+    fontSize: normalizeFontSize$2(attrs.fontSize),
     textColor: normalizeColorValue2(attrs.textColor) ?? null,
     textHighlight: normalizeColorValue2(attrs.textHighlight) ?? null,
     linkUrl: toNullableString(attrs.linkUrl),
@@ -250904,7 +251086,7 @@ function normalizeColorValue2(value) {
     return;
   return trimmed;
 }
-function normalizeFontSize$1(value) {
+function normalizeFontSize$2(value) {
   if (value == null)
     return null;
   if (typeof value === "number")
@@ -252506,11 +252688,15 @@ function tableNodeToBlock(node3, { nextBlockId, positions, storyKey, trackedChan
     tableAttrs.tableWidth = hydratedTableStyle.tableWidth;
   if (node3.attrs?.tableIndent && typeof node3.attrs.tableIndent === "object")
     tableAttrs.tableIndent = { ...node3.attrs.tableIndent };
+  else if (hydratedTableStyle?.tableIndent)
+    tableAttrs.tableIndent = { ...hydratedTableStyle.tableIndent };
   if (defaultCellPadding && typeof defaultCellPadding === "object")
     tableAttrs.defaultCellPadding = { ...defaultCellPadding };
   const tableLayout = node3.attrs?.tableLayout;
   if (tableLayout)
     tableAttrs.tableLayout = tableLayout;
+  else if (hydratedTableStyle?.tableLayout)
+    tableAttrs.tableLayout = hydratedTableStyle.tableLayout;
   const tableProperties = node3.attrs?.tableProperties;
   if (tableProperties && typeof tableProperties === "object")
     tableAttrs.tableProperties = tableProperties;
@@ -257429,7 +257615,7 @@ function measureCharacterX(block, line, charOffset, availableWidthOverride, alig
     }
     const text5 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? "" : run2.text ?? "";
     const runLength = text5.length;
-    const displayText = applyTextTransform$2(text5, isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? undefined : run2.textTransform);
+    const displayText = applyTextTransform$3(text5, isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? undefined : run2.textTransform);
     if (currentCharOffset + runLength >= charOffset) {
       const offsetInRun = charOffset - currentCharOffset;
       ctx$1.font = getRunFontString(run2);
@@ -257478,7 +257664,7 @@ function measureCharacterXSegmentBased(block, line, charOffset, ctx$1) {
         return segmentBaseX + (offsetInSegment > 0 ? segment.width ?? 0 : 0);
       if ("src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math")
         return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
-      const textUpToTarget = applyTextTransform$2(run2.text ?? "", "textTransform" in run2 ? run2.textTransform : undefined).slice(segment.fromChar, segment.toChar).slice(0, offsetInSegment);
+      const textUpToTarget = applyTextTransform$3(run2.text ?? "", "textTransform" in run2 ? run2.textTransform : undefined).slice(segment.fromChar, segment.toChar).slice(0, offsetInSegment);
       ctx$1.font = getRunFontString(run2);
       const measured = ctx$1.measureText(textUpToTarget);
       const spacingWidth = computeLetterSpacingWidth(run2, offsetInSegment, segmentChars);
@@ -257571,7 +257757,7 @@ function findCharacterAtX(block, line, x, pmStart, availableWidthOverride, align
     }
     const text5 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? "" : run2.text ?? "";
     const runLength = text5.length;
-    const displayText = applyTextTransform$2(text5, isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? undefined : run2.textTransform);
+    const displayText = applyTextTransform$3(text5, isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" || run2.kind === "math" ? undefined : run2.textTransform);
     if (runLength === 0)
       continue;
     ctx$1.font = getRunFontString(run2);
@@ -258214,7 +258400,7 @@ function measureRunSliceWidth(run2, fromChar, toChar) {
   const context = getCtx();
   const fullText = runText(run2);
   const transform = isTextRun$3(run2) ? run2.textTransform : undefined;
-  const text5 = applyTextTransform$1(fullText.slice(fromChar, toChar), transform, fullText, fromChar);
+  const text5 = applyTextTransform$2(fullText.slice(fromChar, toChar), transform, fullText, fromChar);
   if (!context) {
     const size$1 = (isTextRun$3(run2) ? run2 : null)?.fontSize ?? 16;
     return Math.max(1, text5.length * (size$1 * 0.6));
@@ -261481,7 +261667,7 @@ function areNumberListsEqual(left$1, right$1) {
       return false;
   return true;
 }
-function isWordCharacter(char) {
+function isWordCharacter$1(char) {
   if (!char)
     return false;
   return WORD_CHARACTER_REGEX.test(char);
@@ -261564,17 +261750,17 @@ function computeWordSelectionRangeAt(state, pos) {
   const parentStart = textblockPos.start();
   const parentEnd = textblockPos.end();
   const sampleEnd = Math.min(pos + 1, parentEnd);
-  if (!isWordCharacter(state.doc.textBetween(pos, sampleEnd, "\x00", "\x00")))
+  if (!isWordCharacter$1(state.doc.textBetween(pos, sampleEnd, "\x00", "\x00")))
     return null;
   let startPos = pos;
   while (startPos > parentStart) {
-    if (!isWordCharacter(state.doc.textBetween(startPos - 1, startPos, "\x00", "\x00")))
+    if (!isWordCharacter$1(state.doc.textBetween(startPos - 1, startPos, "\x00", "\x00")))
       break;
     startPos -= 1;
   }
   let endPos = pos;
   while (endPos < parentEnd) {
-    if (!isWordCharacter(state.doc.textBetween(endPos, endPos + 1, "\x00", "\x00")))
+    if (!isWordCharacter$1(state.doc.textBetween(endPos, endPos + 1, "\x00", "\x00")))
       break;
     endPos += 1;
   }
@@ -264845,6 +265031,1369 @@ function getFontMetrics(ctx$1, fontInfo, mode, fonts) {
   fontMetricsCache.set(key2, result);
   return result;
 }
+function computeFixedTableColumnWidths(input2) {
+  const gridColumnCount = Math.max(0, sanitizeColumnCount(input2.gridColumnCount), Array.isArray(input2.preferredColumnWidths) ? input2.preferredColumnWidths.length : 0);
+  const preferredTableWidth = sanitizeOptionalWidth$1(input2.preferredTableWidth);
+  const defaultAddedColumnWidth = resolveDefaultAddedColumnWidth(input2.preferredColumnWidths, preferredTableWidth);
+  const columnWidths = buildInitialGrid(input2.preferredColumnWidths, gridColumnCount, defaultAddedColumnWidth);
+  if (input2.preserveAuthoredGrid === true)
+    return {
+      columnWidths,
+      totalWidth: sumWidths$2(columnWidths),
+      gridColumnCount: columnWidths.length,
+      preferredTableWidth
+    };
+  if (input2.rows.length === 0) {
+    if (preferredTableWidth != null)
+      shrinkToPreferredTableWidth(columnWidths, preferredTableWidth);
+    return {
+      columnWidths,
+      totalWidth: sumWidths$2(columnWidths),
+      gridColumnCount: columnWidths.length,
+      preferredTableWidth
+    };
+  }
+  applyFirstRowRequests(columnWidths, input2.rows[0], defaultAddedColumnWidth);
+  if (preferredTableWidth != null)
+    shrinkToPreferredTableWidth(columnWidths, preferredTableWidth);
+  for (const row2 of input2.rows.slice(1)) {
+    applySubsequentRowRequests(columnWidths, row2, defaultAddedColumnWidth);
+    if (preferredTableWidth != null)
+      shrinkToPreferredTableWidth(columnWidths, preferredTableWidth);
+  }
+  return {
+    columnWidths,
+    totalWidth: sumWidths$2(columnWidths),
+    gridColumnCount: columnWidths.length,
+    preferredTableWidth
+  };
+}
+function buildInitialGrid(preferredColumnWidths, gridColumnCount, defaultAddedColumnWidth) {
+  const next2 = preferredColumnWidths.slice(0, gridColumnCount).map((width) => sanitizeNonNegativeWidth(width) ?? 0);
+  while (next2.length < gridColumnCount)
+    next2.push(defaultAddedColumnWidth);
+  return next2;
+}
+function applyFirstRowRequests(columnWidths, row2, defaultAddedColumnWidth) {
+  ensureGridWidth(columnWidths, row2.logicalColumnCount, defaultAddedColumnWidth);
+  for (const skippedColumn of row2.skippedColumns)
+    setSkippedColumnWidth(columnWidths, skippedColumn, defaultAddedColumnWidth);
+  for (const cell2 of row2.cells)
+    setCellSpanWidth(columnWidths, cell2, defaultAddedColumnWidth);
+}
+function applySubsequentRowRequests(columnWidths, row2, defaultAddedColumnWidth) {
+  ensureGridWidth(columnWidths, row2.logicalColumnCount, defaultAddedColumnWidth);
+  for (const skippedColumn of row2.skippedColumns)
+    growSkippedColumnWidth(columnWidths, skippedColumn, defaultAddedColumnWidth);
+  for (const cell2 of row2.cells)
+    growCellSpanWidth(columnWidths, cell2, defaultAddedColumnWidth);
+}
+function setSkippedColumnWidth(columnWidths, skippedColumn, defaultAddedColumnWidth) {
+  const preferredWidth = sanitizeOptionalWidth$1(skippedColumn.preferredWidth);
+  if (preferredWidth == null)
+    return;
+  ensureGridWidth(columnWidths, skippedColumn.columnIndex + 1, defaultAddedColumnWidth);
+  columnWidths[skippedColumn.columnIndex] = preferredWidth;
+}
+function growSkippedColumnWidth(columnWidths, skippedColumn, defaultAddedColumnWidth) {
+  const preferredWidth = sanitizeOptionalWidth$1(skippedColumn.preferredWidth);
+  if (preferredWidth == null)
+    return;
+  ensureGridWidth(columnWidths, skippedColumn.columnIndex + 1, defaultAddedColumnWidth);
+  columnWidths[skippedColumn.columnIndex] = Math.max(columnWidths[skippedColumn.columnIndex] ?? 0, preferredWidth);
+}
+function setCellSpanWidth(columnWidths, cell2, defaultAddedColumnWidth) {
+  const span = Math.max(1, sanitizeColumnCount(cell2.span));
+  const preferredWidth = sanitizeOptionalWidth$1(cell2.preferredWidth);
+  const endColumn = cell2.startColumn + span;
+  ensureGridWidth(columnWidths, endColumn, defaultAddedColumnWidth);
+  if (preferredWidth == null)
+    return;
+  const currentSpanWidth = sumSpan$1(columnWidths, cell2.startColumn, span);
+  const lastColumnIndex = endColumn - 1;
+  columnWidths[lastColumnIndex] = Math.max(0, (columnWidths[lastColumnIndex] ?? 0) + (preferredWidth - currentSpanWidth));
+}
+function growCellSpanWidth(columnWidths, cell2, defaultAddedColumnWidth) {
+  const span = Math.max(1, sanitizeColumnCount(cell2.span));
+  const preferredWidth = sanitizeOptionalWidth$1(cell2.preferredWidth);
+  const endColumn = cell2.startColumn + span;
+  ensureGridWidth(columnWidths, endColumn, defaultAddedColumnWidth);
+  if (preferredWidth == null)
+    return;
+  const deficit = preferredWidth - sumSpan$1(columnWidths, cell2.startColumn, span);
+  if (deficit <= 0)
+    return;
+  const lastColumnIndex = endColumn - 1;
+  columnWidths[lastColumnIndex] = Math.max(0, (columnWidths[lastColumnIndex] ?? 0) + deficit);
+}
+function shrinkToPreferredTableWidth(columnWidths, preferredTableWidth) {
+  const totalWidth = sumWidths$2(columnWidths);
+  if (preferredTableWidth <= 0 || totalWidth <= preferredTableWidth || totalWidth <= 0)
+    return;
+  const scale = preferredTableWidth / totalWidth;
+  let consumed = 0;
+  for (let index2 = 0;index2 < columnWidths.length; index2++) {
+    if (index2 === columnWidths.length - 1) {
+      columnWidths[index2] = Math.max(0, preferredTableWidth - consumed);
+      continue;
+    }
+    const scaled = Math.max(0, (columnWidths[index2] ?? 0) * scale);
+    columnWidths[index2] = scaled;
+    consumed += scaled;
+  }
+}
+function ensureGridWidth(columnWidths, requiredColumnCount, defaultAddedColumnWidth) {
+  while (columnWidths.length < requiredColumnCount)
+    columnWidths.push(defaultAddedColumnWidth);
+}
+function resolveDefaultAddedColumnWidth(preferredColumnWidths, preferredTableWidth) {
+  for (let index2 = preferredColumnWidths.length - 1;index2 >= 0; index2--) {
+    const width = sanitizeNonNegativeWidth(preferredColumnWidths[index2]);
+    if (width != null && width > 0)
+      return width;
+  }
+  const positiveAuthoredWidths = preferredColumnWidths.map((width) => sanitizeNonNegativeWidth(width)).filter((width) => width != null && width > 0);
+  if (positiveAuthoredWidths.length > 0)
+    return sumWidths$2(positiveAuthoredWidths) / positiveAuthoredWidths.length;
+  if (preferredTableWidth != null && preferredTableWidth > 0)
+    return preferredTableWidth;
+  return 1;
+}
+function sumSpan$1(columnWidths, startColumn, span) {
+  let total = 0;
+  for (let offset$1 = 0;offset$1 < span; offset$1++)
+    total += columnWidths[startColumn + offset$1] ?? 0;
+  return total;
+}
+function sumWidths$2(columnWidths) {
+  return columnWidths.reduce((sum, width) => sum + Math.max(0, width), 0);
+}
+function sanitizeColumnCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return 0;
+  return Math.floor(value);
+}
+function sanitizeOptionalWidth$1(value) {
+  const width = sanitizeNonNegativeWidth(value);
+  return width == null ? undefined : width;
+}
+function sanitizeNonNegativeWidth(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return Math.max(0, value);
+}
+function computeAutoFitColumnWidths(input2) {
+  const { workingInput, fixedLayout, rowMetrics, minColumnWidth } = resolveAutoFitContext(input2);
+  if (workingInput.layoutMode === "fixed")
+    return finalizeResult("fixed", fixedLayout.columnWidths, minColumnWidth);
+  const gridColumnCount = fixedLayout.gridColumnCount;
+  if (gridColumnCount === 0)
+    return buildFallbackResult(workingInput.layoutMode, minColumnWidth);
+  const normalizedRows = buildNormalizedRows(workingInput, rowMetrics);
+  const currentWidths = fixedLayout.columnWidths.slice(0, gridColumnCount);
+  const minBounds = new Array(gridColumnCount).fill(0);
+  const maxBounds = new Array(gridColumnCount).fill(0);
+  const preferredOverrides = new Array(gridColumnCount).fill(undefined);
+  const multiSpanCells = [];
+  accumulateBounds({
+    rows: normalizedRows,
+    minBounds,
+    maxBounds,
+    preferredOverrides,
+    multiSpanCells
+  });
+  applyMultiSpanMinimums(minBounds, multiSpanCells);
+  applySingleSpanPreferredOverrides(maxBounds, minBounds, preferredOverrides);
+  applyMultiSpanMaximums(maxBounds, minBounds, multiSpanCells, currentWidths);
+  const triggerCells = collectTriggerCells(currentWidths, multiSpanCells, normalizedRows);
+  const postTriggerGrowableColumns = triggerCells.length > 0 ? collectNonProtectedColumns(triggerCells, gridColumnCount) : undefined;
+  let resolvedWidths = currentWidths.slice();
+  const preferredTableWidth = sanitizeOptionalWidth(workingInput.preferredTableWidth);
+  let targetTableWidth = preferredTableWidth ?? fixedLayout.totalWidth;
+  const maxResolvedTableWidth = preferredTableWidth != null || hasCompleteAuthoredGrid(workingInput) ? Math.max(workingInput.maxTableWidth, targetTableWidth) : workingInput.maxTableWidth;
+  const shouldPreservePreferredGrid = workingInput.preserveAutoGrid === true || workingInput.preserveExplicitAutoGrid === true;
+  if (triggerCells.length > 0) {
+    resolvedWidths = raiseToMinimums(resolvedWidths, minBounds);
+    resolvedWidths = expandTriggersWithinCurrentTable(resolvedWidths, triggerCells, minBounds, maxBounds);
+    resolvedWidths = expandTriggersByGrowingTable(resolvedWidths, triggerCells, maxBounds, maxResolvedTableWidth);
+    targetTableWidth = Math.max(targetTableWidth, sumWidths$1(resolvedWidths));
+    targetTableWidth = Math.min(targetTableWidth, maxResolvedTableWidth);
+  } else {
+    targetTableWidth = Math.min(targetTableWidth, maxResolvedTableWidth);
+    if (!shouldPreservePreferredGrid) {
+      resolvedWidths = redistributeTowardMaximumsWithinCurrentTable(resolvedWidths, minBounds, maxBounds);
+      resolvedWidths = redistributeTowardContentWeightedShape(resolvedWidths, minBounds, maxBounds);
+    }
+  }
+  resolvedWidths = shrinkToTargetWidth(resolvedWidths, targetTableWidth, minBounds);
+  resolvedWidths = growToTargetWidth(resolvedWidths, targetTableWidth, maxBounds, postTriggerGrowableColumns);
+  if (sumWidths$1(resolvedWidths) < targetTableWidth)
+    resolvedWidths = distributeRemainingSlack(resolvedWidths, targetTableWidth, postTriggerGrowableColumns);
+  if (triggerCells.length > 0)
+    resolvedWidths = clampTriggeredSpansToTargets(resolvedWidths, triggerCells, minBounds, maxBounds, currentWidths);
+  if (sumWidths$1(resolvedWidths) > maxResolvedTableWidth)
+    resolvedWidths = shrinkToTargetWidth(resolvedWidths, maxResolvedTableWidth, minBounds);
+  return finalizeResult(workingInput.layoutMode, resolvedWidths, minColumnWidth);
+}
+function hasCompleteAuthoredGrid(workingInput) {
+  const authoredColumnCount = workingInput.preferredColumnWidths.length;
+  if (authoredColumnCount === 0)
+    return false;
+  return workingInput.rows.some((row2) => row2.logicalColumnCount >= authoredColumnCount);
+}
+function resolveAutoFitContext(input2) {
+  const minColumnWidth = sanitizeWidth(input2.minColumnWidth, DEFAULT_MIN_COLUMN_WIDTH);
+  if (isExplicitInput(input2))
+    return {
+      workingInput: input2.workingInput,
+      fixedLayout: input2.fixedLayout,
+      rowMetrics: input2.contentMetrics.rowMetrics,
+      minColumnWidth
+    };
+  const layoutMode = resolveLayoutMode$1(input2.tableLayout);
+  const normalizedRows = normalizeLegacyRows(input2.rows ?? []);
+  const gridColumnCount = determineGridColumnCount$1(input2.preferredColumnWidths ?? [], normalizedRows);
+  const workingInput = {
+    layoutMode,
+    maxTableWidth: Math.max(minColumnWidth, sanitizeWidth(input2.maxTableWidth, minColumnWidth)),
+    preferredTableWidth: sanitizeOptionalWidth(input2.preferredTableWidth),
+    preferredColumnWidths: (input2.preferredColumnWidths ?? []).map((width) => Math.max(0, width)),
+    gridColumnCount,
+    rows: normalizedRows.map((row2) => ({
+      skippedBefore: row2.skippedColumns.filter((column) => column.columnIndex < firstCellStart(row2)),
+      skippedAfter: row2.skippedColumns.filter((column) => column.columnIndex >= lastCellEnd(row2)),
+      skippedColumns: row2.skippedColumns,
+      cells: row2.cells.map((cell2) => ({
+        cellId: undefined,
+        startColumn: cell2.startColumn,
+        span: cell2.span,
+        preferredWidth: cell2.preferredWidth
+      })),
+      logicalColumnCount: row2.logicalColumnCount
+    }))
+  };
+  return {
+    workingInput,
+    fixedLayout: computeFixedTableColumnWidths(workingInput),
+    rowMetrics: normalizedRows.map((row2, rowIndex) => ({
+      rowIndex,
+      cells: row2.cells.map((cell2) => ({
+        cellIndex: cell2.cellIndex,
+        span: cell2.span,
+        preferredWidth: cell2.preferredWidth,
+        minContentWidth: cell2.minContentWidth,
+        maxContentWidth: cell2.maxContentWidth
+      }))
+    })),
+    minColumnWidth
+  };
+}
+function isExplicitInput(input2) {
+  return "workingInput" in input2 && "fixedLayout" in input2 && "contentMetrics" in input2;
+}
+function resolveLayoutMode$1(tableLayout) {
+  return tableLayout === "fixed" ? "fixed" : "autofit";
+}
+function normalizeLegacyRows(rows) {
+  return rows.map((row2, rowIndex) => {
+    let columnIndex = 0;
+    const skippedColumns = [];
+    const cells = [];
+    for (const skipped of row2.skippedBefore ?? []) {
+      skippedColumns.push(normalizeSkippedColumn(skipped, columnIndex));
+      columnIndex += 1;
+    }
+    for (let cellIndex = 0;cellIndex < (row2.cells ?? []).length; cellIndex++) {
+      const cell2 = row2.cells?.[cellIndex];
+      if (!cell2)
+        continue;
+      const span = Math.max(1, Math.floor(cell2.span ?? 1));
+      cells.push({
+        rowIndex,
+        cellIndex,
+        startColumn: columnIndex,
+        span,
+        preferredWidth: sanitizeOptionalWidth(cell2.preferredWidth),
+        minContentWidth: Math.max(0, cell2.minContentWidth ?? 0),
+        maxContentWidth: Math.max(0, cell2.maxContentWidth ?? cell2.minContentWidth ?? 0)
+      });
+      columnIndex += span;
+    }
+    for (const skipped of row2.skippedAfter ?? []) {
+      skippedColumns.push(normalizeSkippedColumn(skipped, columnIndex));
+      columnIndex += 1;
+    }
+    return {
+      cells,
+      skippedColumns,
+      logicalColumnCount: columnIndex
+    };
+  });
+}
+function normalizeSkippedColumn(skipped, columnIndex) {
+  return {
+    columnIndex,
+    preferredWidth: sanitizeOptionalWidth(skipped.preferredWidth),
+    minContentWidth: Math.max(0, skipped.minContentWidth ?? 0),
+    maxContentWidth: Math.max(0, skipped.maxContentWidth ?? skipped.minContentWidth ?? 0)
+  };
+}
+function buildNormalizedRows(workingInput, rowMetrics) {
+  return workingInput.rows.map((workingRow, rowIndex) => {
+    const metricsRow = rowMetrics[rowIndex];
+    return {
+      cells: (workingRow.cells ?? []).map((cell2, cellIndex) => {
+        const metrics = metricsRow?.cells[cellIndex];
+        const placedCell = cell2;
+        return {
+          rowIndex,
+          cellIndex: metrics?.cellIndex ?? cellIndex,
+          startColumn: placedCell.startColumn,
+          span: Math.max(1, placedCell.span ?? metrics?.span ?? 1),
+          preferredWidth: sanitizeOptionalWidth(metrics?.preferredWidth ?? placedCell.preferredWidth),
+          minContentWidth: Math.max(0, metrics?.minContentWidth ?? 0),
+          maxContentWidth: Math.max(0, metrics?.maxContentWidth ?? metrics?.minContentWidth ?? 0)
+        };
+      }),
+      skippedColumns: (workingRow.skippedColumns ?? []).map((skipped) => ({
+        columnIndex: skipped.columnIndex,
+        preferredWidth: sanitizeOptionalWidth(skipped.preferredWidth),
+        minContentWidth: Math.max(0, skipped.minContentWidth ?? 0),
+        maxContentWidth: Math.max(0, skipped.maxContentWidth ?? skipped.minContentWidth ?? 0)
+      })),
+      logicalColumnCount: workingRow.logicalColumnCount
+    };
+  });
+}
+function accumulateBounds(args$1) {
+  const { rows, minBounds, maxBounds, preferredOverrides, multiSpanCells } = args$1;
+  for (const row2 of rows) {
+    for (const skipped of row2.skippedColumns) {
+      minBounds[skipped.columnIndex] = Math.max(minBounds[skipped.columnIndex], skipped.minContentWidth);
+      maxBounds[skipped.columnIndex] = Math.max(maxBounds[skipped.columnIndex], skipped.maxContentWidth);
+      if (preferredOverrides[skipped.columnIndex] == null && skipped.preferredWidth != null)
+        preferredOverrides[skipped.columnIndex] = skipped.preferredWidth;
+    }
+    for (const cell2 of row2.cells)
+      if (cell2.span === 1) {
+        minBounds[cell2.startColumn] = Math.max(minBounds[cell2.startColumn], cell2.minContentWidth);
+        maxBounds[cell2.startColumn] = Math.max(maxBounds[cell2.startColumn], cell2.maxContentWidth);
+        if (preferredOverrides[cell2.startColumn] == null && cell2.preferredWidth != null)
+          preferredOverrides[cell2.startColumn] = cell2.preferredWidth;
+      } else
+        multiSpanCells.push(cell2);
+  }
+}
+function applyMultiSpanMinimums(minBounds, cells) {
+  for (const cell2 of cells)
+    growSpanTotal(minBounds, cell2.startColumn, cell2.span, cell2.minContentWidth);
+}
+function applySingleSpanPreferredOverrides(maxBounds, minBounds, preferredOverrides) {
+  for (let index2 = 0;index2 < maxBounds.length; index2++) {
+    const currentMax = Math.max(maxBounds[index2], minBounds[index2]);
+    maxBounds[index2] = preferredOverrides[index2] ?? currentMax;
+    maxBounds[index2] = Math.max(maxBounds[index2], minBounds[index2]);
+  }
+}
+function applyMultiSpanMaximums(maxBounds, minBounds, cells, fixedWidths) {
+  for (const cell2 of cells) {
+    const targetTotal = cell2.preferredWidth != null ? Math.max(cell2.preferredWidth, sumSpan(minBounds, cell2.startColumn, cell2.span)) : Math.max(cell2.maxContentWidth, sumSpan(minBounds, cell2.startColumn, cell2.span));
+    setSpanTotal(maxBounds, minBounds, fixedWidths, cell2.startColumn, cell2.span, targetTotal);
+  }
+}
+function collectTriggerCells(currentWidths, multiSpanCells, rows) {
+  const triggers = [];
+  for (const row2 of rows)
+    for (const cell2 of row2.cells)
+      if (sumSpan(currentWidths, cell2.startColumn, cell2.span) < cell2.minContentWidth)
+        triggers.push(cell2);
+  for (const cell2 of multiSpanCells)
+    if (sumSpan(currentWidths, cell2.startColumn, cell2.span) < cell2.minContentWidth)
+      triggers.push(cell2);
+  return coalesceEquivalentTriggerCells(dedupeCells(triggers));
+}
+function setSpanTotal(widths, minBounds, fixedWidths, startColumn, span, targetTotal) {
+  const currentTotal = sumSpan(widths, startColumn, span);
+  const minTotal = sumSpan(minBounds, startColumn, span);
+  const boundedTarget = Math.max(targetTotal, minTotal);
+  if (currentTotal < boundedTarget) {
+    growSpanTotal(widths, startColumn, span, boundedTarget, fixedWidths);
+    return;
+  }
+  if (currentTotal === boundedTarget)
+    return;
+  const reducibleRanges = collectSpanRanges(widths, minBounds, startColumn, span);
+  const totalReducible = reducibleRanges.reduce((sum, range) => sum + range.amount, 0);
+  if (totalReducible <= 0)
+    return;
+  const reduction = currentTotal - boundedTarget;
+  let applied = 0;
+  for (let rangeIndex = 0;rangeIndex < reducibleRanges.length; rangeIndex++) {
+    const range = reducibleRanges[rangeIndex];
+    const portion = rangeIndex === reducibleRanges.length - 1 ? reduction - applied : reduction * (range.amount / totalReducible);
+    widths[range.index] = Math.max(minBounds[range.index], widths[range.index] - portion);
+    applied += portion;
+  }
+}
+function growSpanTotal(widths, startColumn, span, targetTotal, fixedWidths) {
+  const deficit = targetTotal - sumSpan(widths, startColumn, span);
+  if (deficit <= 0)
+    return;
+  const weights = Array.from({ length: span }, (_$1, offset$1) => {
+    const index2 = startColumn + offset$1;
+    return Math.max(fixedWidths?.[index2] ?? 0, widths[index2] ?? 0, 1);
+  });
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  let applied = 0;
+  for (let offset$1 = 0;offset$1 < span; offset$1++) {
+    const index2 = startColumn + offset$1;
+    const increment2 = offset$1 === span - 1 ? deficit - applied : deficit * (weights[offset$1] / totalWeight);
+    widths[index2] = Math.max(0, (widths[index2] ?? 0) + increment2);
+    applied += increment2;
+  }
+}
+function shrinkToTargetWidth(widths, targetWidth, minBounds) {
+  const currentTotal = sumWidths$1(widths);
+  if (currentTotal <= targetWidth)
+    return widths;
+  const minTotal = sumWidths$1(minBounds);
+  if (targetWidth <= 0)
+    return widths;
+  if (targetWidth < minTotal)
+    return scaleToTargetWidth(widths, targetWidth);
+  const capacities = widths.map((width, index2) => Math.max(0, width - minBounds[index2]));
+  const totalCapacity = capacities.reduce((sum, capacity) => sum + capacity, 0);
+  if (totalCapacity <= 0)
+    return widths;
+  const excess = currentTotal - targetWidth;
+  return widths.map((width, index2) => {
+    const shrink = excess * (capacities[index2] / totalCapacity);
+    return Math.max(minBounds[index2], width - shrink);
+  });
+}
+function growToTargetWidth(widths, targetWidth, maxBounds, growableColumns) {
+  const currentTotal = sumWidths$1(widths);
+  if (currentTotal >= targetWidth)
+    return widths;
+  const ranges = widths.map((width, index2) => growableColumns == null || growableColumns.has(index2) ? Math.max(0, maxBounds[index2] - width) : 0);
+  const totalRange = ranges.reduce((sum, range) => sum + range, 0);
+  if (totalRange <= 0)
+    return widths;
+  const slack = targetWidth - currentTotal;
+  return widths.map((width, index2) => width + slack * (ranges[index2] / totalRange));
+}
+function distributeRemainingSlack(widths, targetWidth, growableColumns) {
+  const currentTotal = sumWidths$1(widths);
+  if (currentTotal >= targetWidth)
+    return widths;
+  const basis = widths.reduce((sum, width, index2) => {
+    if (growableColumns != null && !growableColumns.has(index2))
+      return sum;
+    return sum + Math.max(width, 1);
+  }, 0);
+  const slack = targetWidth - currentTotal;
+  if (basis <= 0) {
+    if (growableColumns == null)
+      return widths;
+    const growableIndexes = widths.map((_$1, index2) => index2).filter((index2) => growableColumns.has(index2));
+    if (growableIndexes.length === 0)
+      return widths;
+    const share = slack / growableIndexes.length;
+    return widths.map((width, index2) => growableColumns.has(index2) ? width + share : width);
+  }
+  return widths.map((width, index2) => {
+    if (growableColumns != null && !growableColumns.has(index2))
+      return width;
+    return width + slack * (Math.max(width, 1) / basis);
+  });
+}
+function raiseToMinimums(widths, minBounds) {
+  const next2 = widths.slice();
+  const deficits = next2.map((width, index2) => Math.max(0, minBounds[index2] - width));
+  const totalDeficit = deficits.reduce((sum, deficit) => sum + deficit, 0);
+  if (totalDeficit <= 0)
+    return next2;
+  const capacities = next2.map((width, index2) => Math.max(0, width - minBounds[index2]));
+  const totalCapacity = capacities.reduce((sum, capacity) => sum + capacity, 0);
+  const borrowAmount = Math.min(totalDeficit, totalCapacity);
+  if (borrowAmount > 0 && totalCapacity > 0) {
+    let borrowed = 0;
+    for (let index2 = 0;index2 < next2.length; index2++) {
+      const reduction = index2 === next2.length - 1 ? borrowAmount - borrowed : borrowAmount * (capacities[index2] / totalCapacity);
+      next2[index2] = Math.max(minBounds[index2], next2[index2] - reduction);
+      borrowed += reduction;
+    }
+  }
+  for (let index2 = 0;index2 < next2.length; index2++)
+    next2[index2] = Math.max(next2[index2], Math.min(minBounds[index2], widths[index2] + deficits[index2]));
+  return next2;
+}
+function redistributeTowardMaximumsWithinCurrentTable(widths, minBounds, maxBounds) {
+  const next2 = widths.slice();
+  for (let iteration = 0;iteration < 8; iteration++) {
+    const receiverHeadrooms = next2.map((width, index2) => Math.max(0, maxBounds[index2] - width));
+    const totalReceiverHeadroom = receiverHeadrooms.reduce((sum, headroom) => sum + headroom, 0);
+    if (totalReceiverHeadroom <= 0.001)
+      break;
+    const donorCapacities = next2.map((width, index2) => receiverHeadrooms[index2] > 0.001 ? 0 : Math.max(0, width - minBounds[index2]));
+    let totalDonorCapacity = donorCapacities.reduce((sum, capacity) => sum + capacity, 0);
+    if (totalDonorCapacity <= 0.001) {
+      for (let index2 = 0;index2 < next2.length; index2++)
+        donorCapacities[index2] = Math.max(0, next2[index2] - minBounds[index2]);
+      totalDonorCapacity = donorCapacities.reduce((sum, capacity) => sum + capacity, 0);
+    }
+    if (totalDonorCapacity <= 0.001)
+      break;
+    const redistribution = Math.min(totalReceiverHeadroom, totalDonorCapacity);
+    shrinkColumnsByCapacity(next2, donorCapacities, minBounds, redistribution);
+    growColumnsByHeadroom(next2, receiverHeadrooms, redistribution);
+  }
+  return next2;
+}
+function redistributeTowardContentWeightedShape(widths, minBounds, maxBounds) {
+  const distributableWidth = sumWidths$1(widths) - sumWidths$1(minBounds);
+  if (distributableWidth <= 0.001 || widths.length === 0)
+    return widths;
+  const demandWeights = widths.map((width, index2) => {
+    const demand = Math.max(maxBounds[index2], width, minBounds[index2], 1);
+    return demand * demand;
+  });
+  const totalDemandWeight = demandWeights.reduce((sum, weight) => sum + weight, 0);
+  if (totalDemandWeight <= 0.001)
+    return widths;
+  return widths.map((_$1, index2) => minBounds[index2] + distributableWidth * (demandWeights[index2] / totalDemandWeight));
+}
+function expandTriggersWithinCurrentTable(widths, triggerCells, minBounds, maxBounds) {
+  const next2 = widths.slice();
+  const protectedColumns = collectProtectedColumns(triggerCells);
+  for (let iteration = 0;iteration < 8; iteration++) {
+    const totalHeadroom = collectTriggerHeadrooms(next2, triggerCells, maxBounds).reduce((sum, headroom) => sum + headroom, 0);
+    if (totalHeadroom <= 0.001)
+      break;
+    const donorCapacities = next2.map((width, index2) => protectedColumns.has(index2) ? 0 : Math.max(0, width - minBounds[index2]));
+    const totalDonorCapacity = donorCapacities.reduce((sum, capacity) => sum + capacity, 0);
+    if (totalDonorCapacity <= 0.001)
+      break;
+    const borrowedWidth = Math.min(totalHeadroom, totalDonorCapacity);
+    shrinkColumnsByCapacity(next2, donorCapacities, minBounds, borrowedWidth);
+    applyTriggerGrowth(next2, triggerCells, maxBounds, borrowedWidth);
+  }
+  return next2;
+}
+function expandTriggersByGrowingTable(widths, triggerCells, maxBounds, maxTableWidth) {
+  const next2 = widths.slice();
+  for (let iteration = 0;iteration < 8; iteration++) {
+    const totalHeadroom = collectTriggerHeadrooms(next2, triggerCells, maxBounds).reduce((sum, headroom) => sum + headroom, 0);
+    if (totalHeadroom <= 0.001)
+      break;
+    const remainingTableGrowth = Math.max(0, maxTableWidth - sumWidths$1(next2));
+    if (remainingTableGrowth <= 0.001)
+      break;
+    applyTriggerGrowth(next2, triggerCells, maxBounds, Math.min(totalHeadroom, remainingTableGrowth));
+  }
+  return next2;
+}
+function collectTriggerHeadrooms(widths, triggerCells, maxBounds) {
+  return triggerCells.map((cell2) => {
+    const currentTotal = sumSpan(widths, cell2.startColumn, cell2.span);
+    const targetTotal = resolveTriggerTargetTotal(cell2, maxBounds);
+    return Math.max(0, targetTotal - currentTotal);
+  });
+}
+function resolveTriggerTargetTotal(cell2, maxBounds) {
+  if (cell2.span === 1)
+    return maxBounds[cell2.startColumn] ?? cell2.maxContentWidth;
+  return cell2.preferredWidth != null ? Math.max(cell2.preferredWidth, cell2.minContentWidth) : Math.max(cell2.maxContentWidth, cell2.minContentWidth);
+}
+function collectProtectedColumns(cells) {
+  const protectedColumns = /* @__PURE__ */ new Set;
+  for (const cell2 of cells)
+    for (let offset$1 = 0;offset$1 < cell2.span; offset$1++)
+      protectedColumns.add(cell2.startColumn + offset$1);
+  return protectedColumns;
+}
+function collectNonProtectedColumns(cells, columnCount) {
+  const protectedColumns = collectProtectedColumns(cells);
+  const growableColumns = /* @__PURE__ */ new Set;
+  for (let index2 = 0;index2 < columnCount; index2++)
+    if (!protectedColumns.has(index2))
+      growableColumns.add(index2);
+  return growableColumns;
+}
+function shrinkColumnsByCapacity(widths, capacities, minBounds, shrinkAmount) {
+  const totalCapacity = capacities.reduce((sum, capacity) => sum + capacity, 0);
+  if (totalCapacity <= 0 || shrinkAmount <= 0)
+    return;
+  let applied = 0;
+  for (let index2 = 0;index2 < widths.length; index2++) {
+    const reduction = index2 === widths.length - 1 ? shrinkAmount - applied : shrinkAmount * (capacities[index2] / totalCapacity);
+    widths[index2] = Math.max(minBounds[index2], widths[index2] - reduction);
+    applied += reduction;
+  }
+}
+function growColumnsByHeadroom(widths, headrooms, growthAmount) {
+  const totalHeadroom = headrooms.reduce((sum, headroom) => sum + headroom, 0);
+  if (totalHeadroom <= 0 || growthAmount <= 0)
+    return;
+  let applied = 0;
+  const activeIndexes = headrooms.map((headroom, index2) => ({
+    headroom,
+    index: index2
+  })).filter((entry) => entry.headroom > 0.001);
+  for (let activeIndex = 0;activeIndex < activeIndexes.length; activeIndex++) {
+    const { index: index2, headroom } = activeIndexes[activeIndex];
+    const growth = activeIndex === activeIndexes.length - 1 ? growthAmount - applied : growthAmount * (headroom / totalHeadroom);
+    widths[index2] += Math.min(headroom, growth);
+    applied += Math.min(headroom, growth);
+  }
+}
+function applyTriggerGrowth(widths, triggerCells, maxBounds, growthAmount) {
+  let remainingGrowth = growthAmount;
+  for (let iteration = 0;iteration < 16 && remainingGrowth > 0.001; iteration++) {
+    const headrooms = collectTriggerHeadrooms(widths, triggerCells, maxBounds);
+    const totalHeadroom = headrooms.reduce((sum, headroom) => sum + headroom, 0);
+    if (totalHeadroom <= 0.001)
+      break;
+    const stepGrowth = Math.min(remainingGrowth, totalHeadroom);
+    const activeIndexes = headrooms.map((headroom, index2) => ({
+      headroom,
+      index: index2
+    })).filter((entry) => entry.headroom > 0.001);
+    let appliedThisRound = 0;
+    for (let activeIndex = 0;activeIndex < activeIndexes.length; activeIndex++) {
+      const { index: index2, headroom } = activeIndexes[activeIndex];
+      const cell2 = triggerCells[index2];
+      const proportionalGrowth = activeIndex === activeIndexes.length - 1 ? stepGrowth - appliedThisRound : stepGrowth * (headroom / totalHeadroom);
+      const boundedGrowth = Math.min(headroom, proportionalGrowth);
+      if (boundedGrowth <= 0)
+        continue;
+      growSpanTotal(widths, cell2.startColumn, cell2.span, sumSpan(widths, cell2.startColumn, cell2.span) + boundedGrowth);
+      appliedThisRound += boundedGrowth;
+    }
+    if (appliedThisRound <= 0.001)
+      break;
+    remainingGrowth -= appliedThisRound;
+  }
+}
+function clampTriggeredSpansToTargets(widths, triggerCells, minBounds, maxBounds, fixedWidths) {
+  const next2 = widths.slice();
+  for (let iteration = 0;iteration < 8; iteration++) {
+    let changed = false;
+    for (const cell2 of triggerCells) {
+      const currentTotal = sumSpan(next2, cell2.startColumn, cell2.span);
+      const targetTotal = resolveTriggerTargetTotal(cell2, maxBounds);
+      if (currentTotal > targetTotal + 0.001) {
+        setSpanTotal(next2, minBounds, fixedWidths, cell2.startColumn, cell2.span, targetTotal);
+        changed = true;
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return next2;
+}
+function collectSpanRanges(widths, minBounds, startColumn, span) {
+  const ranges = [];
+  for (let offset$1 = 0;offset$1 < span; offset$1++) {
+    const index2 = startColumn + offset$1;
+    const amount = Math.max(0, widths[index2] - minBounds[index2]);
+    if (amount > 0)
+      ranges.push({
+        index: index2,
+        amount
+      });
+  }
+  return ranges;
+}
+function dedupeCells(cells) {
+  const seen = /* @__PURE__ */ new Set;
+  return cells.filter((cell2) => {
+    const key2 = `${cell2.rowIndex}:${cell2.startColumn}:${cell2.span}:${cell2.cellIndex}`;
+    if (seen.has(key2))
+      return false;
+    seen.add(key2);
+    return true;
+  });
+}
+function coalesceEquivalentTriggerCells(cells) {
+  const strongestBySpan = /* @__PURE__ */ new Map;
+  for (const cell2 of cells) {
+    const key2 = `${cell2.startColumn}:${cell2.span}`;
+    const current = strongestBySpan.get(key2);
+    if (!current || resolveTriggerStrength(cell2) > resolveTriggerStrength(current))
+      strongestBySpan.set(key2, cell2);
+  }
+  return [...strongestBySpan.values()];
+}
+function resolveTriggerStrength(cell2) {
+  return cell2.preferredWidth != null ? Math.max(cell2.preferredWidth, cell2.minContentWidth) : Math.max(cell2.maxContentWidth, cell2.minContentWidth);
+}
+function determineGridColumnCount$1(preferredColumnWidths, rows) {
+  return Math.max(preferredColumnWidths.length, ...rows.map((row2) => row2.logicalColumnCount), 0);
+}
+function firstCellStart(row2) {
+  return row2.cells[0]?.startColumn ?? row2.logicalColumnCount;
+}
+function lastCellEnd(row2) {
+  const lastCell = row2.cells[row2.cells.length - 1];
+  return lastCell ? lastCell.startColumn + lastCell.span : 0;
+}
+function sumSpan(widths, startColumn, span) {
+  let total = 0;
+  for (let offset$1 = 0;offset$1 < span; offset$1++)
+    total += widths[startColumn + offset$1] ?? 0;
+  return total;
+}
+function sumWidths$1(widths) {
+  return widths.reduce((sum, width) => sum + Math.max(0, width), 0);
+}
+function scaleToTargetWidth(widths, targetWidth) {
+  const currentTotal = sumWidths$1(widths);
+  if (currentTotal <= 0 || targetWidth <= 0)
+    return widths;
+  const scale = targetWidth / currentTotal;
+  return widths.map((width) => Math.max(0, width * scale));
+}
+function sanitizeWidth(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function sanitizeOptionalWidth(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function buildFallbackResult(layoutMode, minColumnWidth) {
+  return {
+    layoutMode,
+    columnWidths: [minColumnWidth],
+    totalWidth: minColumnWidth,
+    gridColumnCount: 1
+  };
+}
+function finalizeResult(layoutMode, widths, minColumnWidth) {
+  if (widths.length === 0)
+    return buildFallbackResult(layoutMode, minColumnWidth);
+  return {
+    layoutMode,
+    columnWidths: widths,
+    totalWidth: sumWidths$1(widths),
+    gridColumnCount: widths.length
+  };
+}
+function buildAutoFitWorkingGridInput(block, constraints) {
+  const maxTableWidth = sanitizePositiveNumber(constraints.maxWidth);
+  const layoutMode = resolveLayoutMode(block.attrs?.tableLayout);
+  const preferredTableWidth = resolvePreferredTableWidth(block.attrs?.tableWidth, maxTableWidth);
+  const rawPreferredColumnWidths = normalizePreferredColumnWidths(block.columnWidths);
+  const logicalColumnLimit = resolveTrailingPlaceholderColumnLimit(rawPreferredColumnWidths);
+  let activeRowSpans = [];
+  const rows = block.rows.map((row2) => {
+    const normalized = normalizeRow(row2, preferredTableWidth ?? maxTableWidth, activeRowSpans, logicalColumnLimit);
+    activeRowSpans = normalized.nextActiveRowSpans;
+    return normalized.row;
+  });
+  const preferredColumnWidths = trimTrailingUnoccupiedPlaceholderColumns(rawPreferredColumnWidths, determineGridColumnCount(0, rows));
+  const gridColumnCount = determineGridColumnCount(preferredColumnWidths.length, rows);
+  const preserveAuthoredGrid = shouldPreserveAuthoredGrid({
+    layoutMode,
+    preferredColumnWidths,
+    preferredTableWidth,
+    gridColumnCount
+  });
+  const preserveAutoGrid = shouldPreserveAutoGrid({
+    layoutMode,
+    preferredColumnWidths,
+    preferredTableWidth,
+    gridColumnCount
+  });
+  const preserveExplicitAutoGrid = shouldPreserveExplicitAutoGrid({
+    layoutMode,
+    preferredColumnWidths,
+    preferredTableWidth,
+    gridColumnCount,
+    rows
+  });
+  return {
+    layoutMode,
+    maxTableWidth,
+    ...preserveAuthoredGrid ? { preserveAuthoredGrid } : {},
+    ...preserveAutoGrid ? { preserveAutoGrid } : {},
+    ...preserveExplicitAutoGrid ? { preserveExplicitAutoGrid } : {},
+    preferredTableWidth,
+    preferredColumnWidths,
+    gridColumnCount,
+    rows
+  };
+}
+function resolveLayoutMode(tableLayout) {
+  return tableLayout === "fixed" ? "fixed" : "autofit";
+}
+function shouldPreserveAuthoredGrid(args$1) {
+  const { layoutMode, preferredColumnWidths, preferredTableWidth, gridColumnCount } = args$1;
+  if (layoutMode !== "fixed")
+    return false;
+  if (preferredTableWidth == null || preferredTableWidth <= 0)
+    return false;
+  if (preferredColumnWidths.length === 0 || preferredColumnWidths.length !== gridColumnCount)
+    return false;
+  const totalPreferredColumnWidth = sumWidths(preferredColumnWidths);
+  return approximatelyEqual(totalPreferredColumnWidth, preferredTableWidth) || isSlightlyUnderPreferredTableWidth(totalPreferredColumnWidth, preferredTableWidth);
+}
+function shouldPreserveAutoGrid(args$1) {
+  const { layoutMode, preferredColumnWidths, preferredTableWidth, gridColumnCount } = args$1;
+  if (layoutMode !== "autofit")
+    return false;
+  if (preferredTableWidth != null)
+    return false;
+  if (preferredColumnWidths.length === 0 || preferredColumnWidths.length !== gridColumnCount)
+    return false;
+  if (!hasNonUniformGrid(preferredColumnWidths))
+    return false;
+  return true;
+}
+function shouldPreserveExplicitAutoGrid(args$1) {
+  const { layoutMode, preferredColumnWidths, preferredTableWidth, gridColumnCount, rows } = args$1;
+  if (layoutMode !== "autofit")
+    return false;
+  if (preferredTableWidth == null || preferredTableWidth <= 0)
+    return false;
+  if (preferredColumnWidths.length === 0 || preferredColumnWidths.length !== gridColumnCount)
+    return false;
+  if (!hasNonUniformGrid(preferredColumnWidths) && !hasConcreteCellWidthRequest(rows))
+    return false;
+  return approximatelyEqual(sumWidths(preferredColumnWidths), preferredTableWidth);
+}
+function hasNonUniformGrid(widths) {
+  if (widths.length <= 1)
+    return true;
+  const firstWidth = widths[0];
+  return widths.some((width) => !approximatelyEqual(width, firstWidth));
+}
+function hasConcreteCellWidthRequest(rows) {
+  return rows.some((row2) => row2.cells.some((cell2) => cell2.preferredWidth != null));
+}
+function trimTrailingUnoccupiedPlaceholderColumns(widths, occupiedGridColumnCount) {
+  const occupiedCount = Math.max(0, Math.floor(occupiedGridColumnCount));
+  if (occupiedCount <= 0 || widths.length <= occupiedCount)
+    return widths;
+  if (!widths.slice(occupiedCount).every((width) => width <= PLACEHOLDER_COLUMN_MAX_WIDTH))
+    return widths;
+  return widths.slice(0, occupiedCount);
+}
+function resolveTrailingPlaceholderColumnLimit(widths) {
+  let trailingPlaceholderCount = 0;
+  for (let index2 = widths.length - 1;index2 >= 0; index2--) {
+    if (widths[index2] > PLACEHOLDER_COLUMN_MAX_WIDTH)
+      break;
+    trailingPlaceholderCount += 1;
+  }
+  if (trailingPlaceholderCount === 0 || trailingPlaceholderCount === widths.length)
+    return;
+  return widths.length - trailingPlaceholderCount;
+}
+function normalizePreferredColumnWidths(columnWidths) {
+  if (!Array.isArray(columnWidths))
+    return [];
+  return columnWidths.map((width) => sanitizeNonNegativeNumber(width)).filter((width) => width !== undefined).map((width) => width);
+}
+function normalizeRow(row2, percentageBasis, activeRowSpans, logicalColumnLimit) {
+  const rowProps = row2.attrs?.tableRowProperties ?? {};
+  const skippedBeforeCount = sanitizeCount(rowProps.gridBefore);
+  const skippedAfterCount = normalizeSkippedAfterCount(rowProps.gridAfter, rowProps.wAfter, percentageBasis);
+  const cells = Array.isArray(row2.cells) ? row2.cells : [];
+  let columnIndex = advancePastOccupiedColumns(activeRowSpans, 0);
+  const skippedBeforePlacement = buildSkippedColumns(skippedBeforeCount, rowProps.wBefore, percentageBasis, columnIndex, activeRowSpans);
+  columnIndex = skippedBeforePlacement.nextColumnIndex;
+  const normalizedCells = cells.map((cell2) => {
+    columnIndex = advancePastOccupiedColumns(activeRowSpans, columnIndex);
+    const normalizedCell = normalizeCell(cell2, percentageBasis, columnIndex, logicalColumnLimit);
+    columnIndex += normalizedCell.span ?? 1;
+    return normalizedCell;
+  });
+  const skippedAfterPlacement = buildSkippedColumns(skippedAfterCount, rowProps.wAfter, percentageBasis, columnIndex, activeRowSpans);
+  columnIndex = skippedAfterPlacement.nextColumnIndex;
+  const logicalColumnCount = Math.max(columnIndex, resolveOccupiedLogicalColumnCount(activeRowSpans));
+  const nextActiveRowSpans = advanceRowSpans(activeRowSpans);
+  normalizedCells.forEach((cell2, index2) => {
+    const rowSpan = sanitizeCount(cells[index2]?.rowSpan) || 1;
+    if (rowSpan > 1)
+      markRowSpanOccupancy(nextActiveRowSpans, cell2.startColumn, cell2.span ?? 1, rowSpan - 1);
+  });
+  return {
+    row: {
+      skippedBefore: skippedBeforePlacement.columns,
+      cells: normalizedCells,
+      skippedAfter: skippedAfterPlacement.columns,
+      skippedColumns: [...skippedBeforePlacement.columns, ...skippedAfterPlacement.columns],
+      logicalColumnCount
+    },
+    nextActiveRowSpans
+  };
+}
+function buildSkippedColumns(count2, preferredWidthMeasurement, percentageBasis, startColumnIndex, activeRowSpans) {
+  if (count2 <= 0)
+    return {
+      columns: [],
+      nextColumnIndex: startColumnIndex
+    };
+  const totalPreferredWidth = resolveMeasurementToPx(preferredWidthMeasurement, percentageBasis);
+  const perColumnPreferredWidth = totalPreferredWidth != null && count2 > 0 ? Math.max(0, totalPreferredWidth / count2) : undefined;
+  const columns = [];
+  let columnIndex = startColumnIndex;
+  for (let index2 = 0;index2 < count2; index2++) {
+    columnIndex = advancePastOccupiedColumns(activeRowSpans, columnIndex);
+    columns.push({
+      columnIndex,
+      preferredWidth: perColumnPreferredWidth,
+      minContentWidth: 0,
+      maxContentWidth: 0
+    });
+    columnIndex += 1;
+  }
+  return {
+    columns,
+    nextColumnIndex: columnIndex
+  };
+}
+function normalizeSkippedAfterCount(countValue, preferredWidthMeasurement, percentageBasis) {
+  const count2 = sanitizeCount(countValue);
+  if (count2 <= 0)
+    return 0;
+  const totalPreferredWidth = resolveMeasurementToPx(preferredWidthMeasurement, percentageBasis);
+  if (totalPreferredWidth != null && totalPreferredWidth <= PLACEHOLDER_COLUMN_MAX_WIDTH * count2)
+    return 0;
+  return count2;
+}
+function normalizeCell(cell2, percentageBasis, startColumn, logicalColumnLimit) {
+  const cellProps = cell2.attrs?.tableCellProperties ?? {};
+  const rawSpan = sanitizeCount(cell2.colSpan) || 1;
+  const span = logicalColumnLimit != null && startColumn < logicalColumnLimit && startColumn + rawSpan > logicalColumnLimit ? Math.max(1, logicalColumnLimit - startColumn) : rawSpan;
+  return {
+    cellId: cell2.id,
+    startColumn,
+    span,
+    preferredWidth: resolveMeasurementToPx(cellProps.cellWidth, percentageBasis)
+  };
+}
+function advancePastOccupiedColumns(activeRowSpans, columnIndex) {
+  let nextColumnIndex = columnIndex;
+  while ((activeRowSpans[nextColumnIndex] ?? 0) > 0)
+    nextColumnIndex += 1;
+  return nextColumnIndex;
+}
+function resolveOccupiedLogicalColumnCount(activeRowSpans) {
+  for (let index2 = activeRowSpans.length - 1;index2 >= 0; index2--)
+    if ((activeRowSpans[index2] ?? 0) > 0)
+      return index2 + 1;
+  return 0;
+}
+function advanceRowSpans(activeRowSpans) {
+  return activeRowSpans.map((remainingRows) => Math.max(0, remainingRows - 1));
+}
+function markRowSpanOccupancy(activeRowSpans, startColumn, span, remainingRows) {
+  const boundedSpan = Math.max(1, sanitizeCount(span));
+  for (let offset$1 = 0;offset$1 < boundedSpan; offset$1++) {
+    const columnIndex = startColumn + offset$1;
+    activeRowSpans[columnIndex] = Math.max(activeRowSpans[columnIndex] ?? 0, remainingRows);
+  }
+}
+function determineGridColumnCount(preferredColumnCount, rows) {
+  return Math.max(preferredColumnCount, ...rows.map((row2) => {
+    if ("logicalColumnCount" in row2 && typeof row2.logicalColumnCount === "number")
+      return row2.logicalColumnCount;
+    const skippedBefore = row2.skippedBefore?.length ?? 0;
+    const skippedAfter = row2.skippedAfter?.length ?? 0;
+    const cellSpanTotal = (row2.cells ?? []).reduce((sum, cell2) => sum + Math.max(1, cell2.span ?? 1), 0);
+    return skippedBefore + skippedAfter + cellSpanTotal;
+  }), 0);
+}
+function resolvePreferredTableWidth(tableWidth, maxWidth) {
+  const resolvedWidth = resolveTableWidthAttr(tableWidth);
+  if (!resolvedWidth)
+    return;
+  if (resolvedWidth.type === "pct")
+    return Math.round(maxWidth * (resolvedWidth.width / OOXML_PCT_DIVISOR));
+  return resolvedWidth.width;
+}
+function resolveMeasurementToPx(measurement, percentageBasis) {
+  if (!measurement || typeof measurement !== "object" || !Number.isFinite(measurement.value))
+    return;
+  const value = measurement.value;
+  switch ((measurement.type ?? "dxa").toLowerCase()) {
+    case "dxa":
+      return value / TWIPS_PER_PX$1;
+    case "pct":
+      return Math.round(percentageBasis * (value / OOXML_PCT_DIVISOR));
+    case "px":
+    case "pixel":
+      return value;
+    case "auto":
+    case "nil":
+      return;
+    default:
+      return value;
+  }
+}
+function sanitizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.floor(value));
+}
+function sanitizePositiveNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return 1;
+  return value;
+}
+function sanitizeNonNegativeNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return;
+  return value;
+}
+function sumWidths(widths) {
+  return widths.reduce((sum, width) => sum + Math.max(0, width), 0);
+}
+function approximatelyEqual(left$1, right$1) {
+  return Math.abs(left$1 - right$1) <= 0.01;
+}
+function isSlightlyUnderPreferredTableWidth(totalColumnWidth, preferredTableWidth) {
+  if (totalColumnWidth <= 0 || totalColumnWidth >= preferredTableWidth)
+    return false;
+  return preferredTableWidth - totalColumnWidth <= preferredTableWidth * 0.05;
+}
+function buildTableCellContentMetricsCacheKey(cell2, options) {
+  return stableSerialize({
+    maxWidth: Math.max(1, Math.round(options.maxWidth)),
+    layoutEpoch: options.layoutEpoch ?? null,
+    attrs: cell2.attrs ?? null,
+    paragraph: cell2.paragraph ?? null,
+    blocks: cell2.blocks ?? null
+  });
+}
+function buildAutoFitTableResultCacheKey(table2, options) {
+  return stableSerialize({
+    id: table2.id,
+    attrs: table2.attrs ?? null,
+    columnWidths: table2.columnWidths ?? null,
+    rowCount: table2.rows.length,
+    maxWidth: Math.max(1, Math.round(options.maxWidth)),
+    layoutEpoch: options.layoutEpoch ?? null,
+    cellMetricKeys: options.cellMetricKeys,
+    workingGrid: {
+      layoutMode: options.workingInput.layoutMode,
+      gridColumnCount: options.workingInput.gridColumnCount,
+      preserveAuthoredGrid: options.workingInput.preserveAuthoredGrid === true,
+      preserveAutoGrid: options.workingInput.preserveAutoGrid === true,
+      preserveExplicitAutoGrid: options.workingInput.preserveExplicitAutoGrid === true,
+      preferredTableWidth: options.workingInput.preferredTableWidth ?? null,
+      preferredColumnWidths: options.workingInput.preferredColumnWidths,
+      rows: options.workingInput.rows.map((row2) => ({
+        logicalColumnCount: row2.logicalColumnCount,
+        skippedColumns: (row2.skippedColumns ?? []).map((column) => ({
+          columnIndex: column.columnIndex,
+          preferredWidth: column.preferredWidth ?? null
+        })),
+        cells: row2.cells.map((cell2) => ({
+          startColumn: cell2.startColumn,
+          span: cell2.span ?? 1,
+          preferredWidth: cell2.preferredWidth ?? null
+        }))
+      }))
+    },
+    fixedLayout: {
+      columnWidths: options.fixedLayout.columnWidths,
+      totalWidth: options.fixedLayout.totalWidth,
+      gridColumnCount: options.fixedLayout.gridColumnCount,
+      preferredTableWidth: options.fixedLayout.preferredTableWidth ?? null
+    }
+  });
+}
+function getCachedAutoFitTableResult(cacheKey) {
+  return autoFitTableResultCache.get(cacheKey);
+}
+function setCachedAutoFitTableResult(cacheKey, result) {
+  autoFitTableResultCache.set(cacheKey, result);
+}
+async function measureTableCellContentMetrics(cell2, options) {
+  const cacheKey = buildTableCellContentMetricsCacheKey(cell2, options);
+  const cached = tableCellMetricsCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const horizontalInsets = getHorizontalCellInsets(cell2);
+  const contentBlocks = cell2.blocks ?? (cell2.paragraph ? [cell2.paragraph] : []);
+  if (contentBlocks.length === 0) {
+    const emptyMetrics = {
+      minWidthPx: horizontalInsets,
+      maxWidthPx: horizontalInsets
+    };
+    tableCellMetricsCache.set(cacheKey, emptyMetrics);
+    return emptyMetrics;
+  }
+  let minContentWidthPx = 0;
+  let maxContentWidthPx = 0;
+  for (const block of contentBlocks) {
+    const metrics = await measureIntrinsicBlockWidthMetrics(block, options);
+    minContentWidthPx = Math.max(minContentWidthPx, metrics.minWidthPx);
+    maxContentWidthPx = Math.max(maxContentWidthPx, metrics.maxWidthPx);
+  }
+  const result = {
+    minWidthPx: minContentWidthPx + horizontalInsets,
+    maxWidthPx: maxContentWidthPx + horizontalInsets
+  };
+  tableCellMetricsCache.set(cacheKey, result);
+  return result;
+}
+async function measureTableAutoFitContentMetrics(table2, workingInput, fixedLayout, measureBlock$1) {
+  const tableMeasurementBasis = Math.max(1, fixedLayout.totalWidth);
+  const cellMetricKeys = [];
+  const rowMetrics = await Promise.all(table2.rows.map(async (row2, rowIndex) => {
+    const normalizedRow = workingInput.rows[rowIndex] ?? {};
+    return {
+      rowIndex,
+      cells: await Promise.all(row2.cells.map(async (cell2, cellIndex) => {
+        const normalizedCell = normalizedRow.cells?.[cellIndex];
+        const span = normalizedCell?.span ?? cell2.colSpan ?? 1;
+        const measurementMaxWidth = resolveAutoFitCellMeasurementMaxWidth(cell2, normalizedCell, span, fixedLayout, tableMeasurementBasis, workingInput.gridColumnCount);
+        cellMetricKeys.push(buildTableCellContentMetricsCacheKey(cell2, { maxWidth: measurementMaxWidth }));
+        const metrics = await measureTableCellContentMetrics(cell2, {
+          maxWidth: measurementMaxWidth,
+          measureBlock: measureBlock$1
+        });
+        return {
+          cellIndex,
+          span,
+          preferredWidth: normalizedCell?.preferredWidth,
+          minContentWidth: metrics.minWidthPx,
+          maxContentWidth: metrics.maxWidthPx
+        };
+      }))
+    };
+  }));
+  return {
+    rowMetrics,
+    rows: rowMetrics.map((rowMetrics$1, rowIndex) => {
+      const normalizedRow = workingInput.rows[rowIndex] ?? {};
+      return {
+        skippedBefore: normalizedRow.skippedBefore ?? [],
+        cells: rowMetrics$1.cells.map((cellMetrics) => ({
+          span: cellMetrics.span,
+          preferredWidth: cellMetrics.preferredWidth,
+          minContentWidth: cellMetrics.minContentWidth,
+          maxContentWidth: cellMetrics.maxContentWidth
+        })),
+        skippedAfter: normalizedRow.skippedAfter ?? []
+      };
+    }),
+    cellMetricKeys
+  };
+}
+async function measureIntrinsicBlockWidthMetrics(block, options) {
+  if (block.kind === "paragraph")
+    return measureParagraphIntrinsicWidthMetrics(block, options.measureBlock);
+  if (block.kind === "table")
+    return measureNestedTableIntrinsicWidthMetrics(block, options);
+  const intrinsicWidth = getIntrinsicAtomicBlockWidth(block);
+  return {
+    minWidthPx: intrinsicWidth,
+    maxWidthPx: intrinsicWidth
+  };
+}
+async function measureParagraphIntrinsicWidthMetrics(paragraph2, measureBlock$1) {
+  const maxLineWidth = (await measureBlock$1(paragraph2, {
+    maxWidth: NO_WRAP_MAX_WIDTH,
+    maxHeight: Infinity
+  })).lines.reduce((widest, line) => Math.max(widest, line.width), 0);
+  return {
+    minWidthPx: measureParagraphMinTokenWidth(paragraph2),
+    maxWidthPx: maxLineWidth
+  };
+}
+async function measureNestedTableIntrinsicWidthMetrics(table2, options) {
+  const nestedMeasure = await options.measureBlock(table2, {
+    maxWidth: Math.max(1, options.maxWidth),
+    maxHeight: Infinity
+  });
+  if (nestedMeasure.kind !== "table")
+    return {
+      minWidthPx: 0,
+      maxWidthPx: 0
+    };
+  return {
+    minWidthPx: nestedMeasure.totalWidth,
+    maxWidthPx: nestedMeasure.totalWidth
+  };
+}
+function measureParagraphMinTokenWidth(paragraph2) {
+  let widestToken = 0;
+  let currentTokenWidth = 0;
+  const flushToken = () => {
+    widestToken = Math.max(widestToken, currentTokenWidth);
+    currentTokenWidth = 0;
+  };
+  for (const run2 of paragraph2.runs) {
+    if (isExplicitLineBreakRun(run2)) {
+      flushToken();
+      continue;
+    }
+    if (isTextLikeRun(run2)) {
+      accumulateTextRunMinTokenWidth(run2, (width) => {
+        currentTokenWidth += width;
+      }, flushToken);
+      continue;
+    }
+    flushToken();
+    if (run2.kind === "image") {
+      widestToken = Math.max(widestToken, run2.width ?? 0);
+      continue;
+    }
+    if (run2.kind === "fieldAnnotation") {
+      widestToken = Math.max(widestToken, measureFieldAnnotationWidth(run2));
+      continue;
+    }
+    if (run2.kind === "math")
+      widestToken = Math.max(widestToken, run2.width ?? 0);
+  }
+  flushToken();
+  return widestToken;
+}
+function accumulateTextRunMinTokenWidth(run2, appendTokenPiece, flushToken) {
+  const font = buildFontString$1(run2);
+  let cursor = 0;
+  for (const boundary of run2.text.matchAll(TOKEN_BOUNDARY_PATTERN)) {
+    const boundaryStart = boundary.index ?? cursor;
+    if (boundaryStart > cursor)
+      appendTokenPiece(measureTextRunTokenSlice(run2, cursor, boundaryStart, font));
+    flushToken();
+    cursor = boundaryStart + boundary[0].length;
+  }
+  if (cursor < run2.text.length)
+    appendTokenPiece(measureTextRunTokenSlice(run2, cursor, run2.text.length, font));
+}
+function measureTextRunTokenSlice(run2, start$1, end$1, font) {
+  return getMeasuredTextWidth(applyTextTransform$1(run2.text.slice(start$1, end$1), run2, start$1), font, getLetterSpacing(run2), getCanvasContext$1());
+}
+function getIntrinsicAtomicBlockWidth(block) {
+  if (block.kind === "image")
+    return block.width ?? 0;
+  if (block.drawingKind === "image")
+    return block.width ?? 0;
+  if (block.drawingKind === "shapeGroup")
+    return block.size?.width ?? block.geometry.width;
+  return block.geometry.width;
+}
+function resolveAutoFitCellMeasurementMaxWidth(cell2, normalizedCell, span, fixedLayout, tableWidthBasis, gridColumnCount) {
+  const outerWidth = resolveFixedPassCellOuterWidth(normalizedCell, span, fixedLayout) ?? normalizedCell?.preferredWidth ?? Math.max(1, tableWidthBasis * (Math.max(1, span) / Math.max(1, gridColumnCount || span || 1)));
+  const padding = cell2.attrs?.padding ?? DEFAULT_CELL_PADDING$1;
+  const leftPadding = padding.left ?? DEFAULT_CELL_PADDING$1.left;
+  const rightPadding = padding.right ?? DEFAULT_CELL_PADDING$1.right;
+  const leftBorder = getCellBorderWidthPx(cell2.attrs?.borders?.left);
+  const rightBorder = getCellBorderWidthPx(cell2.attrs?.borders?.right);
+  return Math.max(1, outerWidth - leftPadding - rightPadding - leftBorder - rightBorder);
+}
+function resolveFixedPassCellOuterWidth(normalizedCell, fallbackSpan, fixedLayout) {
+  if (normalizedCell?.startColumn == null)
+    return;
+  const span = Math.max(1, normalizedCell.span ?? fallbackSpan);
+  let width = 0;
+  for (let offset$1 = 0;offset$1 < span; offset$1++)
+    width += fixedLayout.columnWidths[normalizedCell.startColumn + offset$1] ?? 0;
+  return width > 0 ? width : undefined;
+}
+function getHorizontalCellInsets(cell2) {
+  const padding = cell2.attrs?.padding ?? DEFAULT_CELL_PADDING$1;
+  const leftPadding = padding.left ?? DEFAULT_CELL_PADDING$1.left;
+  const rightPadding = padding.right ?? DEFAULT_CELL_PADDING$1.right;
+  const leftBorder = getCellBorderWidthPx(cell2.attrs?.borders?.left);
+  const rightBorder = getCellBorderWidthPx(cell2.attrs?.borders?.right);
+  return leftPadding + rightPadding + leftBorder + rightBorder;
+}
+function getCellBorderWidthPx(border) {
+  if (!border || border.style === "none")
+    return 0;
+  const width = typeof border.width === "number" ? border.width : 0;
+  if (border.style === "thick")
+    return Math.max(width * 2, 3);
+  return Math.max(0, width);
+}
+function getCanvasContext$1() {
+  if (!canvasContext$1) {
+    canvasContext$1 = document.createElement("canvas").getContext("2d");
+    if (!canvasContext$1)
+      throw new Error("Failed to create canvas context for AutoFit cell measurement.");
+  }
+  return canvasContext$1;
+}
+function buildFontString$1(run2) {
+  const parts = [];
+  if (run2.italic)
+    parts.push("italic");
+  if (run2.bold)
+    parts.push("bold");
+  parts.push(`${normalizeFontSize$1(run2.fontSize)}px`);
+  parts.push(toCssFontFamily(normalizeFontFamily$1(run2.fontFamily)) ?? normalizeFontFamily$1(run2.fontFamily));
+  return parts.join(" ");
+}
+function applyTextTransform$1(text5, run2, startOffset = 0) {
+  const transform = run2.textTransform;
+  if (!text5 || !transform || transform === "none")
+    return text5;
+  if (transform === "uppercase")
+    return text5.toUpperCase();
+  if (transform === "lowercase")
+    return text5.toLowerCase();
+  if (transform === "capitalize")
+    return capitalizeText$1(text5, run2.text ?? text5, startOffset);
+  return text5;
+}
+function capitalizeText$1(text5, fullText, startOffset) {
+  let result = "";
+  for (let index2 = 0;index2 < text5.length; index2++) {
+    const absoluteIndex = startOffset + index2;
+    const currentChar = text5[index2];
+    const previousChar = absoluteIndex > 0 ? fullText[absoluteIndex - 1] : "";
+    result += isWordCharacter(currentChar) && !isWordCharacter(previousChar) ? currentChar.toUpperCase() : currentChar;
+  }
+  return result;
+}
+function measureFieldAnnotationWidth(run2) {
+  const fontSize = typeof run2.fontSize === "number" ? run2.fontSize : typeof run2.fontSize === "string" ? parseFloat(run2.fontSize) || DEFAULT_FIELD_ANNOTATION_FONT_SIZE$1 : DEFAULT_FIELD_ANNOTATION_FONT_SIZE$1;
+  const font = buildFontString$1({
+    fontFamily: normalizeFontFamily$1(run2.fontFamily ?? "Arial"),
+    fontSize,
+    bold: run2.bold,
+    italic: run2.italic
+  });
+  return getMeasuredTextWidth(applyTextTransform$1(run2.displayLabel || "", { text: run2.displayLabel || "" }), font, 0, getCanvasContext$1()) + (run2.highlighted === false ? 0 : FIELD_ANNOTATION_PILL_PADDING$1);
+}
+function isExplicitLineBreakRun(run2) {
+  return run2.kind === "lineBreak" || run2.kind === "break" && run2.breakType === "line";
+}
+function isTextLikeRun(run2) {
+  return "text" in run2 && typeof run2.text === "string";
+}
+function getLetterSpacing(run2) {
+  return "letterSpacing" in run2 && typeof run2.letterSpacing === "number" ? run2.letterSpacing : 0;
+}
+function normalizeFontSize$1(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0)
+    return value;
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return 12;
+}
+function normalizeFontFamily$1(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : "Arial";
+}
+function stableSerialize(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+  return `{${Object.entries(value).sort(([left$1], [right$1]) => left$1.localeCompare(right$1)).map(([key2, entry]) => `${JSON.stringify(key2)}:${stableSerialize(entry)}`).join(",")}}`;
+}
+function isWordCharacter(value) {
+  return /[A-Za-z0-9]/.test(value);
+}
 function getTableBorderWidthPx(value) {
   if (value == null)
     return 0;
@@ -266335,141 +267884,9 @@ async function measureParagraphBlock(block, maxWidth) {
     ...dropCapMeasure ? { dropCap: dropCapMeasure } : {}
   };
 }
-function resolveTableWidth(attrs, maxWidth) {
-  const tableWidthAttr = resolveTableWidthAttr(attrs?.tableWidth);
-  if (!tableWidthAttr)
-    return;
-  if (tableWidthAttr.type === "pct")
-    return Math.round(maxWidth * (tableWidthAttr.width / OOXML_PCT_DIVISOR));
-  else if (tableWidthAttr.type === "px" || tableWidthAttr.type === "pixel" || tableWidthAttr.type === "dxa")
-    return tableWidthAttr.width;
-}
 async function measureTableBlock(block, constraints) {
-  const maxWidth = typeof constraints === "number" ? constraints : constraints.maxWidth;
-  const resolvedTableWidth = resolveTableWidth(block.attrs, maxWidth);
-  let columnWidths;
-  const maxCellCount = Math.max(1, Math.max(...block.rows.map((r$1) => r$1.cells.reduce((sum, cell2) => sum + (cell2.colSpan ?? 1), 0))));
-  const effectiveTargetWidth = resolvedTableWidth != null ? resolvedTableWidth : maxWidth;
-  if (block.columnWidths && block.columnWidths.length > 0) {
-    columnWidths = [...block.columnWidths];
-    const hasExplicitWidth = resolvedTableWidth != null;
-    const hasFixedLayout = block.attrs?.tableLayout === "fixed";
-    if (hasExplicitWidth || hasFixedLayout) {
-      const totalWidth$1 = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-      const tableWidthType = block.attrs?.tableWidth?.type;
-      const targetWidth = hasExplicitWidth ? effectiveTargetWidth : totalWidth$1;
-      if ((totalWidth$1 > targetWidth || totalWidth$1 < targetWidth && targetWidth > 0 && (tableWidthType === "pct" || hasExplicitWidth && !hasFixedLayout)) && targetWidth > 0 && totalWidth$1 > 0) {
-        const scale = targetWidth / totalWidth$1;
-        columnWidths = columnWidths.map((w) => Math.max(1, Math.round(w * scale)));
-        const scaledSum = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-        if (scaledSum !== targetWidth && columnWidths.length > 0) {
-          const diff = targetWidth - scaledSum;
-          columnWidths[columnWidths.length - 1] = Math.max(1, columnWidths[columnWidths.length - 1] + diff);
-        }
-      }
-    } else if (columnWidths.length < maxCellCount) {
-      const usedWidth = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-      const remainingWidth = Math.max(0, effectiveTargetWidth - usedWidth);
-      const missingColumns = maxCellCount - columnWidths.length;
-      const paddingWidth = Math.max(1, Math.floor(remainingWidth / missingColumns));
-      columnWidths.push(...Array.from({ length: missingColumns }, () => paddingWidth));
-    } else if (columnWidths.length > maxCellCount)
-      columnWidths = columnWidths.slice(0, maxCellCount);
-  } else {
-    const columnWidth = Math.max(1, Math.floor(effectiveTargetWidth / maxCellCount));
-    columnWidths = Array.from({ length: maxCellCount }, () => columnWidth);
-  }
-  const isFixedLayout = block.attrs?.tableLayout === "fixed";
-  const gridLooksLikePlaceholder = columnWidths.reduce((a2, b$1) => a2 + b$1, 0) < maxWidth * 0.1;
-  if (!isFixedLayout && gridLooksLikePlaceholder) {
-    const gridColCount = columnWidths.length;
-    const maxContentWidths = new Array(gridColCount).fill(0);
-    const autoFitRowspanTracker = new Array(gridColCount).fill(0);
-    for (const row2 of block.rows) {
-      let colIndex = 0;
-      for (const cell2 of row2.cells) {
-        const colspan = cell2.colSpan ?? 1;
-        const rowspan = cell2.rowSpan ?? 1;
-        while (colIndex < gridColCount && autoFitRowspanTracker[colIndex] > 0) {
-          autoFitRowspanTracker[colIndex]--;
-          colIndex++;
-        }
-        if (colIndex >= gridColCount)
-          break;
-        if (colspan === 1) {
-          const cellPadding = cell2.attrs?.padding ?? DEFAULT_CELL_PADDING;
-          const paddingH = (cellPadding.left ?? 4) + (cellPadding.right ?? 4);
-          const cellBlocks = cell2.blocks ?? (cell2.paragraph ? [cell2.paragraph] : []);
-          let cellMaxWidth = 0;
-          for (const cellBlock of cellBlocks) {
-            const maxMeasure = await measureBlock(cellBlock, {
-              maxWidth: 99999,
-              maxHeight: Infinity
-            });
-            let blockMaxWidth = 0;
-            if (maxMeasure.kind === "paragraph") {
-              for (const line of maxMeasure.lines)
-                if (line.width > blockMaxWidth)
-                  blockMaxWidth = line.width;
-            } else if (maxMeasure.kind === "image" || maxMeasure.kind === "drawing")
-              blockMaxWidth = maxMeasure.width;
-            else if (maxMeasure.kind === "table")
-              blockMaxWidth = maxMeasure.totalWidth;
-            else if (maxMeasure.kind === "list") {
-              for (const item of maxMeasure.items)
-                if (item.paragraph) {
-                  const gutterWidth = (item.indentLeft ?? 0) + (item.markerWidth ?? 0);
-                  for (const line of item.paragraph.lines) {
-                    const lineTotal = gutterWidth + line.width;
-                    if (lineTotal > blockMaxWidth)
-                      blockMaxWidth = lineTotal;
-                  }
-                }
-            }
-            if (blockMaxWidth > cellMaxWidth)
-              cellMaxWidth = blockMaxWidth;
-          }
-          const totalWidth$1 = cellMaxWidth + paddingH;
-          if (totalWidth$1 > maxContentWidths[colIndex])
-            maxContentWidths[colIndex] = totalWidth$1;
-        }
-        if (rowspan > 1)
-          for (let c = 0;c < colspan && colIndex + c < gridColCount; c++)
-            autoFitRowspanTracker[colIndex + c] = rowspan - 1;
-        colIndex += colspan;
-      }
-      for (let col = colIndex;col < gridColCount; col++)
-        if (autoFitRowspanTracker[col] > 0)
-          autoFitRowspanTracker[col]--;
-    }
-    const contentTotal = maxContentWidths.reduce((a2, b$1) => a2 + b$1, 0);
-    if (contentTotal > 0)
-      if (contentTotal <= maxWidth) {
-        for (let i4 = 0;i4 < gridColCount; i4++)
-          if (maxContentWidths[i4] > columnWidths[i4])
-            columnWidths[i4] = maxContentWidths[i4];
-        const expandedTotal = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-        if (expandedTotal > maxWidth && gridColCount > 0) {
-          const scale = maxWidth / expandedTotal;
-          for (let i4 = 0;i4 < gridColCount; i4++)
-            columnWidths[i4] = Math.max(1, Math.round(columnWidths[i4] * scale));
-          const scaledSum = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-          if (scaledSum !== maxWidth) {
-            const diff = maxWidth - scaledSum;
-            columnWidths[gridColCount - 1] = Math.max(1, columnWidths[gridColCount - 1] + diff);
-          }
-        }
-      } else {
-        const scale = maxWidth / contentTotal;
-        for (let i4 = 0;i4 < gridColCount; i4++)
-          columnWidths[i4] = Math.max(1, Math.round(maxContentWidths[i4] * scale));
-        const scaledSum = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-        if (scaledSum !== maxWidth && gridColCount > 0) {
-          const diff = maxWidth - scaledSum;
-          columnWidths[gridColCount - 1] = Math.max(1, columnWidths[gridColCount - 1] + diff);
-        }
-      }
-  }
+  const workingInput = buildAutoFitWorkingGridInput(block, { maxWidth: typeof constraints === "number" ? constraints : constraints.maxWidth });
+  const columnWidths = await resolveRuntimeTableColumnWidths(block, workingInput);
   const gridColumnCount = columnWidths.length;
   const calculateCellWidth = (startCol, colspan) => {
     let width = 0;
@@ -266483,11 +267900,19 @@ async function measureTableBlock(block, constraints) {
   const spanConstraints = [];
   for (let rowIndex = 0;rowIndex < block.rows.length; rowIndex++) {
     const row2 = block.rows[rowIndex];
+    const normalizedRow = workingInput.rows[rowIndex];
     const cellMeasures = [];
     let gridColIndex = 0;
-    for (const cell2 of row2.cells) {
+    for (let cellIndex = 0;cellIndex < row2.cells.length; cellIndex++) {
+      const cell2 = row2.cells[cellIndex];
       const colspan = cell2.colSpan ?? 1;
       const rowspan = cell2.rowSpan ?? 1;
+      const preferredStartColumn = normalizedRow?.cells?.[cellIndex]?.startColumn ?? gridColIndex;
+      while (gridColIndex < gridColumnCount && gridColIndex < preferredStartColumn) {
+        if (rowspanTracker[gridColIndex] > 0)
+          rowspanTracker[gridColIndex]--;
+        gridColIndex++;
+      }
       while (gridColIndex < gridColumnCount && rowspanTracker[gridColIndex] > 0) {
         rowspanTracker[gridColIndex]--;
         gridColIndex++;
@@ -266590,18 +268015,48 @@ async function measureTableBlock(block, constraints) {
   const borderWidthH = tableBorderWidths.left + tableBorderWidths.right;
   const borderWidthV = tableBorderWidths.top + tableBorderWidths.bottom;
   const includeOuterBordersInTotal = (block.attrs?.borderCollapse ?? (block.attrs?.cellSpacing != null ? "separate" : "collapse")) === "separate";
-  const totalWidth = contentWidth + horizontalGaps + (includeOuterBordersInTotal ? borderWidthH : 0);
-  const totalHeight = contentHeight + verticalGaps + (includeOuterBordersInTotal ? borderWidthV : 0);
   return {
     kind: "table",
     rows,
     columnWidths,
-    totalWidth,
-    totalHeight,
+    totalWidth: contentWidth + horizontalGaps + (includeOuterBordersInTotal ? borderWidthH : 0),
+    totalHeight: contentHeight + verticalGaps + (includeOuterBordersInTotal ? borderWidthV : 0),
     cellSpacingPx: cellSpacingPx > 0 ? cellSpacingPx : undefined,
     tableBorderWidths: borderWidthH > 0 || borderWidthV > 0 ? tableBorderWidths : undefined
   };
 }
+async function resolveRuntimeTableColumnWidths(block, workingInput) {
+  const fixedLayout = computeFixedTableColumnWidths(workingInput);
+  if (workingInput.layoutMode === "fixed")
+    return fixedLayout.columnWidths;
+  const { contentMetrics, cellMetricKeys } = await buildMeasuredAutoFitContentMetrics(block, workingInput, fixedLayout);
+  const cacheKey = buildAutoFitTableResultCacheKey(block, {
+    maxWidth: workingInput.maxTableWidth,
+    cellMetricKeys,
+    workingInput,
+    fixedLayout
+  });
+  const cached = getCachedAutoFitTableResult(cacheKey);
+  if (cached)
+    return cached.columnWidths;
+  const result = computeAutoFitColumnWidths({
+    workingInput,
+    fixedLayout,
+    contentMetrics: { rowMetrics: contentMetrics.rowMetrics }
+  });
+  setCachedAutoFitTableResult(cacheKey, {
+    columnWidths: result.columnWidths,
+    totalWidth: result.totalWidth
+  });
+  return result.columnWidths;
+}
+async function buildMeasuredAutoFitContentMetrics(block, workingInput, fixedLayout) {
+  const contentMetrics = await measureTableAutoFitContentMetrics(block, workingInput, fixedLayout, measureBlock);
+  return {
+    contentMetrics,
+    cellMetricKeys: contentMetrics.cellMetricKeys
+  };
+}
 async function measureImageBlock(block, constraints) {
   const intrinsic = getIntrinsicImageSize(block, constraints.maxWidth);
   const isBlockBehindDoc = block.anchor?.behindDoc;
@@ -267454,7 +268909,7 @@ var Node$13 = class Node$14 {
     "iPhone",
     "iPod"
   ].includes(navigator.platform);
-}, OOXML_PCT_DIVISOR = 5000, TWIPS_PER_PX$2 = 15, isPlainObject$7 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), OOXML_Z_INDEX_BASE = 251658240, SPACE_CHARS, isAtomicRunKind = (kind) => kind === "image" || kind === "lineBreak" || kind === "break" || kind === "tab" || kind === "fieldAnnotation", isImageLikeRun = (run2) => {
+}, OOXML_PCT_DIVISOR = 5000, TWIPS_PER_PX$3 = 15, isPlainObject$7 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), OOXML_Z_INDEX_BASE = 251658240, SPACE_CHARS, isAtomicRunKind = (kind) => kind === "image" || kind === "lineBreak" || kind === "break" || kind === "tab" || kind === "fieldAnnotation", isImageLikeRun = (run2) => {
   if (!run2 || typeof run2 !== "object")
     return false;
   return typeof run2.src === "string";
@@ -269721,7 +271176,7 @@ var Node$13 = class Node$14 {
     const transaction = view.state.tr.setSelection(selection);
     view.dispatch(transaction);
   }
-}, StructuredContentInlineView, STRUCTURED_CONTENT_LOCK_KEY, structuredContentClass = "sd-structured-content", structuredContentInnerClass = "sd-structured-content__content", StructuredContent, StructuredContentBlockView, structuredContentBlockClass = "sd-structured-content-block", structuredContentBlockInnerClass = "sd-structured-content-block__content", StructuredContentBlock, structuredContentHelpers_exports, STRUCTURED_CONTENT_NAMES, findFirstTextNode$1 = (node3) => {
+}, StructuredContentInlineView, STRUCTURED_CONTENT_LOCK_KEY, INLINE_LEAF_TEXT = "", structuredContentClass = "sd-structured-content", structuredContentInnerClass = "sd-structured-content__content", StructuredContent, StructuredContentBlockView, structuredContentBlockClass = "sd-structured-content-block", structuredContentBlockInnerClass = "sd-structured-content-block__content", StructuredContentBlock, structuredContentHelpers_exports, STRUCTURED_CONTENT_NAMES, findFirstTextNode$1 = (node3) => {
   let firstTextNode = null;
   node3.descendants((child) => {
     if (child.isText) {
@@ -283105,6 +284560,8 @@ var Node$13 = class Node$14 {
   border: 1px solid transparent;
   position: relative;
   display: inline;
+  font-size: initial;
+  line-height: normal;
   z-index: 10;
 }
 
@@ -287025,9 +288482,17 @@ menclose::after {
       inlineBorders = normalizeTableBorders(tableProps.borders);
     if (typeof tableProps.justification === "string")
       hydration.justification = tableProps.justification;
+    const tableIndent = normalizeTableIndent(tableProps.tableIndent);
+    if (tableIndent)
+      hydration.tableIndent = tableIndent;
+    if (typeof tableProps.tableLayout === "string")
+      hydration.tableLayout = tableProps.tableLayout;
     const tableWidth = normalizeTableWidth(tableProps.tableWidth);
     if (tableWidth)
       hydration.tableWidth = tableWidth;
+    const tableCellSpacing = normalizeTableSpacing(tableProps.tableCellSpacing);
+    if (tableCellSpacing)
+      hydration.tableCellSpacing = tableCellSpacing;
   }
   const styleId = effectiveStyleId === null ? undefined : effectiveStyleId ?? (typeof tableNode.attrs?.tableStyleId === "string" ? tableNode.attrs.tableStyleId : undefined);
   if (styleId && context?.translatedLinkedStyles) {
@@ -287054,8 +288519,18 @@ menclose::after {
       hydration.cellPadding = inlinePadding;
     if (!hydration.justification && resolved.justification)
       hydration.justification = resolved.justification;
-    if (resolved.tableCellSpacing)
-      hydration.tableCellSpacing = resolved.tableCellSpacing;
+    if (!hydration.tableIndent && resolved.tableIndent) {
+      const tableIndent = normalizeTableIndent(resolved.tableIndent);
+      if (tableIndent)
+        hydration.tableIndent = tableIndent;
+    }
+    if (!hydration.tableLayout && resolved.tableLayout)
+      hydration.tableLayout = resolved.tableLayout;
+    if (!hydration.tableCellSpacing && resolved.tableCellSpacing) {
+      const tableCellSpacing = normalizeTableSpacing(resolved.tableCellSpacing);
+      if (tableCellSpacing)
+        hydration.tableCellSpacing = tableCellSpacing;
+    }
     if (!hydration.tableWidth && resolved.tableWidth) {
       const tableWidth = normalizeTableWidth(resolved.tableWidth);
       if (tableWidth)
@@ -287153,7 +288628,41 @@ menclose::after {
     width: raw,
     type: measurement.type
   };
-}, isTableRowNode = (node3) => node3.type === "tableRow" || node3.type === "table_row", isTableCellNode = (node3) => node3.type === "tableCell" || node3.type === "table_cell" || node3.type === "tableHeader" || node3.type === "table_header", convertResolvedCellBorder = (value) => {
+}, normalizeTableIndent = (value) => {
+  if (!value || typeof value !== "object")
+    return;
+  const measurement = value;
+  const raw = typeof measurement.width === "number" ? measurement.width : measurement.value;
+  if (typeof raw !== "number")
+    return;
+  if (!measurement.type || measurement.type === "px" || measurement.type === "pixel")
+    return {
+      width: raw,
+      type: measurement.type ?? "px"
+    };
+  if (measurement.type === "dxa")
+    return {
+      width: twipsToPx$2(raw),
+      type: "dxa"
+    };
+  return {
+    width: raw,
+    type: measurement.type
+  };
+}, normalizeTableSpacing = (value) => {
+  if (!value || typeof value !== "object")
+    return;
+  const measurement = value;
+  if (typeof measurement.value !== "number")
+    return;
+  return {
+    value: measurement.value,
+    type: measurement.type ?? "px"
+  };
+}, isTableRowNode = (node3) => node3.type === "tableRow" || node3.type === "table_row", isTableCellNode = (node3) => node3.type === "tableCell" || node3.type === "table_cell" || node3.type === "tableHeader" || node3.type === "table_header", isTableSkipPlaceholderCell = (node3) => {
+  const placeholder = node3.attrs?.__placeholder;
+  return placeholder === "gridBefore" || placeholder === "gridAfter";
+}, convertResolvedCellBorder = (value) => {
   if (!value || typeof value !== "object")
     return;
   const border = value;
@@ -287421,6 +288930,8 @@ menclose::after {
   const cells = [];
   const rowCnfStyle = rowNode.attrs?.tableRowProperties?.cnfStyle;
   rowNode.content.forEach((cellNode, cellIndex) => {
+    if (isTableCellNode(cellNode) && isTableSkipPlaceholderCell(cellNode))
+      return;
     const parsedCell = parseTableCell({
       cellNode,
       rowIndex,
@@ -287771,7 +289282,7 @@ menclose::after {
       return true;
   }
   return false;
-}, capitalizeText$2 = (text5) => {
+}, capitalizeText$3 = (text5) => {
   if (!text5)
     return text5;
   let result = "";
@@ -287781,7 +289292,7 @@ menclose::after {
     result += isWordChar$3(ch) && !isWordChar$3(prevChar) ? ch.toUpperCase() : ch;
   }
   return result;
-}, applyTextTransform$2 = (text5, transform) => {
+}, applyTextTransform$3 = (text5, transform) => {
   if (!text5 || !transform || transform === "none")
     return text5;
   if (transform === "uppercase")
@@ -287789,7 +289300,7 @@ menclose::after {
   if (transform === "lowercase")
     return text5.toLowerCase();
   if (transform === "capitalize")
-    return capitalizeText$2(text5);
+    return capitalizeText$3(text5);
   return text5;
 }, countSpaces = (text5) => {
   let spaces = 0;
@@ -288577,7 +290088,7 @@ menclose::after {
     return false;
   const code7 = char.charCodeAt(0);
   return code7 >= 48 && code7 <= 57 || code7 >= 65 && code7 <= 90 || code7 >= 97 && code7 <= 122 || char === "'";
-}, capitalizeText$1 = (text5, fullText, startOffset) => {
+}, capitalizeText$2 = (text5, fullText, startOffset) => {
   if (!text5)
     return text5;
   const hasFullText = typeof startOffset === "number" && fullText != null;
@@ -288588,7 +290099,7 @@ menclose::after {
     result += isWordChar$1(ch) && !isWordChar$1(prevChar) ? ch.toUpperCase() : ch;
   }
   return result;
-}, applyTextTransform$1 = (text5, transform, fullText, startOffset) => {
+}, applyTextTransform$2 = (text5, transform, fullText, startOffset) => {
   if (!text5 || !transform || transform === "none")
     return text5;
   if (transform === "uppercase")
@@ -288596,9 +290107,9 @@ menclose::after {
   if (transform === "lowercase")
     return text5.toLowerCase();
   if (transform === "capitalize")
-    return capitalizeText$1(text5, fullText, startOffset);
+    return capitalizeText$2(text5, fullText, startOffset);
   return text5;
-}, DEFAULT_TAB_INTERVAL_TWIPS$1 = 720, TWIPS_PER_PX$1, TAB_EPSILON$1 = 0.1, WIDTH_FUDGE_PX = 0.5, twipsToPx$1 = (twips) => twips / TWIPS_PER_PX$1, pxToTwips$1 = (px) => Math.round(px * TWIPS_PER_PX$1), sanitizeIndent$1 = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0, sanitizeDecimalSeparator$1 = (value) => value === "," ? "," : ".", getRunWidth = (run2) => {
+}, DEFAULT_TAB_INTERVAL_TWIPS$1 = 720, TWIPS_PER_PX$2, TAB_EPSILON$1 = 0.1, WIDTH_FUDGE_PX = 0.5, twipsToPx$1 = (twips) => twips / TWIPS_PER_PX$2, pxToTwips$1 = (px) => Math.round(px * TWIPS_PER_PX$2), sanitizeIndent$1 = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0, sanitizeDecimalSeparator$1 = (value) => value === "," ? "," : ".", getRunWidth = (run2) => {
   const width = run2.width;
   return typeof width === "number" ? width : 0;
 }, isLineBreakRun$1 = (run2) => run2.kind === "lineBreak" || run2.kind === "break" && run2.breakType === "line", markerFontString = (run2) => {
@@ -290206,13 +291717,13 @@ menclose::after {
   if (startA == null)
     return false;
   return (endA ?? startA + 1) > startB && startA < endB;
-}, DEFAULT_CELL_PADDING$1, getCellPaddingFromRow = (cellIdx, row2) => {
+}, DEFAULT_CELL_PADDING$2, getCellPaddingFromRow = (cellIdx, row2) => {
   const padding = row2?.cells?.[cellIdx]?.attrs?.padding ?? {};
   return {
-    top: padding.top ?? DEFAULT_CELL_PADDING$1.top,
-    bottom: padding.bottom ?? DEFAULT_CELL_PADDING$1.bottom,
-    left: padding.left ?? DEFAULT_CELL_PADDING$1.left,
-    right: padding.right ?? DEFAULT_CELL_PADDING$1.right
+    top: padding.top ?? DEFAULT_CELL_PADDING$2.top,
+    bottom: padding.bottom ?? DEFAULT_CELL_PADDING$2.bottom,
+    left: padding.left ?? DEFAULT_CELL_PADDING$2.left,
+    right: padding.right ?? DEFAULT_CELL_PADDING$2.right
   };
 }, getCellBlocks = (cell2) => {
   if (!cell2)
@@ -294692,7 +296203,41 @@ menclose::after {
   }
 }, EMUS_PER_INCH = 914400, maxSize = 5000, cache, makeKey = (text5, font, letterSpacing) => {
   return `${text5}|${font}|${letterSpacing || 0}`;
-}, fontMetricsCache, MAX_CACHE_SIZE = 1000, METRICS_TEST_STRING = "MHgypbdlÁÉÍ", computeTabStops, measurementConfig, canvasContext = null, DEFAULT_TAB_INTERVAL_TWIPS = 720, TWIPS_PER_PX, twipsToPx = (twips) => twips / TWIPS_PER_PX, pxToTwips = (px) => Math.round(px * TWIPS_PER_PX), DEFAULT_TAB_INTERVAL_PX, TAB_EPSILON = 0.1, DEFAULT_CELL_PADDING, DEFAULT_DECIMAL_SEPARATOR = ".", ALLOWED_TAB_VALS, FIELD_ANNOTATION_PILL_PADDING = 8, FIELD_ANNOTATION_LINE_HEIGHT_MULTIPLIER = 1.2, FIELD_ANNOTATION_VERTICAL_PADDING = 6, DEFAULT_FIELD_ANNOTATION_FONT_SIZE = 16, DEFAULT_PARAGRAPH_FONT_SIZE = 12, DEFAULT_PARAGRAPH_FONT_FAMILY = "Arial", isValidFontSize = (value) => typeof value === "number" && Number.isFinite(value) && value > 0, normalizeFontSize = (value, fallback = DEFAULT_PARAGRAPH_FONT_SIZE) => {
+}, fontMetricsCache, MAX_CACHE_SIZE = 1000, METRICS_TEST_STRING = "MHgypbdlÁÉÍ", DEFAULT_MIN_COLUMN_WIDTH = 8, TWIPS_PER_PX$1 = 15, PLACEHOLDER_COLUMN_MAX_WIDTH = 1, DEFAULT_CELL_PADDING$1, DEFAULT_FIELD_ANNOTATION_FONT_SIZE$1 = 16, FIELD_ANNOTATION_PILL_PADDING$1 = 8, TABLE_CELL_METRICS_CACHE_SIZE = 2000, TABLE_AUTOFIT_RESULT_CACHE_SIZE = 500, NO_WRAP_MAX_WIDTH, TOKEN_BOUNDARY_PATTERN, LruCache = class {
+  constructor(maxSize$1) {
+    this.cache = /* @__PURE__ */ new Map;
+    this.maxSize = maxSize$1;
+  }
+  get(key2) {
+    const hit = this.cache.get(key2);
+    if (!hit)
+      return;
+    this.cache.delete(key2);
+    this.cache.set(key2, hit);
+    return hit.value;
+  }
+  set(key2, value) {
+    this.cache.set(key2, { value });
+    this.evictIfNeeded();
+  }
+  clear() {
+    this.cache.clear();
+  }
+  resize(nextSize) {
+    if (!Number.isFinite(nextSize) || nextSize <= 0)
+      return;
+    this.maxSize = nextSize;
+    this.evictIfNeeded();
+  }
+  evictIfNeeded() {
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === undefined)
+        break;
+      this.cache.delete(oldestKey);
+    }
+  }
+}, tableCellMetricsCache, autoFitTableResultCache, canvasContext$1 = null, computeTabStops, measurementConfig, canvasContext = null, DEFAULT_TAB_INTERVAL_TWIPS = 720, TWIPS_PER_PX, twipsToPx = (twips) => twips / TWIPS_PER_PX, pxToTwips = (px) => Math.round(px * TWIPS_PER_PX), DEFAULT_TAB_INTERVAL_PX, TAB_EPSILON = 0.1, DEFAULT_CELL_PADDING, DEFAULT_DECIMAL_SEPARATOR = ".", ALLOWED_TAB_VALS, FIELD_ANNOTATION_PILL_PADDING = 8, FIELD_ANNOTATION_LINE_HEIGHT_MULTIPLIER = 1.2, FIELD_ANNOTATION_VERTICAL_PADDING = 6, DEFAULT_FIELD_ANNOTATION_FONT_SIZE = 16, DEFAULT_PARAGRAPH_FONT_SIZE = 12, DEFAULT_PARAGRAPH_FONT_FAMILY = "Arial", isValidFontSize = (value) => typeof value === "number" && Number.isFinite(value) && value > 0, normalizeFontSize = (value, fallback = DEFAULT_PARAGRAPH_FONT_SIZE) => {
   if (isValidFontSize(value))
     return value;
   if (typeof value === "string") {
@@ -296523,12 +298068,12 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_BzRjWTpH_es = __esm(() => {
+var init_src_DAF1K_X_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_BTy5lByv_es();
+  init_SuperConverter_Dchjy0My_es();
   init_jszip_C49i9kUs_es();
   init_uuid_qzgm05fK_es();
-  init_create_headless_toolbar_k6nNYL53_es();
+  init_create_headless_toolbar_CEcVKzGV_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -323231,7 +324776,7 @@ function print() { __p += __j.call(arguments, '') }
     "even",
     "odd"
   ];
-  TWIPS_PER_PX$1 = 1440 / 96;
+  TWIPS_PER_PX$2 = 1440 / 96;
   init_dist4();
   measureCache = new MeasureCache;
   headerMeasureCache = new HeaderFooterLayoutCache;
@@ -323260,7 +324805,7 @@ function print() { __p += __j.call(arguments, '') }
     workerRoundTrip: 10,
     layoutStaleness: 100
   });
-  DEFAULT_CELL_PADDING$1 = {
+  DEFAULT_CELL_PADDING$2 = {
     top: 0,
     bottom: 0,
     left: 4,
@@ -327867,6 +329412,16 @@ function print() { __p += __j.call(arguments, '') }
   EMUS_PER_INCH / 96;
   cache = /* @__PURE__ */ new Map;
   fontMetricsCache = /* @__PURE__ */ new Map;
+  DEFAULT_CELL_PADDING$1 = {
+    top: 0,
+    right: 4,
+    bottom: 0,
+    left: 4
+  };
+  NO_WRAP_MAX_WIDTH = Number.MAX_SAFE_INTEGER;
+  TOKEN_BOUNDARY_PATTERN = /[ \t\f\v\-\u00ad\u2010\u2012\u2013\u2014\u200b\u2028\u2029]+|\r\n|\r|\n|\u2028|\u2029/gu;
+  tableCellMetricsCache = new LruCache(TABLE_CELL_METRICS_CACHE_SIZE);
+  autoFitTableResultCache = new LruCache(TABLE_AUTOFIT_RESULT_CACHE_SIZE);
   ({ computeTabStops } = engines_exports);
   measurementConfig = {
     mode: "browser",
@@ -333739,11 +335294,11 @@ function print() { __p += __j.call(arguments, '') }
   ];
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-BUfd0WN3.es.js
+// ../../packages/superdoc/dist/chunks/create-super-doc-ui-HW4PZyuU.es.js
 var ALL_TOOLBAR_COMMAND_IDS, EMPTY_ACTIVE_IDS;
-var init_create_super_doc_ui_BUfd0WN3_es = __esm(() => {
-  init_SuperConverter_BTy5lByv_es();
-  init_create_headless_toolbar_k6nNYL53_es();
+var init_create_super_doc_ui_HW4PZyuU_es = __esm(() => {
+  init_SuperConverter_Dchjy0My_es();
+  init_create_headless_toolbar_CEcVKzGV_es();
   ALL_TOOLBAR_COMMAND_IDS = Object.keys(createToolbarRegistry());
   EMPTY_ACTIVE_IDS = Object.freeze([]);
 });
@@ -333761,16 +335316,16 @@ var init_zipper_BxRAi0_5_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_BzRjWTpH_es();
-  init_SuperConverter_BTy5lByv_es();
+  init_src_DAF1K_X_es();
+  init_SuperConverter_Dchjy0My_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_k6nNYL53_es();
+  init_create_headless_toolbar_CEcVKzGV_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
   init_DocxZipper_CUX64E5K_es();
-  init_create_super_doc_ui_BUfd0WN3_es();
+  init_create_super_doc_ui_HW4PZyuU_es();
   init_ui_CGB3qmy3_es();
   init_eventemitter3_BJrNoN9D_es();
   init_errors_C_DoKMoN_es();