@harbour-enterprises/superdoc 0.24.0-next.4 → 0.24.0-next.6

package/dist/chunks/{super-editor.es-CBPoWvjs.es.js → super-editor.es-Dz7y81Yr.es.js}

@@ -15076,6 +15076,7 @@ async function readFromClipboard(state2) {
   }
   return content;
 }
+const PIXELS_PER_INCH = 96;
 function inchesToTwips(inches) {
   if (inches == null) return;
   if (typeof inches === "string") inches = parseFloat(inches);
@@ -15098,12 +15099,12 @@ function pixelsToTwips(pixels) {
 }
 function inchesToPixels(inches) {
   if (inches == null) return;
-  const pixels = inches * 96;
+  const pixels = inches * PIXELS_PER_INCH;
   return Math.round(pixels * 1e3) / 1e3;
 }
 function pixelsToInches(pixels) {
   if (pixels == null) return;
-  const inches = Number(pixels) / 96;
+  const inches = Number(pixels) / PIXELS_PER_INCH;
   return inches;
 }
 function twipsToLines(twips) {
@@ -15121,7 +15122,7 @@ function halfPointToPoints(halfPoints) {
 function emuToPixels(emu) {
   if (emu == null) return;
   if (typeof emu === "string") emu = parseFloat(emu);
-  const pixels = emu * 96 / 914400;
+  const pixels = emu * PIXELS_PER_INCH / 914400;
   return Math.round(pixels);
 }
 function pixelsToEmu(px) {
@@ -15157,12 +15158,12 @@ function degreesToRot(degrees) {
 }
 function pixelsToPolygonUnits(pixels) {
   if (pixels == null) return;
-  const pu = pixels * 96;
+  const pu = pixels * PIXELS_PER_INCH;
   return Math.round(pu);
 }
 function polygonUnitsToPixels(pu) {
   if (pu == null) return;
-  const pixels = Number(pu) / 96;
+  const pixels = Number(pu) / PIXELS_PER_INCH;
   return Math.round(pixels * 1e3) / 1e3;
 }
 function polygonToObj(polygonNode) {
@@ -27038,6 +27039,68 @@ const translator$_ = NodeTranslator.from(
     repeatHeader: false
   })
 );
+const createPlaceholderCell = (gridWidth, reason) => {
+  const safeWidth = Number.isFinite(gridWidth) ? gridWidth : 0;
+  const noBorder = { val: "none", size: 0 };
+  return {
+    type: "tableCell",
+    attrs: {
+      colspan: 1,
+      rowspan: 1,
+      colwidth: [safeWidth],
+      __placeholder: reason,
+      borders: {
+        top: { ...noBorder },
+        right: { ...noBorder },
+        bottom: { ...noBorder },
+        left: { ...noBorder }
+      }
+    },
+    content: [{ type: "paragraph", content: [] }]
+  };
+};
+const advancePastRowSpans = (pendingRowSpans, startIndex, totalColumns) => {
+  let index2 = startIndex;
+  while (index2 < totalColumns && pendingRowSpans[index2] > 0) {
+    pendingRowSpans[index2] -= 1;
+    index2 += 1;
+  }
+  return index2;
+};
+const fillPlaceholderColumns = ({
+  content,
+  pendingRowSpans,
+  currentIndex,
+  targetIndex,
+  totalColumns,
+  gridColumnWidths,
+  reason
+}) => {
+  let index2 = currentIndex;
+  while (index2 < targetIndex && index2 < totalColumns) {
+    if (pendingRowSpans[index2] > 0) {
+      pendingRowSpans[index2] -= 1;
+      index2 += 1;
+      continue;
+    }
+    const width = Array.isArray(gridColumnWidths) ? gridColumnWidths[index2] ?? 0 : 0;
+    content.push(createPlaceholderCell(width, reason));
+    index2 += 1;
+  }
+  return index2;
+};
+const isPlaceholderCell = (cell) => {
+  if (!cell) return false;
+  if (cell.attrs?.__placeholder) return true;
+  const widths = cell.attrs?.colwidth;
+  if (Array.isArray(widths) && widths.length > 0) {
+    const hasMeaningfulWidth = widths.some(
+      (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) > 1
+    );
+    if (!hasMeaningfulWidth) return true;
+  }
+  return false;
+};
 const XML_NODE_NAME$h = "w:tr";
 const SD_NODE_NAME$d = "tableRow";
 const validXmlAttributes$b = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
@@ -27053,29 +27116,64 @@ const encode$n = (params2, encodedAttrs) => {
       nodes: [tPr]
     });
   }
+  const gridBeforeRaw = tableRowProperties?.["gridBefore"];
+  const safeGridBefore = typeof gridBeforeRaw === "number" && Number.isFinite(gridBeforeRaw) && gridBeforeRaw > 0 ? gridBeforeRaw : 0;
   encodedAttrs["tableRowProperties"] = Object.freeze(tableRowProperties);
   encodedAttrs["rowHeight"] = twipsToPixels(tableRowProperties["rowHeight"]?.value);
   encodedAttrs["cantSplit"] = tableRowProperties["cantSplit"];
-  const { columnWidths: gridColumnWidths } = params2.extraParams;
+  const { columnWidths: gridColumnWidths, activeRowSpans = [] } = params2.extraParams;
+  const totalColumns = Array.isArray(gridColumnWidths) ? gridColumnWidths.length : 0;
+  const pendingRowSpans = Array.isArray(activeRowSpans) ? activeRowSpans.slice() : [];
+  while (pendingRowSpans.length < totalColumns) pendingRowSpans.push(0);
   const cellNodes = row.elements.filter((el) => el.name === "w:tc");
+  const content = [];
   let currentColumnIndex = 0;
-  const content = cellNodes?.map((n) => {
-    let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
+  const fillUntil = (target, reason) => {
+    currentColumnIndex = fillPlaceholderColumns({
+      content,
+      pendingRowSpans,
+      currentIndex: currentColumnIndex,
+      targetIndex: target,
+      totalColumns,
+      gridColumnWidths,
+      reason
+    });
+  };
+  const skipOccupiedColumns = () => {
+    currentColumnIndex = advancePastRowSpans(pendingRowSpans, currentColumnIndex, totalColumns);
+  };
+  fillUntil(safeGridBefore, "gridBefore");
+  skipOccupiedColumns();
+  cellNodes?.forEach((node) => {
+    skipOccupiedColumns();
+    const startColumn = currentColumnIndex;
+    const columnWidth = gridColumnWidths?.[startColumn] || null;
     const result = translator$c.encode({
       ...params2,
       extraParams: {
         ...params2.extraParams,
-        node: n,
-        columnIndex: currentColumnIndex,
+        node,
+        columnIndex: startColumn,
         columnWidth
       }
     });
-    const tcPr = n.elements?.find((el) => el.name === "w:tcPr");
-    const colspanTag = tcPr?.elements?.find((el) => el.name === "w:gridSpan");
-    const colspan = parseInt(colspanTag?.attributes["w:val"] || 1, 10);
-    currentColumnIndex += colspan;
-    return result;
-  }) || [];
+    if (result) {
+      content.push(result);
+      const colspan = Math.max(1, result.attrs?.colspan || 1);
+      const rowspan = Math.max(1, result.attrs?.rowspan || 1);
+      if (rowspan > 1) {
+        for (let offset2 = 0; offset2 < colspan; offset2 += 1) {
+          const target = startColumn + offset2;
+          if (target < pendingRowSpans.length) {
+            pendingRowSpans[target] = Math.max(pendingRowSpans[target], rowspan - 1);
+          }
+        }
+      }
+      currentColumnIndex = startColumn + colspan;
+    }
+  });
+  skipOccupiedColumns();
+  fillUntil(totalColumns, "gridAfter");
   const newNode = {
     type: "tableRow",
     content,
@@ -27085,9 +27183,37 @@ const encode$n = (params2, encodedAttrs) => {
 };
 const decode$p = (params2, decodedAttrs) => {
   const { node } = params2;
-  const elements = translateChildNodes(params2);
+  const cells = node.content || [];
+  let leadingPlaceholders = 0;
+  while (leadingPlaceholders < cells.length && isPlaceholderCell(cells[leadingPlaceholders])) {
+    leadingPlaceholders += 1;
+  }
+  let trailingPlaceholders = 0;
+  while (trailingPlaceholders < cells.length - leadingPlaceholders && isPlaceholderCell(cells[cells.length - 1 - trailingPlaceholders])) {
+    trailingPlaceholders += 1;
+  }
+  const trimmedSlice = cells.slice(leadingPlaceholders, cells.length - trailingPlaceholders);
+  const sanitizedCells = trimmedSlice.map((cell) => {
+    if (cell?.attrs && "__placeholder" in cell.attrs) {
+      const { __placeholder, ...rest } = cell.attrs;
+      return { ...cell, attrs: rest };
+    }
+    return cell;
+  });
+  const trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+  const translateParams = {
+    ...params2,
+    node: { ...node, content: trimmedContent }
+  };
+  const elements = translateChildNodes(translateParams);
   if (node.attrs?.tableRowProperties) {
     const tableRowProperties = { ...node.attrs.tableRowProperties };
+    if (leadingPlaceholders > 0) {
+      tableRowProperties.gridBefore = leadingPlaceholders;
+    }
+    if (trailingPlaceholders > 0) {
+      tableRowProperties.gridAfter = trailingPlaceholders;
+    }
     if (node.attrs.rowHeight != null) {
       const rowHeightPixels = twipsToPixels(node.attrs.tableRowProperties["rowHeight"]?.value);
       if (rowHeightPixels !== node.attrs.rowHeight) {
@@ -27317,17 +27443,21 @@ const decode$o = (params2) => {
   const fallbackColumnWidthTwips = resolveFallbackColumnWidthTwips(params2, totalColumns, cellMinWidth);
   const elements = [];
   let columnIndex = 0;
-  const pushColumn = (widthTwips) => {
+  const pushColumn = (widthTwips, { enforceMinimum = false } = {}) => {
     let numericWidth = typeof widthTwips === "string" ? parseInt(widthTwips, 10) : widthTwips;
+    let shouldEnforceMinimum = enforceMinimum;
     if (numericWidth == null || Number.isNaN(numericWidth) || numericWidth <= 0) {
       numericWidth = fallbackColumnWidthTwips;
+      shouldEnforceMinimum = true;
     }
-    numericWidth = Math.max(numericWidth, cellMinWidth);
+    const roundedWidth = Math.round(numericWidth);
+    const minimumWidth = shouldEnforceMinimum ? cellMinWidth : 1;
+    const safeWidth = Math.max(roundedWidth, minimumWidth);
     const decoded = translator$u.decode({
       node: { type: (
         /** @type {string} */
         translator$u.sdNodeOrKeyName
-      ), attrs: { col: numericWidth } }
+      ), attrs: { col: safeWidth } }
     });
     if (decoded) elements.push(decoded);
   };
@@ -27335,13 +27465,17 @@ const decode$o = (params2) => {
     const { colspan = 1, colwidth } = cell?.attrs || {};
     const spanCount = Math.max(1, colspan);
     for (let span = 0; span < spanCount; span++) {
-      const cellWidthPixels = Array.isArray(colwidth) ? colwidth[span] : void 0;
+      const rawWidth = Array.isArray(colwidth) ? colwidth[span] : void 0;
+      const cellWidthPixels = typeof rawWidth === "number" && Number.isFinite(rawWidth) ? rawWidth : Number(rawWidth);
+      const hasCellWidth = Number.isFinite(cellWidthPixels) && cellWidthPixels > 0;
       const colGridAttrs = grid?.[columnIndex] || {};
       const gridWidthTwips = normalizeTwipWidth(colGridAttrs.col);
       const gridWidthPixels = gridWidthTwips != null ? twipsToPixels(gridWidthTwips) : null;
       let cellWidthTwips;
-      if (cellWidthPixels != null) {
-        if (gridWidthTwips != null && gridWidthPixels === cellWidthPixels) {
+      let enforceMinimum = false;
+      if (hasCellWidth) {
+        const tolerance = 0.5;
+        if (gridWidthTwips != null && gridWidthPixels != null && Math.abs(gridWidthPixels - cellWidthPixels) <= tolerance) {
           cellWidthTwips = gridWidthTwips;
         } else {
           cellWidthTwips = pixelsToTwips(cellWidthPixels);
@@ -27350,8 +27484,9 @@ const decode$o = (params2) => {
         cellWidthTwips = gridWidthTwips;
       } else {
         cellWidthTwips = fallbackColumnWidthTwips;
+        enforceMinimum = true;
       }
-      pushColumn(cellWidthTwips);
+      pushColumn(cellWidthTwips, { enforceMinimum });
       columnIndex++;
     }
   });
@@ -27514,7 +27649,9 @@ const encode$l = (params2, encodedAttrs) => {
     }
   }
   const content = [];
-  rows.forEach((row) => {
+  const totalColumns = columnWidths.length;
+  const activeRowSpans = totalColumns > 0 ? new Array(totalColumns).fill(0) : [];
+  rows.forEach((row, rowIndex) => {
     const result = translator$Z.encode({
       ...params2,
       nodes: [row],
@@ -27523,10 +27660,45 @@ const encode$l = (params2, encodedAttrs) => {
         table: node,
         rowBorders: borderRowData,
         styleTag: tblStyleTag,
-        columnWidths
+        columnWidths,
+        activeRowSpans: activeRowSpans.slice(),
+        rowIndex
       }
     });
-    if (result) content.push(result);
+    if (result) {
+      content.push(result);
+      if (totalColumns > 0) {
+        const activeRowSpansForCurrentRow = activeRowSpans.slice();
+        for (let col = 0; col < totalColumns; col++) {
+          if (activeRowSpans[col] > 0) {
+            activeRowSpans[col] -= 1;
+          }
+        }
+        let columnIndex = 0;
+        const advanceColumnIndex = () => {
+          while (columnIndex < totalColumns && activeRowSpansForCurrentRow[columnIndex] > 0) {
+            columnIndex += 1;
+          }
+        };
+        advanceColumnIndex();
+        result.content?.forEach((cell) => {
+          advanceColumnIndex();
+          const colspan = Math.max(1, cell.attrs?.colspan || 1);
+          const rowspan = Math.max(1, cell.attrs?.rowspan || 1);
+          if (rowspan > 1) {
+            for (let offset2 = 0; offset2 < colspan && columnIndex + offset2 < totalColumns; offset2++) {
+              const targetIndex = columnIndex + offset2;
+              const remainingRows = rowspan - 1;
+              if (remainingRows > 0 && remainingRows > activeRowSpans[targetIndex]) {
+                activeRowSpans[targetIndex] = remainingRows;
+              }
+            }
+          }
+          columnIndex += colspan;
+          advanceColumnIndex();
+        });
+      }
+    }
   });
   return {
     type: "table",
@@ -27931,14 +28103,104 @@ function handleTableCellNode({
   }
   return {
     type: "tableCell",
-    content: nodeListHandler.handler({
-      ...params2,
-      nodes: node.elements,
-      path: [...params2.path || [], node]
-    }),
+    content: normalizeTableCellContent(
+      nodeListHandler.handler({
+        ...params2,
+        nodes: node.elements,
+        path: [...params2.path || [], node]
+      }),
+      params2.editor
+    ),
     attrs: attributes
   };
 }
+function normalizeTableCellContent(content, editor) {
+  if (!Array.isArray(content) || content.length === 0) return content;
+  const normalized = [];
+  const pendingForNextBlock = [];
+  const schema = editor?.schema;
+  const cloneBlock = (node) => {
+    if (!node) return node;
+    const cloned = { ...node };
+    if (Array.isArray(node.content)) {
+      cloned.content = [...node.content];
+    }
+    return cloned;
+  };
+  const ensureArray = (node) => {
+    if (!Array.isArray(node.content)) {
+      node.content = [];
+    }
+    return node.content;
+  };
+  const isInlineNode = (node) => {
+    if (!node || typeof node.type !== "string") return false;
+    if (node.type === "text") return true;
+    if (node.type === "bookmarkStart" || node.type === "bookmarkEnd") return true;
+    const nodeType = schema?.nodes?.[node.type];
+    if (nodeType) {
+      if (typeof nodeType.isInline === "boolean") return nodeType.isInline;
+      if (nodeType.spec?.group && typeof nodeType.spec.group === "string") {
+        return nodeType.spec.group.split(" ").includes("inline");
+      }
+    }
+    return false;
+  };
+  for (const node of content) {
+    if (!node || typeof node.type !== "string") {
+      normalized.push(node);
+      continue;
+    }
+    if (!isInlineNode(node)) {
+      const blockNode = cloneBlock(node);
+      if (pendingForNextBlock.length) {
+        const blockContent = ensureArray(blockNode);
+        const leadingInline = pendingForNextBlock.splice(0);
+        blockNode.content = [...leadingInline, ...blockContent];
+      } else if (Array.isArray(blockNode.content)) {
+        blockNode.content = [...blockNode.content];
+      }
+      normalized.push(blockNode);
+      continue;
+    }
+    const targetIsNextBlock = node.type === "bookmarkStart" || normalized.length === 0;
+    if (targetIsNextBlock) {
+      pendingForNextBlock.push(node);
+    } else {
+      const lastIndex = normalized.length - 1;
+      const lastNode = normalized[lastIndex];
+      if (!lastNode || typeof lastNode.type !== "string" || isInlineNode(lastNode)) {
+        pendingForNextBlock.push(node);
+        continue;
+      }
+      const blockContent = ensureArray(lastNode);
+      if (pendingForNextBlock.length) {
+        blockContent.push(...pendingForNextBlock.splice(0));
+      }
+      blockContent.push(node);
+    }
+  }
+  if (pendingForNextBlock.length) {
+    if (normalized.length) {
+      const lastIndex = normalized.length - 1;
+      const lastNode = normalized[lastIndex];
+      if (lastNode && typeof lastNode.type === "string" && !isInlineNode(lastNode)) {
+        const blockContent = ensureArray(lastNode);
+        blockContent.push(...pendingForNextBlock);
+        pendingForNextBlock.length = 0;
+      }
+    }
+    if (pendingForNextBlock.length) {
+      normalized.push({
+        type: "paragraph",
+        attrs: {},
+        content: [...pendingForNextBlock]
+      });
+      pendingForNextBlock.length = 0;
+    }
+  }
+  return normalized;
+}
 const processInlineCellBorders = (borders, rowBorders) => {
   if (!borders) return null;
   return ["bottom", "top", "left", "right"].reduce((acc, direction) => {
@@ -28492,6 +28754,7 @@ function sdtNodeTypeStrategy(node) {
   }
   return { type: "unknown", handler: null };
 }
+const DRAWING_XML_TAG = "w:drawing";
 function handleImageNode(node, params2, isAnchor) {
   const { docx, filename } = params2;
   const { attributes } = node;
@@ -28503,32 +28766,10 @@ function handleImageNode(node, params2, isAnchor) {
   };
   const extent = node.elements.find((el) => el.name === "wp:extent");
   const size2 = {
-    width: emuToPixels(extent.attributes?.cx),
-    height: emuToPixels(extent.attributes?.cy)
+    width: emuToPixels(extent?.attributes?.cx),
+    height: emuToPixels(extent?.attributes?.cy)
   };
-  const graphic = node.elements.find((el) => el.name === "a:graphic");
-  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
-  const { uri: uri2 } = graphicData?.attributes || {};
-  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
-  if (!!uri2 && uri2 === shapeURI) {
-    return handleShapeDrawing(params2, node, graphicData);
-  }
-  const picture = graphicData.elements.find((el) => el.name === "pic:pic");
-  if (!picture || !picture.elements) return null;
-  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
-  const blip = blipFill.elements.find((el) => el.name === "a:blip");
-  const spPr = picture.elements.find((el) => el.name === "pic:spPr");
   let transformData = {};
-  if (spPr) {
-    const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
-    if (xfrm?.attributes) {
-      transformData = {
-        rotation: rotToDegrees(xfrm.attributes["rot"]),
-        verticalFlip: xfrm.attributes["flipV"] === "1",
-        horizontalFlip: xfrm.attributes["flipH"] === "1"
-      };
-    }
-  }
   const effectExtent = node.elements.find((el) => el.name === "wp:effectExtent");
   if (effectExtent) {
     const sanitizeEmuValue = (value) => {
@@ -28537,22 +28778,26 @@ function handleImageNode(node, params2, isAnchor) {
       return Number.isFinite(numeric) ? numeric : 0;
     };
     transformData.sizeExtension = {
-      left: emuToPixels(sanitizeEmuValue(effectExtent.attributes["l"])),
-      top: emuToPixels(sanitizeEmuValue(effectExtent.attributes["t"])),
-      right: emuToPixels(sanitizeEmuValue(effectExtent.attributes["r"])),
-      bottom: emuToPixels(sanitizeEmuValue(effectExtent.attributes["b"]))
+      left: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["l"])),
+      top: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["t"])),
+      right: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["r"])),
+      bottom: emuToPixels(sanitizeEmuValue(effectExtent.attributes?.["b"]))
     };
   }
   const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
   const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
   const positionHValue = emuToPixels(positionH?.elements[0]?.text);
-  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
-  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const hRelativeFrom = positionHTag?.attributes?.relativeFrom;
+  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements?.[0]?.text;
   const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
   const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
   const positionVValue = emuToPixels(positionV?.elements[0]?.text);
-  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
-  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const vRelativeFrom = positionVTag?.attributes?.relativeFrom;
+  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements?.[0]?.text;
+  const marginOffset = {
+    horizontal: positionHValue,
+    top: positionVValue
+  };
   const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
   const wrapNode = isAnchor ? node.elements.find(
     (el) => ["wp:wrapNone", "wp:wrapSquare", "wp:wrapThrough", "wp:wrapTight", "wp:wrapTopAndBottom"].includes(el.name)
@@ -28560,38 +28805,40 @@ function handleImageNode(node, params2, isAnchor) {
   const wrap2 = isAnchor ? { type: wrapNode?.name.slice(7) || "None", attrs: {} } : { type: "Inline" };
   switch (wrap2.type) {
     case "Square":
-      wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
-      if ("distB" in (wrapNode.attributes || {})) {
+      if (wrapNode?.attributes?.wrapText) {
+        wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
+      }
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("distL" in (wrapNode.attributes || {})) {
+      if ("distL" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
       }
-      if ("distR" in (wrapNode.attributes || {})) {
+      if ("distR" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
       break;
     case "Tight":
     case "Through": {
-      if ("distL" in (wrapNode.attributes || {})) {
+      if ("distL" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distLeft = emuToPixels(wrapNode.attributes.distL);
       }
-      if ("distR" in (wrapNode.attributes || {})) {
+      if ("distR" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distRight = emuToPixels(wrapNode.attributes.distR);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
-      if ("distB" in (wrapNode.attributes || {})) {
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("wrapText" in (wrapNode.attributes || {})) {
+      if ("wrapText" in (wrapNode?.attributes || {})) {
         wrap2.attrs.wrapText = wrapNode.attributes.wrapText;
       }
-      const polygon = wrapNode.elements?.find((el) => el.name === "wp:wrapPolygon");
+      const polygon = wrapNode?.elements?.find((el) => el.name === "wp:wrapPolygon");
       if (polygon) {
         wrap2.attrs.polygon = polygonToObj(polygon);
         if (polygon.attributes?.edited !== void 0) {
@@ -28601,10 +28848,10 @@ function handleImageNode(node, params2, isAnchor) {
       break;
     }
     case "TopAndBottom":
-      if ("distB" in (wrapNode.attributes || {})) {
+      if ("distB" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distBottom = emuToPixels(wrapNode.attributes.distB);
       }
-      if ("distT" in (wrapNode.attributes || {})) {
+      if ("distT" in (wrapNode?.attributes || {})) {
         wrap2.attrs.distTop = emuToPixels(wrapNode.attributes.distT);
       }
       break;
@@ -28622,17 +28869,42 @@ function handleImageNode(node, params2, isAnchor) {
       alignV
     };
   }
-  const marginOffset = {
-    horizontal: positionHValue,
-    top: positionVValue
-  };
+  const graphic = node.elements.find((el) => el.name === "a:graphic");
+  const graphicData = graphic?.elements.find((el) => el.name === "a:graphicData");
+  const { uri: uri2 } = graphicData?.attributes || {};
+  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+  if (!!uri2 && uri2 === shapeURI) {
+    const shapeMarginOffset = {
+      left: positionHValue,
+      horizontal: positionHValue,
+      top: positionVValue
+    };
+    return handleShapeDrawing(params2, node, graphicData, size2, padding, shapeMarginOffset);
+  }
+  const picture = graphicData?.elements.find((el) => el.name === "pic:pic");
+  if (!picture || !picture.elements) return null;
+  const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
+  const blip = blipFill?.elements.find((el) => el.name === "a:blip");
+  if (!blip) return null;
+  const spPr = picture.elements.find((el) => el.name === "pic:spPr");
+  if (spPr) {
+    const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
+    if (xfrm?.attributes) {
+      transformData = {
+        ...transformData,
+        rotation: rotToDegrees(xfrm.attributes["rot"]),
+        verticalFlip: xfrm.attributes["flipV"] === "1",
+        horizontalFlip: xfrm.attributes["flipH"] === "1"
+      };
+    }
+  }
   const { attributes: blipAttributes = {} } = blip;
   const rEmbed = blipAttributes["r:embed"];
   if (!rEmbed) return null;
   const currentFile = filename || "document.xml";
   let rels = docx[`word/_rels/${currentFile}.rels`];
   if (!rels) rels = docx[`word/_rels/document.xml.rels`];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
+  const relationships = rels?.elements.find((el) => el.name === "Relationships");
   const { elements } = relationships || [];
   const rel = elements?.find((el) => el.attributes["Id"] === rEmbed);
   if (!rel) return null;
@@ -28645,10 +28917,10 @@ function handleImageNode(node, params2, isAnchor) {
     type: "image",
     attrs: {
       src: path,
-      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
+      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes?.name || "Image",
       extension,
-      id: docPr?.attributes.id || "",
-      title: docPr?.attributes.descr || "Image",
+      id: docPr?.attributes?.id || "",
+      title: docPr?.attributes?.descr || "Image",
       inline: true,
       padding,
       marginOffset,
@@ -28663,6 +28935,10 @@ function handleImageNode(node, params2, isAnchor) {
         }
       },
       wrap: wrap2,
+      ...wrap2.type === "Square" && wrap2.attrs.wrapText ? {
+        wrapText: wrap2.attrs.wrapText
+      } : {},
+      wrapTopAndBottom: wrap2.type === "TopAndBottom",
       originalPadding: {
         distT: attributes["distT"],
         distB: attributes["distB"],
@@ -28674,7 +28950,7 @@ function handleImageNode(node, params2, isAnchor) {
     }
   };
 }
-const handleShapeDrawing = (params2, node, graphicData) => {
+const handleShapeDrawing = (params2, node, graphicData, size2, padding, marginOffset) => {
   const wsp = graphicData.elements.find((el) => el.name === "wps:wsp");
   const textBox = wsp.elements.find((el) => el.name === "wps:txbx");
   const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
@@ -28685,21 +28961,14 @@ const handleShapeDrawing = (params2, node, graphicData) => {
     return getRectangleShape(params2, spPr);
   }
   if (!textBoxContent) {
-    return null;
+    return buildShapePlaceholder(node, size2, padding, marginOffset, "drawing");
   }
-  const { nodeListHandler } = params2;
-  const translatedElement = nodeListHandler.handler({
-    ...params2,
-    node: textBoxContent.elements[0],
-    nodes: textBoxContent.elements,
-    path: [...params2.path || [], textBoxContent]
-  });
-  return translatedElement[0];
+  return buildShapePlaceholder(node, size2, padding, marginOffset, "textbox");
 };
 const getRectangleShape = (params2, node) => {
   const schemaAttrs = {};
   const [drawingNode] = params2.nodes;
-  if (drawingNode?.name === "w:drawing") {
+  if (drawingNode?.name === DRAWING_XML_TAG) {
     schemaAttrs.drawingContent = drawingNode;
   }
   const xfrm = node.elements.find((el) => el.name === "a:xfrm");
@@ -28723,6 +28992,52 @@ const getRectangleShape = (params2, node) => {
     attrs: schemaAttrs
   };
 };
+const buildShapePlaceholder = (node, size2, padding, marginOffset, shapeType) => {
+  const attrs = {
+    drawingContent: {
+      name: DRAWING_XML_TAG,
+      elements: [carbonCopy(node)]
+    },
+    attributes: {
+      "data-shape-type": shapeType
+    }
+  };
+  if (size2 && (Number.isFinite(size2.width) || Number.isFinite(size2.height))) {
+    attrs.size = {
+      ...Number.isFinite(size2.width) ? { width: size2.width } : {},
+      ...Number.isFinite(size2.height) ? { height: size2.height } : {}
+    };
+  }
+  if (padding) {
+    const paddingData = {};
+    if (Number.isFinite(padding.top)) paddingData["data-padding-top"] = padding.top;
+    if (Number.isFinite(padding.right)) paddingData["data-padding-right"] = padding.right;
+    if (Number.isFinite(padding.bottom)) paddingData["data-padding-bottom"] = padding.bottom;
+    if (Number.isFinite(padding.left)) paddingData["data-padding-left"] = padding.left;
+    if (Object.keys(paddingData).length) {
+      attrs.attributes = {
+        ...attrs.attributes,
+        ...paddingData
+      };
+    }
+  }
+  if (marginOffset) {
+    const offsetData = {};
+    const horizontal = Number.isFinite(marginOffset.horizontal) ? marginOffset.horizontal : Number.isFinite(marginOffset.left) ? marginOffset.left : void 0;
+    if (Number.isFinite(horizontal)) offsetData["data-offset-x"] = horizontal;
+    if (Number.isFinite(marginOffset.top)) offsetData["data-offset-y"] = marginOffset.top;
+    if (Object.keys(offsetData).length) {
+      attrs.attributes = {
+        ...attrs.attributes,
+        ...offsetData
+      };
+    }
+  }
+  return {
+    type: "contentBlock",
+    attrs
+  };
+};
 function handleAnchorNode(params2) {
   const { node } = params2.extraParams;
   if (node.name !== "wp:anchor") {
@@ -58931,8 +59246,11 @@ const HardBreak = Node$1.create({
   }
 });
 const getColStyleDeclaration = (minWidth, width) => {
-  if (width) {
-    return ["width", `${Math.max(width, minWidth)}px`];
+  if (width != null) {
+    const numericWidth = Number(width);
+    if (Number.isFinite(numericWidth) && numericWidth >= 0) {
+      return ["width", `${numericWidth}px`];
+    }
   }
   return ["min-width", `${minWidth}px`];
 };
@@ -58954,7 +59272,7 @@ const createTableView = ({ editor }) => {
       this.table = this.dom.appendChild(document.createElement("table"));
       this.colgroup = this.table.appendChild(document.createElement("colgroup"));
       updateTable(this.editor, this.node, this.table);
-      updateColumns(node, this.colgroup, this.table, cellMinWidth2);
+      updateColumns(node, this.colgroup, this.table, cellMinWidth2, void 0, void 0, this.editor);
       this.contentDOM = this.table.appendChild(document.createElement("tbody"));
       setTimeout(() => {
         updateTableWrapper(this.dom, this.table);
@@ -58966,7 +59284,7 @@ const createTableView = ({ editor }) => {
       }
       this.node = node;
       updateTable(this.editor, node, this.table);
-      updateColumns(node, this.colgroup, this.table, this.cellMinWidth);
+      updateColumns(node, this.colgroup, this.table, this.cellMinWidth, void 0, void 0, this.editor);
       updateTableWrapper(this.dom, this.table);
       return true;
     }
@@ -58979,46 +59297,105 @@ const createTableView = ({ editor }) => {
     }
   };
 };
-function updateColumns(node, colgroup, table, cellMinWidth2, overrideCol, overrideValue) {
-  let totalWidth = 0;
-  let fixedWidth = true;
-  let nextDOM = colgroup.firstChild;
+function updateColumns(node, colgroup, table, cellMinWidth2, overrideCol, overrideValue, editor) {
+  const gridColumns = Array.isArray(node.attrs?.grid) && node.attrs.grid.length ? node.attrs.grid.map((col) => twipsToPixels(col.col)) : null;
+  const totalColumns = gridColumns?.length ?? null;
+  const pageBody = table.closest(".page__body");
+  const wrapper = table.parentElement;
+  let availableWidth = pageBody?.getBoundingClientRect?.().width;
+  if (!availableWidth && wrapper) {
+    availableWidth = wrapper.getBoundingClientRect().width;
+  }
+  if (typeof availableWidth === "number" && !Number.isNaN(availableWidth)) {
+    availableWidth = Math.max(availableWidth - 2, 0);
+  } else {
+    availableWidth = null;
+  }
+  const pageStyles = editor?.converter?.pageStyles;
+  if (pageStyles?.pageSize?.width) {
+    const toNumber = (v2) => typeof v2 === "number" ? v2 : parseFloat(v2) || 0;
+    const pageWidth = toNumber(pageStyles.pageSize.width);
+    const marginLeft = toNumber(pageStyles.pageMargins?.left);
+    const marginRight = toNumber(pageStyles.pageMargins?.right);
+    const pageAvailableWidthPx = Math.max((pageWidth - marginLeft - marginRight) * PIXELS_PER_INCH, 0);
+    if (pageAvailableWidthPx > 0) {
+      availableWidth = availableWidth ? Math.min(availableWidth, pageAvailableWidthPx) : pageAvailableWidthPx;
+    }
+  }
+  const resolveColumnWidth = (colIndex2, colwidthValue) => {
+    if (overrideCol === colIndex2) return overrideValue;
+    if (colwidthValue != null) return colwidthValue;
+    if (gridColumns && gridColumns[colIndex2] != null) return gridColumns[colIndex2];
+    return null;
+  };
+  const widths = [];
   const row = node.firstChild;
+  let colIndex = 0;
   if (row !== null) {
-    for (let i = 0, col = 0; i < row.childCount; i++) {
-      const { colspan, colwidth } = row.child(i).attrs;
-      for (let j2 = 0; j2 < colspan; j2++, col++) {
-        const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j2];
-        const cssWidth = hasWidth ? `${hasWidth}px` : "";
-        totalWidth += hasWidth || cellMinWidth2;
-        if (!hasWidth) fixedWidth = false;
-        if (!nextDOM) {
-          const col2 = document.createElement("col");
-          const [propKey, propVal] = getColStyleDeclaration(cellMinWidth2, hasWidth);
-          col2.style.setProperty(propKey, propVal);
-          colgroup.appendChild(col2);
-        } else {
-          if (nextDOM.style.width !== cssWidth) {
-            const [propKey, propVal] = getColStyleDeclaration(cellMinWidth2, hasWidth);
-            nextDOM.style.setProperty(propKey, propVal);
-          }
-          nextDOM = nextDOM.nextSibling;
-        }
+    for (let i = 0; i < row.childCount; i++) {
+      const child = row.child(i);
+      const { colspan, colwidth } = child.attrs;
+      for (let span = 0; span < colspan; span += 1, colIndex += 1) {
+        widths.push(resolveColumnWidth(colIndex, colwidth && colwidth[span]));
       }
     }
   }
-  while (nextDOM) {
-    const after = nextDOM.nextSibling;
-    nextDOM.parentNode?.removeChild(nextDOM);
-    nextDOM = after;
+  if (totalColumns != null && colIndex < totalColumns) {
+    for (let col = colIndex; col < totalColumns; col += 1) {
+      widths.push(resolveColumnWidth(col));
+    }
   }
-  if (fixedWidth) {
-    table.style.width = `${totalWidth}px`;
+  const normalizedWidths = widths.map((widthPx) => {
+    const numericWidth = Number(widthPx);
+    if (!Number.isFinite(numericWidth)) return null;
+    if (numericWidth < 0) return null;
+    if (numericWidth === 0) return 0;
+    if (numericWidth < 1) return 0;
+    return numericWidth;
+  });
+  const rawTotalWidth = normalizedWidths.reduce((sum, width) => sum + (width != null ? width : cellMinWidth2), 0);
+  let scale = 1;
+  if (availableWidth && rawTotalWidth > 0 && rawTotalWidth > availableWidth) {
+    scale = availableWidth / rawTotalWidth;
+  }
+  let totalWidth = 0;
+  let hasUndefinedWidth = false;
+  let dom = colgroup.firstChild;
+  normalizedWidths.forEach((width) => {
+    let scaledWidth = width;
+    if (scaledWidth != null) {
+      scaledWidth = scaledWidth * scale;
+    }
+    const [propKey, propVal] = getColStyleDeclaration(cellMinWidth2, scaledWidth);
+    if (scaledWidth == null) {
+      totalWidth += cellMinWidth2;
+      hasUndefinedWidth = true;
+    } else {
+      totalWidth += scaledWidth;
+    }
+    if (!dom) {
+      const colElement = document.createElement("col");
+      colElement.style.setProperty(propKey, propVal);
+      colgroup.appendChild(colElement);
+    } else {
+      dom.style.setProperty(propKey, propVal);
+      dom = dom.nextSibling;
+    }
+  });
+  while (dom) {
+    const next = dom.nextSibling;
+    dom.parentNode?.removeChild(dom);
+    dom = next;
+  }
+  if (scale < 1 || !hasUndefinedWidth) {
+    const clampedWidth = Math.min(totalWidth, availableWidth || totalWidth);
+    table.style.width = `${clampedWidth}px`;
     table.style.minWidth = "";
   } else {
     table.style.width = "";
     table.style.minWidth = `${totalWidth}px`;
   }
+  table.style.maxWidth = "100%";
 }
 function updateTable(editor, node, table) {
   const allExtensionsAttrs = editor.extensionService.attributes;
@@ -59096,22 +59473,61 @@ const createTable = (schema, rowsCount, colsCount, withHeaderRow, cellContent =
   const tableBorders = createTableBorders();
   return types2.table.createChecked({ borders: tableBorders }, rows);
 };
+const MIN_MEANINGFUL_WIDTH_PX = 1;
 const createColGroup = (node, cellMinWidth2, overrideCol, overrideValue) => {
   let totalWidth = 0;
   let fixedWidth = true;
   const cols = [];
   const colsValues = [];
   const row = node.firstChild;
+  const gridColumns = Array.isArray(node.attrs?.grid) && node.attrs.grid.length ? node.attrs.grid.map((col) => twipsToPixels(col.col)) : null;
   if (!row) return {};
-  for (let i = 0, col = 0; i < row.childCount; i++) {
-    const { colspan, colwidth } = row.child(i).attrs;
-    for (let j2 = 0; j2 < colspan; j2++, col++) {
-      const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j2];
-      totalWidth += hasWidth || cellMinWidth2;
-      if (!hasWidth) fixedWidth = false;
-      const [prop, value] = getColStyleDeclaration(cellMinWidth2, hasWidth);
+  const totalColumns = gridColumns?.length;
+  const resolveColumnWidth = (colIndex2, colwidthValue) => {
+    if (overrideCol === colIndex2) return overrideValue;
+    if (colwidthValue != null) return colwidthValue;
+    if (gridColumns && gridColumns[colIndex2] != null) return gridColumns[colIndex2];
+    return null;
+  };
+  let colIndex = 0;
+  for (let i = 0; i < row.childCount; i++) {
+    const child = row.child(i);
+    const { colspan, colwidth } = child.attrs;
+    for (let j2 = 0; j2 < colspan; j2++, colIndex++) {
+      const candidateWidth = resolveColumnWidth(colIndex, colwidth && colwidth[j2]);
+      const numericWidth = Number(candidateWidth);
+      let effectiveWidth = Number.isFinite(numericWidth) && numericWidth > 0 ? numericWidth : null;
+      if (effectiveWidth != null && effectiveWidth < MIN_MEANINGFUL_WIDTH_PX) {
+        effectiveWidth = 0;
+      }
+      if (effectiveWidth == null) {
+        totalWidth += cellMinWidth2;
+        fixedWidth = false;
+      } else {
+        totalWidth += effectiveWidth;
+      }
+      const [prop, value] = getColStyleDeclaration(cellMinWidth2, effectiveWidth);
       cols.push(["col", { style: `${prop}: ${value}` }]);
-      colsValues.push(parseInt(value, 10));
+      colsValues.push(parseFloat(value));
+    }
+  }
+  if (totalColumns != null) {
+    for (let col = colIndex; col < totalColumns; col++) {
+      const candidateWidth = resolveColumnWidth(col);
+      const numericWidth = Number(candidateWidth);
+      let effectiveWidth = Number.isFinite(numericWidth) && numericWidth > 0 ? numericWidth : null;
+      if (effectiveWidth != null && effectiveWidth < MIN_MEANINGFUL_WIDTH_PX) {
+        effectiveWidth = 0;
+      }
+      if (effectiveWidth == null) {
+        totalWidth += cellMinWidth2;
+        fixedWidth = false;
+      } else {
+        totalWidth += effectiveWidth;
+      }
+      const [prop, value] = getColStyleDeclaration(cellMinWidth2, effectiveWidth);
+      cols.push(["col", { style: `${prop}: ${value}` }]);
+      colsValues.push(parseFloat(value));
     }
   }
   const tableWidth = fixedWidth ? `${totalWidth}px` : "";
@@ -62014,6 +62430,19 @@ const TableHeader = Node$1.create({
             "data-colwidth": attrs.colwidth.join(",")
           };
         }
+      },
+      __placeholder: {
+        default: null,
+        parseDOM: (element) => {
+          const value = element.getAttribute("data-placeholder");
+          return value || null;
+        },
+        renderDOM({ __placeholder }) {
+          if (!__placeholder) return {};
+          return {
+            "data-placeholder": __placeholder
+          };
+        }
       }
     };
   },
@@ -62174,6 +62603,19 @@ const TableCell = Node$1.create({
         default: "px",
         rendered: false
       },
+      __placeholder: {
+        default: null,
+        parseDOM: (element) => {
+          const value = element.getAttribute("data-placeholder");
+          return value || null;
+        },
+        renderDOM({ __placeholder }) {
+          if (!__placeholder) return {};
+          return {
+            "data-placeholder": __placeholder
+          };
+        }
+      },
       /**
        * @category Attribute
        * @param {TableCellProperties} tableCellProperties - Properties for the table cell.