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

package/dist/superdoc.umd.js

@@ -22818,6 +22818,7 @@
     }
     return content;
   }
+  const PIXELS_PER_INCH = 96;
   function inchesToTwips(inches) {
     if (inches == null) return;
     if (typeof inches === "string") inches = parseFloat(inches);
@@ -22840,12 +22841,12 @@
   }
   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) {
@@ -22863,7 +22864,7 @@
   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) {
@@ -22899,12 +22900,12 @@
   }
   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) {
@@ -34780,6 +34781,68 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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(
@@ -34795,29 +34858,64 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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,
@@ -34827,9 +34925,37 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   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) {
@@ -35059,17 +35185,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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);
     };
@@ -35077,13 +35207,17 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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);
@@ -35092,8 +35226,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           cellWidthTwips = gridWidthTwips;
         } else {
           cellWidthTwips = fallbackColumnWidthTwips;
+          enforceMinimum = true;
         }
-        pushColumn(cellWidthTwips);
+        pushColumn(cellWidthTwips, { enforceMinimum });
         columnIndex++;
       }
     });
@@ -35256,7 +35391,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     }
     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],
@@ -35265,10 +35402,45 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           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",
@@ -35673,14 +35845,104 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     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) => {
@@ -36234,6 +36496,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return { type: "unknown", handler: null };
   }
+  const DRAWING_XML_TAG = "w:drawing";
   function handleImageNode(node, params2, isAnchor) {
     const { docx, filename } = params2;
     const { attributes } = node;
@@ -36245,32 +36508,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     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) => {
@@ -36279,22 +36520,26 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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)
@@ -36302,38 +36547,40 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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) {
@@ -36343,10 +36590,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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;
@@ -36364,17 +36611,42 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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;
@@ -36387,10 +36659,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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,
@@ -36405,6 +36677,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           }
         },
         wrap: wrap2,
+        ...wrap2.type === "Square" && wrap2.attrs.wrapText ? {
+          wrapText: wrap2.attrs.wrapText
+        } : {},
+        wrapTopAndBottom: wrap2.type === "TopAndBottom",
         originalPadding: {
           distT: attributes["distT"],
           distB: attributes["distB"],
@@ -36416,7 +36692,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     };
   }
-  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");
@@ -36427,21 +36703,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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");
@@ -36465,6 +36734,52 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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") {
@@ -66646,8 +66961,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
   });
   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`];
   };
@@ -66669,7 +66987,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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);
@@ -66681,7 +66999,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         }
         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;
       }
@@ -66694,46 +67012,105 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     };
   };
-  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 toNumber2 = (v2) => typeof v2 === "number" ? v2 : parseFloat(v2) || 0;
+      const pageWidth = toNumber2(pageStyles.pageSize.width);
+      const marginLeft = toNumber2(pageStyles.pageMargins?.left);
+      const marginRight = toNumber2(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 i2 = 0, col = 0; i2 < row.childCount; i2++) {
-        const { colspan, colwidth } = row.child(i2).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 i2 = 0; i2 < row.childCount; i2++) {
+        const child = row.child(i2);
+        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;
@@ -66811,22 +67188,61 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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 i2 = 0, col = 0; i2 < row.childCount; i2++) {
-      const { colspan, colwidth } = row.child(i2).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 i2 = 0; i2 < row.childCount; i2++) {
+      const child = row.child(i2);
+      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` : "";
@@ -69729,6 +70145,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               "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
+            };
+          }
         }
       };
     },
@@ -69889,6 +70318,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           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.
@@ -113053,17 +113495,62 @@ ${style2}
     const highContrastModeStore = useHighContrastMode();
     return { app, pinia, superdocStore, commentsStore, highContrastModeStore };
   };
-  const createDownload = (blob, name, extension) => {
+  const MIME_TYPES = {
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    html: "text/html",
+    txt: "text/plain;charset=utf-8",
+    json: "application/json"
+  };
+  const getMimeType = (extension) => {
+    if (!extension || typeof extension.toLowerCase !== "function") return "application/octet-stream";
+    return MIME_TYPES[extension.toLowerCase()] || "application/octet-stream";
+  };
+  const ensureBlob = (data, extension) => {
+    if (data instanceof Blob) return data;
+    const mimeType = getMimeType(extension);
+    if (data instanceof ArrayBuffer) {
+      return new Blob([data], { type: mimeType });
+    }
+    if (ArrayBuffer.isView(data)) {
+      const { buffer: buffer2, byteOffset, byteLength: byteLength2 } = data;
+      const slice = buffer2.slice(byteOffset, byteOffset + byteLength2);
+      return new Blob([slice], { type: mimeType });
+    }
+    if (typeof data === "string") {
+      return new Blob([data], { type: mimeType });
+    }
+    if (data == null) {
+      throw new TypeError("createDownload requires a Blob, ArrayBuffer, or ArrayBufferView.");
+    }
+    throw new TypeError(`Cannot create download from value of type ${typeof data}`);
+  };
+  const createDownload = (data, name, extension) => {
+    const blob = ensureBlob(data, extension);
+    if (typeof URL === "undefined" || typeof URL.createObjectURL !== "function") return blob;
+    if (typeof document === "undefined" || typeof document.createElement !== "function") return blob;
     const url = URL.createObjectURL(blob);
     const a = document.createElement("a");
     a.href = url;
     a.download = `${name}.${extension}`;
+    const shouldAppend = document.body && typeof document.body.appendChild === "function";
+    if (shouldAppend) document.body.appendChild(a);
     a.click();
+    if (shouldAppend) document.body.removeChild(a);
+    if (typeof URL.revokeObjectURL === "function") {
+      setTimeout(() => URL.revokeObjectURL(url), 0);
+    }
+    return blob;
   };
   const cleanName = (currentName) => {
-    if (currentName.toLowerCase().endsWith(".docx") || currentName.toLowerCase().endsWith(".pdf")) {
+    const lowerName = currentName.toLowerCase();
+    if (lowerName.endsWith(".docx")) {
       return currentName.slice(0, -5);
     }
+    if (lowerName.endsWith(".pdf")) {
+      return currentName.slice(0, -4);
+    }
     return currentName;
   };
   class SuperDoc extends EventEmitter {
@@ -113681,14 +114168,25 @@ ${style2}
           comments.push(...this.commentsStore.translateCommentsForExport());
         }
       }
-      const docxPromises = [];
-      this.superdocStore.documents.forEach((doc2) => {
-        const editor = doc2.getEditor();
-        if (editor) {
-          docxPromises.push(editor.exportDocx({ isFinalDoc, comments, commentsType, fieldsHighlightColor }));
+      const docxPromises = this.superdocStore.documents.map(async (doc2) => {
+        if (!doc2 || doc2.type !== DOCX) return null;
+        const editor = typeof doc2.getEditor === "function" ? doc2.getEditor() : null;
+        const fallbackDocx = () => {
+          if (!doc2.data) return null;
+          if (doc2.data.type && doc2.data.type !== DOCX) return null;
+          return doc2.data;
+        };
+        if (!editor) return fallbackDocx();
+        try {
+          const exported = await editor.exportDocx({ isFinalDoc, comments, commentsType, fieldsHighlightColor });
+          if (exported) return exported;
+        } catch (error) {
+          this.emit("exception", { error, document: doc2 });
         }
+        return fallbackDocx();
       });
-      return await Promise.all(docxPromises);
+      const docxFiles = await Promise.all(docxPromises);
+      return docxFiles.filter(Boolean);
     }
     /**
      * Request an immediate save from all collaboration documents