@superdoc-dev/cli 0.8.0-next.34 → 0.8.0-next.36

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-CCV76OsP.es.js
+// ../../packages/superdoc/dist/chunks/src-Dinif16O.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -207334,6 +207398,18 @@ function calculateTabWidth(params$1) {
     tabStopPosUsed: nextStop.pos
   };
 }
+function resolveTableWidthAttr(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const measurement = value;
+  const width = measurement.width ?? measurement.value;
+  if (typeof width !== "number" || !Number.isFinite(width) || width <= 0)
+    return null;
+  return {
+    width,
+    type: measurement.type
+  };
+}
 function resolveColumnWidths(columns, availableWidth) {
   const width = availableWidth / columns.length;
   return columns.map(() => width);
@@ -207365,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) {
@@ -221842,7 +221918,8 @@ function executeTextSelector(editor, index2, query2, diagnostics) {
   const rawResult = requireEditorCommand(editor.commands?.search, "find (search)")(pattern, {
     highlight: false,
     caseSensitive: selector.caseSensitive ?? false,
-    maxMatches: Infinity
+    maxMatches: Infinity,
+    searchModel: "visible"
   });
   if (!Array.isArray(rawResult))
     throw new DocumentApiAdapterError("CAPABILITY_UNAVAILABLE", "Editor search command returned an unexpected result format.");
@@ -228977,6 +229054,28 @@ function toNotFoundError(input2) {
 function isSameTarget(left$1, right$1) {
   return left$1.blockId === right$1.blockId && left$1.range.start === right$1.range.start && left$1.range.end === right$1.range.end;
 }
+function isTextAddressShape(target) {
+  if (!target || typeof target !== "object")
+    return false;
+  const t = target;
+  if (t.kind !== "text")
+    return false;
+  if (typeof t.blockId !== "string")
+    return false;
+  return isTextRangeShape(t.range);
+}
+function isTextRangeShape(range) {
+  if (!range || typeof range !== "object")
+    return false;
+  const r$1 = range;
+  return Number.isInteger(r$1.start) && Number.isInteger(r$1.end) && r$1.start <= r$1.end;
+}
+function isTextSegmentShape(segment) {
+  if (!segment || typeof segment !== "object")
+    return false;
+  const seg = segment;
+  return typeof seg.blockId === "string" && isTextRangeShape(seg.range);
+}
 function isTextTargetShape(target) {
   if (!target || typeof target !== "object")
     return false;
@@ -228985,17 +229084,19 @@ function isTextTargetShape(target) {
     return false;
   if (!Array.isArray(t.segments) || t.segments.length === 0)
     return false;
-  if (typeof t.blockId === "string" || t.range !== undefined && t.range !== null)
+  if (!t.segments.every(isTextSegmentShape))
     return false;
   return true;
 }
 function targetToSegments(target) {
+  if (isTextAddressShape(target))
+    return [{
+      blockId: target.blockId,
+      range: target.range
+    }];
   if (isTextTargetShape(target))
     return [...target.segments];
-  return [{
-    blockId: target.blockId,
-    range: target.range
-  }];
+  return null;
 }
 function listCommentAnchorsSafe(editor) {
   try {
@@ -229213,6 +229314,15 @@ function addCommentHandler(editor, input2, options) {
       }
     };
   const segments = targetToSegments(target);
+  if (!segments)
+    return {
+      success: false,
+      failure: {
+        code: "INVALID_TARGET",
+        message: "Comment target must be a TextAddress or TextTarget.",
+        details: { target }
+      }
+    };
   for (const seg of segments)
     if (seg.range.start === seg.range.end)
       return {
@@ -234132,8 +234242,9 @@ function resolveCurrentSelectionInfo(editor, input2) {
       activeCommentIds: [],
       activeChangeIds: []
     };
-  const { from: from$1, to, empty: empty$1 } = state.selection;
-  const segments = collectTextSegments(state.doc, from$1, to);
+  const sel = state.selection;
+  const { from: from$1, to, empty: empty$1 } = sel;
+  const segments = shouldProjectTextTarget(sel) ? collectTextSegments(state.doc, from$1, to) : null;
   const target = segments && segments.length > 0 ? buildTextTarget(segments) : null;
   const activeMarks = collectActiveMarks(state, from$1, to);
   const { commentIds: activeCommentIds, changeIds: activeChangeRawIds } = collectActiveEntityIds(state, from$1, to);
@@ -234154,6 +234265,15 @@ function buildTextTarget(segments) {
     segments
   };
 }
+function shouldProjectTextTarget(selection) {
+  if (!selection || typeof selection !== "object")
+    return false;
+  if (selection instanceof NodeSelection)
+    return false;
+  if ("$anchorCell" in selection)
+    return false;
+  return true;
+}
 function collectTextSegments(doc$12, from$1, to) {
   const segments = [];
   let abort = false;
@@ -234506,29 +234626,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 = {
@@ -234540,7 +234643,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";
@@ -234548,23 +234651,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;
@@ -234579,6 +234682,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) };
@@ -234641,6 +234833,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 ?? {} };
@@ -235518,8 +235734,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;
@@ -235533,29 +235754,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);
@@ -235579,7 +235802,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;
@@ -235595,6 +235821,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++) {
@@ -235617,29 +235849,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);
@@ -236223,6 +236452,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);
@@ -250754,7 +250987,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),
@@ -250848,7 +251081,7 @@ function normalizeColorValue2(value) {
     return;
   return trimmed;
 }
-function normalizeFontSize$1(value) {
+function normalizeFontSize$2(value) {
   if (value == null)
     return null;
   if (typeof value === "number")
@@ -252450,11 +252683,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;
@@ -254417,23 +254654,37 @@ function applyTableIndent(x, width, indent2, columnWidth) {
       x: shiftedX,
       width: Math.max(0, width - indent2)
     };
+  if (width > columnWidth)
+    return {
+      x: shiftedX,
+      width
+    };
   const maxWidthWithinColumn = Math.max(0, columnWidth - indent2);
   return {
     x: shiftedX,
     width: Math.min(width, maxWidthWithinColumn)
   };
 }
+function resolveRenderedTableWidth(columnWidth, measuredWidth, attrs) {
+  const safeMeasuredWidth = Number.isFinite(measuredWidth) && measuredWidth > 0 ? measuredWidth : Math.max(0, columnWidth);
+  const configuredWidth = resolveTableWidthAttr(attrs?.tableWidth);
+  if (!configuredWidth)
+    return safeMeasuredWidth;
+  if (configuredWidth.type === "pct")
+    return Math.max(0, Math.round(columnWidth * (configuredWidth.width / OOXML_PCT_DIVISOR)));
+  return safeMeasuredWidth;
+}
 function resolveTableFrame(baseX, columnWidth, tableWidth, attrs) {
-  const width = Math.min(columnWidth, tableWidth);
+  const width = resolveRenderedTableWidth(columnWidth, tableWidth, attrs);
   const justification = typeof attrs?.justification === "string" ? attrs.justification : undefined;
   if (justification === "center")
     return {
-      x: baseX + Math.max(0, (columnWidth - width) / 2),
+      x: baseX + (columnWidth - width) / 2,
       width
     };
   if (justification === "right" || justification === "end")
     return {
-      x: baseX + Math.max(0, columnWidth - width),
+      x: baseX + (columnWidth - width),
       width
     };
   return applyTableIndent(baseX, width, getTableIndentWidth(attrs), columnWidth);
@@ -254863,13 +255114,14 @@ function layoutMonolithicTable(context) {
   state = context.ensurePage();
   const height = Math.min(context.measure.totalHeight, state.contentBottom - state.cursorY);
   const baseX = context.columnX(state.columnIndex);
-  const baseWidth = Math.min(context.columnWidth, context.measure.totalWidth || context.columnWidth);
+  const baseWidth = Math.max(0, context.measure.totalWidth || context.columnWidth);
   const { x, width } = resolveTableFrame(baseX, context.columnWidth, baseWidth, context.block.attrs);
   const columnWidths = rescaleColumnWidths(context.measure.columnWidths, context.measure.totalWidth, width);
   const metadata = generateFragmentMetadata(context.measure, context.block, 0, context.block.rows.length, 0, columnWidths);
   const fragment2 = {
     kind: "table",
     blockId: context.block.id,
+    columnIndex: state.columnIndex,
     fromRow: 0,
     toRow: context.block.rows.length,
     x,
@@ -254941,12 +255193,13 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
   let pendingPartialRow = null;
   if (block.rows.length === 0 && measure.totalHeight > 0) {
     const height = Math.min(measure.totalHeight, state.contentBottom - state.cursorY);
-    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
+    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
     const columnWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width);
     const metadata = generateFragmentMetadata(measure, block, 0, 0, 0, columnWidths);
     const fragment2 = {
       kind: "table",
       blockId: block.id,
+      columnIndex: state.columnIndex,
       fromRow: 0,
       toRow: 0,
       x,
@@ -255011,11 +255264,12 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       });
       const fragmentHeight$1 = computeFragmentHeight$1(measure, rowIndex, rowIndex + 1, repeatHeaderCount, borderCollapse, continuationPartialRow);
       if (fragmentHeight$1 > 0 && madeProgress) {
-        const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
+        const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
         const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
         const fragment$1 = {
           kind: "table",
           blockId: block.id,
+          columnIndex: state.columnIndex,
           fromRow: rowIndex,
           toRow: rowIndex + 1,
           x: x$1,
@@ -255067,11 +255321,12 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       }
       const forcedEndRow = bodyStartRow + 1;
       const fragmentHeight$1 = computeFragmentHeight$1(measure, bodyStartRow, forcedEndRow, repeatHeaderCount, borderCollapse, forcedPartialRow);
-      const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
+      const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
       const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
       const fragment$1 = {
         kind: "table",
         blockId: block.id,
+        columnIndex: state.columnIndex,
         fromRow: bodyStartRow,
         toRow: forcedEndRow,
         x: x$1,
@@ -255096,11 +255351,12 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       continue;
     }
     const fragmentHeight = computeFragmentHeight$1(measure, bodyStartRow, endRow, repeatHeaderCount, borderCollapse, partialRow);
-    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
+    const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.max(0, measure.totalWidth || columnWidth), block.attrs);
     const scaledWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width);
     const fragment2 = {
       kind: "table",
       blockId: block.id,
+      columnIndex: state.columnIndex,
       fromRow: bodyStartRow,
       toRow: endRow,
       x,
@@ -257354,7 +257610,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);
@@ -257403,7 +257659,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);
@@ -257496,7 +257752,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);
@@ -258139,7 +258395,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));
@@ -259196,32 +259452,12 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
                     return;
                   if (!block || block.kind !== "table")
                     return;
-                  const tableWidthRaw = Math.max(0, measure.totalWidth ?? 0);
-                  let tableWidth = Math.min(contentWidth, tableWidthRaw);
-                  let tableX = columnX;
-                  const justification = typeof block.attrs?.justification === "string" ? block.attrs.justification : undefined;
-                  if (justification === "center")
-                    tableX = columnX + Math.max(0, (contentWidth - tableWidth) / 2);
-                  else if (justification === "right" || justification === "end")
-                    tableX = columnX + Math.max(0, contentWidth - tableWidth);
-                  else {
-                    const indentValue = block.attrs?.tableIndent?.width;
-                    const indent2 = typeof indentValue === "number" && Number.isFinite(indentValue) ? indentValue : 0;
-                    tableX += indent2;
-                    tableWidth = Math.max(0, tableWidth - indent2);
-                  }
-                  let fragmentColumnWidths;
-                  if (tableWidthRaw > tableWidth && measure.columnWidths && measure.columnWidths.length > 0 && tableWidthRaw > 0) {
-                    const scale = tableWidth / tableWidthRaw;
-                    fragmentColumnWidths = measure.columnWidths.map((w) => Math.max(1, Math.round(w * scale)));
-                    const scaledSum = fragmentColumnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-                    const target = Math.round(tableWidth);
-                    if (scaledSum !== target && fragmentColumnWidths.length > 0)
-                      fragmentColumnWidths[fragmentColumnWidths.length - 1] = Math.max(1, fragmentColumnWidths[fragmentColumnWidths.length - 1] + (target - scaledSum));
-                  }
+                  const { x: tableX, width: tableWidth } = resolveTableFrame(columnX, contentWidth, Math.max(0, measure.totalWidth ?? contentWidth), block.attrs);
+                  const fragmentColumnWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, tableWidth);
                   page.fragments.push({
                     kind: "table",
                     blockId: range.blockId,
+                    columnIndex,
                     fromRow: 0,
                     toRow: block.rows.length,
                     x: tableX,
@@ -259964,7 +260200,7 @@ function clickToPositionGeometry(layout, blocks2, measures, containerPoint, opti
           layoutEpoch,
           blockId: tableHit.fragment.blockId,
           pageIndex,
-          column: determineColumn(layout, tableHit.fragment.x),
+          column: determineTableColumn(layout, tableHit.fragment),
           lineIndex
         };
     }
@@ -259975,7 +260211,7 @@ function clickToPositionGeometry(layout, blocks2, measures, containerPoint, opti
         layoutEpoch,
         blockId: tableHit.fragment.blockId,
         pageIndex,
-        column: determineColumn(layout, tableHit.fragment.x),
+        column: determineTableColumn(layout, tableHit.fragment),
         lineIndex: 0
       };
   }
@@ -261426,7 +261662,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);
@@ -261509,17 +261745,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;
   }
@@ -264790,6 +265026,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;
@@ -266280,161 +267879,9 @@ async function measureParagraphBlock(block, maxWidth) {
     ...dropCapMeasure ? { dropCap: dropCapMeasure } : {}
   };
 }
-function validateTableWidthValue(attr) {
-  const value = attr.width ?? attr.value;
-  if (typeof value === "number" && Number.isFinite(value) && value > 0)
-    return value;
-}
-function resolveTableWidth(attrs, maxWidth) {
-  const tableWidthAttr = attrs?.tableWidth;
-  if (!tableWidthAttr || typeof tableWidthAttr !== "object")
-    return;
-  const typedAttr = tableWidthAttr;
-  const validValue = validateTableWidthValue(typedAttr);
-  if (validValue === undefined)
-    return;
-  if (typedAttr.type === "pct")
-    return Math.round(maxWidth * (validValue / OOXML_PCT_DIVISOR));
-  else if (typedAttr.type === "px" || typedAttr.type === "pixel" || typedAttr.type === "dxa")
-    return validValue;
-}
 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 ? Math.min(resolvedTableWidth, maxWidth) : 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;
-      if ((totalWidth$1 > effectiveTargetWidth || totalWidth$1 < effectiveTargetWidth && effectiveTargetWidth > 0 && (tableWidthType === "pct" || hasExplicitWidth && !hasFixedLayout)) && effectiveTargetWidth > 0 && totalWidth$1 > 0) {
-        const scale = effectiveTargetWidth / 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 !== effectiveTargetWidth && columnWidths.length > 0) {
-          const diff = effectiveTargetWidth - 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);
-      const totalWidth$1 = columnWidths.reduce((a2, b$1) => a2 + b$1, 0);
-      if (totalWidth$1 > effectiveTargetWidth && effectiveTargetWidth > 0) {
-        const scale = effectiveTargetWidth / 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 !== effectiveTargetWidth && columnWidths.length > 0) {
-          const diff = effectiveTargetWidth - scaledSum;
-          columnWidths[columnWidths.length - 1] = Math.max(1, columnWidths[columnWidths.length - 1] + diff);
-        }
-      }
-    }
-  } 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;
@@ -266448,11 +267895,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++;
@@ -266555,18 +268010,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;
@@ -267419,7 +268904,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";
@@ -277246,7 +278731,7 @@ var Node$13 = class Node$14 {
     this.deco = deco;
   }
 }, searchKey, BLOCK_SEPARATOR = `
-`, ATOM_PLACEHOLDER = "", SearchIndex, customSearchHighlightsKey, isRegExp2 = (value) => Object.prototype.toString.call(value) === "[object RegExp]", SEARCH_POSITION_TRACKER_TYPE = "search-match", mapIndexMatchesToDocMatches = ({ searchIndex, indexMatches, doc: doc$12, positionTracker }) => {
+`, ATOM_PLACEHOLDER = "", DELETION_BARRIER = "\x00", DEFAULT_SEARCH_MODEL$1 = "raw", hasTrackDeleteMark$1 = (node3) => node3?.marks?.some((mark2) => mark2?.type?.name === "trackDelete") ?? false, SearchIndex, customSearchHighlightsKey, isRegExp2 = (value) => Object.prototype.toString.call(value) === "[object RegExp]", SEARCH_POSITION_TRACKER_TYPE = "search-match", DEFAULT_SEARCH_MODEL = "raw", normalizeSearchModel = (value) => value === "visible" ? "visible" : DEFAULT_SEARCH_MODEL, mapIndexMatchesToDocMatches = ({ searchIndex, indexMatches, doc: doc$12, positionTracker }) => {
   const matches2 = [];
   for (const indexMatch of indexMatches) {
     const ranges = searchIndex.offsetRangeToDocRanges(indexMatch.start, indexMatch.end);
@@ -278583,7 +280068,7 @@ var Node$13 = class Node$14 {
   });
   const renderSearchDropdown = () => {
     const handleSubmit = ({ value }) => {
-      superToolbar.activeEditor.commands.search(value);
+      superToolbar.activeEditor.commands.search(value, { searchModel: "visible" });
     };
     return exports_vue.h("div", {}, [exports_vue.h(SearchInput_default, {
       onSubmit: handleSubmit,
@@ -286990,9 +288475,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) {
@@ -287019,8 +288512,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)
@@ -287118,7 +288621,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;
@@ -287386,6 +288923,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,
@@ -287736,7 +289275,7 @@ menclose::after {
       return true;
   }
   return false;
-}, capitalizeText$2 = (text5) => {
+}, capitalizeText$3 = (text5) => {
   if (!text5)
     return text5;
   let result = "";
@@ -287746,7 +289285,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")
@@ -287754,7 +289293,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;
@@ -288542,7 +290081,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;
@@ -288553,7 +290092,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")
@@ -288561,9 +290100,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) => {
@@ -289342,7 +290881,9 @@ menclose::after {
     let columnIndex = 0;
     if (columns && columns.count > 1 && page) {
       const fragment2 = findFragmentForPos(page, ref$1.pos);
-      if (fragment2 && typeof fragment2.x === "number") {
+      if (fragment2?.kind === "table" && typeof fragment2.columnIndex === "number")
+        columnIndex = Math.max(0, Math.min(columns.count - 1, fragment2.columnIndex));
+      else if (fragment2 && typeof fragment2.x === "number") {
         const widths = Array.isArray(columns.widths) && columns.widths.length > 0 ? columns.widths : undefined;
         if (widths) {
           let cursorX = columns.left;
@@ -289944,6 +291485,12 @@ menclose::after {
   const relative = fragmentX;
   const raw = Math.floor(relative / Math.max(span, 1));
   return Math.max(0, Math.min(columns.count - 1, raw));
+}, determineTableColumn = (layout, fragment2) => {
+  if (typeof fragment2.columnIndex === "number") {
+    const count2 = layout.columns?.count ?? 1;
+    return Math.max(0, Math.min(Math.max(0, count2 - 1), fragment2.columnIndex));
+  }
+  return determineColumn(layout, fragment2.x);
 }, findLineIndexAtY = (lines, offsetY, fromLine, toLine) => {
   if (!lines || lines.length === 0)
     return null;
@@ -290163,13 +291710,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)
@@ -294649,7 +296196,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") {
@@ -296480,12 +298061,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_CCV76OsP_es = __esm(() => {
+var init_src_Dinif16O_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();
@@ -296511,6 +298092,7 @@ var init_src_CCV76OsP_es = __esm(() => {
     measureRowHeights: () => measureRowHeights,
     resolveColumnWidths: () => resolveColumnWidths,
     resolveSpacingIndent: () => resolveSpacingIndent,
+    resolveTableWidthAttr: () => resolveTableWidthAttr,
     scaleWrapPolygon: () => scaleWrapPolygon
   }, 1);
   floor4 = Math.floor;
@@ -313863,19 +315445,69 @@ function print() { __p += __j.call(arguments, '') }
     valid = false;
     docSize = 0;
     doc = null;
-    build(doc$12) {
-      this.text = doc$12.textBetween(0, doc$12.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
+    searchModel = DEFAULT_SEARCH_MODEL$1;
+    build(doc$12, options = {}) {
+      const searchModel = options?.searchModel === "visible" ? "visible" : DEFAULT_SEARCH_MODEL$1;
+      if (searchModel === "visible")
+        this.#buildVisible(doc$12);
+      else
+        this.text = doc$12.textBetween(0, doc$12.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
       this.segments = [];
       this.docSize = doc$12.content.size;
       this.doc = doc$12;
+      this.searchModel = searchModel;
       let offset$1 = 0;
+      const visibleContext = searchModel === "visible" ? { deletionBarrierActive: false } : null;
       this.#walkNodeContent(doc$12, 0, offset$1, (segment) => {
         this.segments.push(segment);
         offset$1 = segment.offsetEnd;
-      });
+      }, searchModel, visibleContext);
       this.valid = true;
     }
-    #walkNodeContent(node3, contentStart, offset$1, addSegment) {
+    #buildVisible(doc$12) {
+      const parts = [];
+      let emittedDeletionBarrier = false;
+      const appendDeletionBarrier = () => {
+        if (emittedDeletionBarrier)
+          return;
+        parts.push(DELETION_BARRIER);
+        emittedDeletionBarrier = true;
+      };
+      const walkNodeContent2 = (node3) => {
+        let isFirstChild = true;
+        node3.forEach((child) => {
+          if (child.isBlock && !isFirstChild) {
+            parts.push(BLOCK_SEPARATOR);
+            emittedDeletionBarrier = false;
+          }
+          walkNode2(child);
+          isFirstChild = false;
+        });
+      };
+      const walkNode2 = (node3) => {
+        if (node3.isText) {
+          const text5 = node3.text || "";
+          if (!text5.length)
+            return;
+          if (hasTrackDeleteMark$1(node3)) {
+            appendDeletionBarrier();
+            return;
+          }
+          parts.push(text5);
+          emittedDeletionBarrier = false;
+          return;
+        }
+        if (node3.isLeaf) {
+          parts.push(ATOM_PLACEHOLDER);
+          emittedDeletionBarrier = false;
+          return;
+        }
+        walkNodeContent2(node3);
+      };
+      walkNodeContent2(doc$12);
+      this.text = parts.join("");
+    }
+    #walkNodeContent(node3, contentStart, offset$1, addSegment, searchModel = DEFAULT_SEARCH_MODEL$1, context = null) {
       let currentOffset = offset$1;
       let isFirstChild = true;
       node3.forEach((child, childContentOffset) => {
@@ -313889,16 +315521,34 @@ function print() { __p += __j.call(arguments, '') }
             kind: "blockSep"
           });
           currentOffset += 1;
+          if (context && searchModel === "visible")
+            context.deletionBarrierActive = false;
         }
-        currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment);
+        currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment, searchModel, context);
         isFirstChild = false;
       });
       return currentOffset;
     }
-    #walkNode(node3, docPos, offset$1, addSegment) {
+    #walkNode(node3, docPos, offset$1, addSegment, searchModel = DEFAULT_SEARCH_MODEL$1, context = null) {
       if (node3.isText) {
+        if (searchModel === "visible" && hasTrackDeleteMark$1(node3)) {
+          if (context?.deletionBarrierActive)
+            return offset$1;
+          addSegment({
+            offsetStart: offset$1,
+            offsetEnd: offset$1 + 1,
+            docFrom: docPos,
+            docTo: docPos,
+            kind: "atom"
+          });
+          if (context)
+            context.deletionBarrierActive = true;
+          return offset$1 + 1;
+        }
         const text5 = node3.text || "";
         if (text5.length > 0) {
+          if (context && searchModel === "visible")
+            context.deletionBarrierActive = false;
           addSegment({
             offsetStart: offset$1,
             offsetEnd: offset$1 + text5.length,
@@ -313911,6 +315561,8 @@ function print() { __p += __j.call(arguments, '') }
         return offset$1;
       }
       if (node3.isLeaf) {
+        if (context && searchModel === "visible")
+          context.deletionBarrierActive = false;
         if (node3.type.name === "hard_break") {
           addSegment({
             offsetStart: offset$1,
@@ -313930,17 +315582,18 @@ function print() { __p += __j.call(arguments, '') }
         });
         return offset$1 + 1;
       }
-      return this.#walkNodeContent(node3, docPos + 1, offset$1, addSegment);
+      return this.#walkNodeContent(node3, docPos + 1, offset$1, addSegment, searchModel, context);
     }
     invalidate() {
       this.valid = false;
     }
-    isStale(doc$12) {
-      return !this.valid || this.doc !== doc$12;
+    isStale(doc$12, options = {}) {
+      const searchModel = options?.searchModel === "visible" ? "visible" : DEFAULT_SEARCH_MODEL$1;
+      return !this.valid || this.doc !== doc$12 || this.searchModel !== searchModel;
     }
-    ensureValid(doc$12) {
-      if (this.isStale(doc$12))
-        this.build(doc$12);
+    ensureValid(doc$12, options = {}) {
+      if (this.isStale(doc$12, options))
+        this.build(doc$12, options);
     }
     offsetRangeToDocRanges(start$1, end$1) {
       const ranges = [];
@@ -314090,7 +315743,8 @@ function print() { __p += __j.call(arguments, '') }
         activeMatchIndex: -1,
         query: "",
         caseSensitive: false,
-        ignoreDiacritics: false
+        ignoreDiacritics: false,
+        searchModel: DEFAULT_SEARCH_MODEL
       };
     },
     addPmPlugins() {
@@ -314104,8 +315758,11 @@ function print() { __p += __j.call(arguments, '') }
           if (storage?.searchIndex)
             storage.searchIndex.invalidate();
           if (storage?.query) {
-            storage.searchIndex.ensureValid(newState.doc);
-            const indexMatches = (storage.ignoreDiacritics ? (q$1, opts) => storage.searchIndex.searchIgnoringDiacritics(q$1, opts) : (q$1, opts) => storage.searchIndex.search(q$1, opts))(storage.query, { caseSensitive: storage.caseSensitive });
+            storage.searchIndex.ensureValid(newState.doc, { searchModel: storage.searchModel ?? DEFAULT_SEARCH_MODEL });
+            const indexMatches = (storage.ignoreDiacritics ? (q$1, opts) => storage.searchIndex.searchIgnoringDiacritics(q$1, opts) : (q$1, opts) => storage.searchIndex.search(q$1, opts))(storage.query, {
+              caseSensitive: storage.caseSensitive,
+              searchModel: storage.searchModel ?? DEFAULT_SEARCH_MODEL
+            });
             const refreshed = mapIndexMatchesToDocMatches({
               searchIndex: storage.searchIndex,
               indexMatches,
@@ -314203,11 +315860,12 @@ function print() { __p += __j.call(arguments, '') }
           } catch {}
           return true;
         },
-        search: (patternInput, options = {}) => ({ state, dispatch, editor }) => {
+        search: (patternInput, options = {}) => ({ state, editor }) => {
           if (options != null && (typeof options !== "object" || Array.isArray(options)))
             throw new TypeError("Search options must be an object");
           const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
           const maxMatches = typeof options?.maxMatches === "number" ? options.maxMatches : 1000;
+          const searchModel = normalizeSearchModel(options?.searchModel);
           let caseSensitive = false;
           let searchPattern = patternInput;
           if (isRegExp2(patternInput)) {
@@ -314224,12 +315882,14 @@ function print() { __p += __j.call(arguments, '') }
           const positionTracker = getPositionTracker(editor);
           positionTracker?.untrackByType?.(SEARCH_POSITION_TRACKER_TYPE);
           const searchIndex = this.storage.searchIndex;
-          searchIndex.ensureValid(state.doc);
+          searchIndex.ensureValid(state.doc, { searchModel });
+          this.storage.searchModel = searchModel;
           const resultMatches = mapIndexMatchesToDocMatches({
             searchIndex,
             indexMatches: searchIndex.search(searchPattern, {
               caseSensitive,
-              maxMatches
+              maxMatches,
+              searchModel
             }),
             doc: state.doc,
             positionTracker
@@ -314274,9 +315934,11 @@ function print() { __p += __j.call(arguments, '') }
           const caseSensitive = options.caseSensitive ?? false;
           const ignoreDiacritics = options.ignoreDiacritics ?? false;
           const highlight = options.highlight ?? true;
+          const searchModel = normalizeSearchModel(options.searchModel);
           this.storage.query = query2;
           this.storage.caseSensitive = caseSensitive;
           this.storage.ignoreDiacritics = ignoreDiacritics;
+          this.storage.searchModel = searchModel;
           const positionTracker = getPositionTracker(editor);
           positionTracker?.untrackByType?.(SEARCH_POSITION_TRACKER_TYPE);
           if (!query2) {
@@ -314289,10 +315951,16 @@ function print() { __p += __j.call(arguments, '') }
             };
           }
           const searchIndex = this.storage.searchIndex;
-          searchIndex.ensureValid(state.doc);
+          searchIndex.ensureValid(state.doc, { searchModel });
           const resultMatches = mapIndexMatchesToDocMatches({
             searchIndex,
-            indexMatches: ignoreDiacritics ? searchIndex.searchIgnoringDiacritics(query2, { caseSensitive }) : searchIndex.search(query2, { caseSensitive }),
+            indexMatches: ignoreDiacritics ? searchIndex.searchIgnoringDiacritics(query2, {
+              caseSensitive,
+              searchModel
+            }) : searchIndex.search(query2, {
+              caseSensitive,
+              searchModel
+            }),
             doc: state.doc,
             positionTracker
           });
@@ -314312,9 +315980,10 @@ function print() { __p += __j.call(arguments, '') }
           this.storage.query = "";
           this.storage.caseSensitive = false;
           this.storage.ignoreDiacritics = false;
+          this.storage.searchModel = DEFAULT_SEARCH_MODEL;
           return true;
         },
-        nextSearchMatch: () => ({ state, editor }) => {
+        nextSearchMatch: () => ({ editor }) => {
           const matches2 = this.storage.searchResults;
           if (!matches2 || matches2.length === 0)
             return {
@@ -314330,7 +315999,7 @@ function print() { __p += __j.call(arguments, '') }
             match: match$1
           };
         },
-        previousSearchMatch: () => ({ state, editor }) => {
+        previousSearchMatch: () => ({ editor }) => {
           const matches2 = this.storage.searchResults;
           if (!matches2 || matches2.length === 0)
             return {
@@ -314346,7 +316015,7 @@ function print() { __p += __j.call(arguments, '') }
             match: match$1
           };
         },
-        replaceSearchMatch: (replacement) => ({ state, dispatch, editor, commands: commands$1 }) => {
+        replaceSearchMatch: (replacement) => ({ state, dispatch, commands: commands$1 }) => {
           const matches2 = this.storage.searchResults;
           const activeIdx = this.storage.activeMatchIndex;
           if (!matches2 || activeIdx < 0 || activeIdx >= matches2.length)
@@ -314368,7 +316037,8 @@ function print() { __p += __j.call(arguments, '') }
           const result = commands$1.setSearchSession(this.storage.query, {
             caseSensitive: this.storage.caseSensitive,
             ignoreDiacritics: this.storage.ignoreDiacritics,
-            highlight: this.storage.highlightEnabled
+            highlight: this.storage.highlightEnabled,
+            searchModel: this.storage.searchModel
           });
           if (result.matches.length > 0) {
             const newIdx = Math.min(activeIdx, result.matches.length - 1);
@@ -323099,7 +324769,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;
@@ -323128,7 +324798,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,
@@ -327735,6 +329405,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",
@@ -333607,11 +335287,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([]);
 });
@@ -333629,16 +335309,16 @@ var init_zipper_BxRAi0_5_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_CCV76OsP_es();
-  init_SuperConverter_BTy5lByv_es();
+  init_src_Dinif16O_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();