@harbour-enterprises/superdoc 1.5.0-next.5 → 1.5.0-next.7

package/dist/superdoc.umd.js

@@ -8332,6 +8332,11 @@
     "xmlns:v": "urn:schemas-microsoft-com:vml",
     "xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
     "xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+    "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "xmlns:pic": "http://schemas.openxmlformats.org/drawingml/2006/picture",
+    "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "xmlns:dgm": "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+    "xmlns:lc": "http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas",
     "xmlns:w10": "urn:schemas-microsoft-com:office:word",
     "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
     "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
@@ -15124,6 +15129,11 @@
   const validXmlAttributes$9 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
     (xmlName) => createAttributeHandler(xmlName)
   );
+  const getColspan$1 = (cell2) => {
+    const rawColspan = cell2?.attrs?.colspan;
+    const numericColspan = typeof rawColspan === "string" ? parseInt(rawColspan, 10) : rawColspan;
+    return Number.isFinite(numericColspan) && numericColspan > 0 ? numericColspan : 1;
+  };
   const encode$w = (params2, encodedAttrs) => {
     const { row: row2 } = params2.extraParams;
     let tableRowProperties = {};
@@ -15256,7 +15266,27 @@
       }
       return cell2;
     });
-    const trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+    let trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+    const preferTableGrid = params2.extraParams?.preferTableGrid === true;
+    const totalColumns = params2.extraParams?.totalColumns;
+    if (preferTableGrid && typeof totalColumns === "number" && Number.isFinite(totalColumns) && totalColumns > 0) {
+      const rawGridBefore = node2.attrs?.tableRowProperties?.gridBefore;
+      const numericGridBefore = typeof rawGridBefore === "string" ? parseInt(rawGridBefore, 10) : rawGridBefore;
+      const safeGridBefore = Number.isFinite(numericGridBefore) && numericGridBefore > 0 ? numericGridBefore : 0;
+      const effectiveGridBefore = leadingPlaceholders > 0 ? leadingPlaceholders : safeGridBefore;
+      const availableColumns = Math.max(totalColumns - effectiveGridBefore, 0);
+      let usedColumns = 0;
+      const constrainedCells = [];
+      for (const cell2 of trimmedContent) {
+        const colspan = getColspan$1(cell2);
+        if (usedColumns + colspan > availableColumns) {
+          break;
+        }
+        constrainedCells.push(cell2);
+        usedColumns += colspan;
+      }
+      trimmedContent = constrainedCells;
+    }
     const translateParams = {
       ...params2,
       node: { ...node2, content: trimmedContent }
@@ -24278,9 +24308,9 @@
     if (!blip) {
       return null;
     }
-    const stretch = blipFill?.elements.find((el) => el.name === "a:stretch");
-    const fillRect = stretch?.elements.find((el) => el.name === "a:fillRect");
-    const srcRect = blipFill?.elements.find((el) => el.name === "a:srcRect");
+    const stretch = blipFill?.elements?.find((el) => el.name === "a:stretch");
+    const fillRect = stretch?.elements?.find((el) => el.name === "a:fillRect");
+    const srcRect = blipFill?.elements?.find((el) => el.name === "a:srcRect");
     const srcRectAttrs = srcRect?.attributes || {};
     const srcRectHasNegativeValues = ["l", "t", "r", "b"].some((attr) => {
       const val = srcRectAttrs[attr];
@@ -31536,6 +31566,53 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     attributes: validXmlAttributes$5
   };
   const translator$s = NodeTranslator.from(config$d);
+  const getColspan = (cell2) => {
+    const rawColspan = cell2?.attrs?.colspan;
+    const numericColspan = typeof rawColspan === "string" ? parseInt(rawColspan, 10) : rawColspan;
+    return Number.isFinite(numericColspan) && numericColspan > 0 ? numericColspan : 1;
+  };
+  const resolveGridBefore = (row2) => {
+    const rawGridBefore = row2?.attrs?.tableRowProperties?.gridBefore ?? row2?.attrs?.gridBefore;
+    const numericGridBefore = typeof rawGridBefore === "string" ? parseInt(rawGridBefore, 10) : rawGridBefore;
+    if (!Number.isFinite(numericGridBefore) || numericGridBefore <= 0) return 0;
+    const cells = Array.isArray(row2.content) ? row2.content : [];
+    let leadingGridBefore = 0;
+    while (leadingGridBefore < cells.length && cells[leadingGridBefore]?.attrs?.__placeholder === "gridBefore") {
+      leadingGridBefore += 1;
+    }
+    return leadingGridBefore > 0 ? 0 : numericGridBefore;
+  };
+  const advanceColumnsForCell = (columnIndex, cell2) => columnIndex + getColspan(cell2);
+  const getCellStartColumn = (row2, targetCell) => {
+    const cells = Array.isArray(row2.content) ? row2.content : [];
+    let columnIndex = resolveGridBefore(row2);
+    for (const cell2 of cells) {
+      if (cell2 === targetCell) return columnIndex;
+      columnIndex = advanceColumnsForCell(columnIndex, cell2);
+    }
+    return columnIndex;
+  };
+  const findCellCoveringColumn = (row2, targetColumn) => {
+    const cells = Array.isArray(row2.content) ? row2.content : [];
+    let columnIndex = resolveGridBefore(row2);
+    for (const cell2 of cells) {
+      const colspan = getColspan(cell2);
+      if (targetColumn >= columnIndex && targetColumn < columnIndex + colspan) {
+        return cell2;
+      }
+      columnIndex = advanceColumnsForCell(columnIndex, cell2);
+    }
+    return null;
+  };
+  const findInsertionIndexForColumn = (row2, targetColumn) => {
+    const cells = Array.isArray(row2.content) ? row2.content : [];
+    let columnIndex = resolveGridBefore(row2);
+    for (let index2 = 0; index2 < cells.length; index2++) {
+      if (columnIndex >= targetColumn) return index2;
+      columnIndex = advanceColumnsForCell(columnIndex, cells[index2]);
+    }
+    return cells.length;
+  };
   function preProcessVerticalMergeCells(table2, { editorSchema }) {
     if (!table2 || !Array.isArray(table2.content)) {
       return table2;
@@ -31551,15 +31628,17 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         const cell2 = row2.content[cellIndex];
         if (!cell2) continue;
         const attrs = cell2.attrs || {};
-        if (!attrs.rowspan || attrs.rowspan <= 1) continue;
-        const maxRowspan = Math.min(attrs.rowspan, rows.length - rowIndex);
+        const rawRowspan = typeof attrs.rowspan === "string" ? parseInt(attrs.rowspan, 10) : attrs.rowspan;
+        if (!Number.isFinite(rawRowspan) || rawRowspan <= 1) continue;
+        const maxRowspan = Math.min(rawRowspan, rows.length - rowIndex);
+        const startColumn = getCellStartColumn(row2, cell2);
         for (let offset2 = 1; offset2 < maxRowspan; offset2++) {
           const rowToChange = rows[rowIndex + offset2];
           if (!rowToChange) continue;
           if (!Array.isArray(rowToChange.content)) {
             rowToChange.content = [];
           }
-          const existingCell = rowToChange.content[cellIndex];
+          const existingCell = findCellCoveringColumn(rowToChange, startColumn);
           if (existingCell?.attrs?.continueMerge) continue;
           const mergedCell = {
             type: cell2.type,
@@ -31570,7 +31649,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               continueMerge: true
             }
           };
-          rowToChange.content.splice(cellIndex, 0, mergedCell);
+          const insertionIndex = findInsertionIndexForColumn(rowToChange, startColumn);
+          rowToChange.content.splice(insertionIndex, 0, mergedCell);
         }
       }
     }
@@ -31722,15 +31802,24 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const decode$t = (params2) => {
     const { grid: rawGrid } = params2.node.attrs || {};
     const grid = Array.isArray(rawGrid) ? rawGrid : [];
-    const { firstRow = {} } = params2.extraParams || {};
+    const { firstRow = {}, preferTableGrid = false, totalColumns: requestedColumns } = params2.extraParams || {};
     const cellNodes = firstRow.content?.filter((n) => n.type === "tableCell") ?? [];
-    const colWidthsFromCellNodes = cellNodes.flatMap((cell2) => {
+    let colWidthsFromCellNodes = cellNodes.flatMap((cell2) => {
       const spanCount = Math.max(1, cell2?.attrs?.colspan ?? 1);
       const colwidth = cell2.attrs?.colwidth;
       return Array.from({ length: spanCount }).map((_2, span) => Array.isArray(colwidth) ? colwidth[span] : void 0);
     });
     const columnCountFromCells = colWidthsFromCellNodes.length;
-    const totalColumns = Math.max(columnCountFromCells, grid.length);
+    const gridColumnCount = grid.length;
+    let totalColumns = Math.max(columnCountFromCells, gridColumnCount);
+    if (typeof requestedColumns === "number" && Number.isFinite(requestedColumns) && requestedColumns > 0) {
+      totalColumns = requestedColumns;
+    } else if (preferTableGrid && gridColumnCount > 0) {
+      totalColumns = gridColumnCount;
+    }
+    if (colWidthsFromCellNodes.length > totalColumns) {
+      colWidthsFromCellNodes = colWidthsFromCellNodes.slice(0, totalColumns);
+    }
     const fallbackColumnWidthTwips = resolveFallbackColumnWidthTwips(params2, totalColumns, cellMinWidth);
     const elements = [];
     const pushColumn = (widthTwips, { enforceMinimum = false } = {}) => {
@@ -31990,22 +32079,31 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const decode$s = (params2, decodedAttrs) => {
     params2.node = preProcessVerticalMergeCells(params2.node, params2);
     const { node: node2 } = params2;
-    const elements = translateChildNodes(params2);
+    const rawGrid = node2.attrs?.grid;
+    const grid = Array.isArray(rawGrid) ? rawGrid : [];
+    const preferTableGrid = node2.attrs?.userEdited !== true && grid.length > 0;
+    const totalColumns = preferTableGrid ? grid.length : void 0;
+    const extraParams = {
+      ...params2.extraParams || {},
+      preferTableGrid,
+      totalColumns
+    };
+    const elements = translateChildNodes({ ...params2, extraParams });
     const firstRow = node2.content?.find((n) => n.type === "tableRow");
-    const properties = node2.attrs.grid;
     const element2 = translator$c.decode({
       ...params2,
-      node: { ...node2, attrs: { ...node2.attrs, grid: properties } },
+      node: { ...node2, attrs: { ...node2.attrs, grid } },
       extraParams: {
+        ...extraParams,
         firstRow
       }
     });
     if (element2) elements.unshift(element2);
     if (node2.attrs?.tableProperties) {
-      const properties2 = { ...node2.attrs.tableProperties };
+      const properties = { ...node2.attrs.tableProperties };
       const element22 = translator$e.decode({
         ...params2,
-        node: { ...node2, attrs: { ...node2.attrs, tableProperties: properties2 } }
+        node: { ...node2, attrs: { ...node2.attrs, tableProperties: properties } }
       });
       if (element22) elements.unshift(element22);
     }
@@ -35461,7 +35559,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return style2;
   }
-  function handleShapeImageImport({ params: params2, pict }) {
+  function handleShapeImageWatermarkImport({ params: params2, pict }) {
     const shape = pict.elements?.find((el) => el.name === "v:shape");
     if (!shape) return null;
     const imagedata = shape.elements?.find((el) => el.name === "v:imagedata");
@@ -35487,7 +35585,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const targetPath = rel.attributes["Target"];
     const normalizedPath = normalizeTargetPath(targetPath);
     const style2 = shapeAttrs.style || "";
-    const styleObj = parseVmlStyle(style2);
+    const styleObj = parseVmlStyle$1(style2);
     const width = styleObj.width || "100px";
     const height = styleObj.height || "100px";
     const position2 = {
@@ -35533,12 +35631,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         },
         // Size
         size: {
-          width: convertToPixels(width),
-          height: convertToPixels(height)
+          width: convertToPixels$1(width),
+          height: convertToPixels$1(height)
         },
         marginOffset: {
-          horizontal: convertToPixels(position2.marginLeft),
-          top: convertToPixels(position2.marginTop)
+          horizontal: convertToPixels$1(position2.marginLeft),
+          top: convertToPixels$1(position2.marginTop)
         },
         // Image adjustments
         ...gain && { gain },
@@ -35554,7 +35652,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (trimmed.startsWith("media/")) return `word/${trimmed}`;
     return `word/${trimmed}`;
   }
-  function parseVmlStyle(style2) {
+  function parseVmlStyle$1(style2) {
     const result = {};
     if (!style2) return result;
     const declarations = style2.split(";").filter((s2) => s2.trim());
@@ -35566,6 +35664,267 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return result;
   }
+  function convertToPixels$1(value) {
+    if (typeof value === "number") return value;
+    if (!value || typeof value !== "string") return 0;
+    const match = value.match(/^([\d.]+)([a-z%]+)?$/i);
+    if (!match) return 0;
+    const num = parseFloat(match[1]);
+    const unit = match[2] || "px";
+    switch (unit.toLowerCase()) {
+      case "px":
+        return num;
+      case "pt":
+        return num * (96 / 72);
+      // 1pt = 1/72 inch, 96 DPI
+      case "in":
+        return num * 96;
+      case "cm":
+        return num * (96 / 2.54);
+      case "mm":
+        return num * (96 / 25.4);
+      case "pc":
+        return num * 16;
+      // 1pc = 12pt
+      default:
+        return num;
+    }
+  }
+  function handleShapeTextWatermarkImport({ pict }) {
+    const shape = pict.elements?.find((el) => el.name === "v:shape");
+    if (!shape) return null;
+    const textpath = shape.elements?.find((el) => el.name === "v:textpath");
+    if (!textpath) return null;
+    const shapeAttrs = shape.attributes || {};
+    const textpathAttrs = textpath.attributes || {};
+    const watermarkText = textpathAttrs["string"] || "";
+    if (!watermarkText) {
+      console.warn("v:textpath missing string attribute");
+      return null;
+    }
+    const style2 = shapeAttrs.style || "";
+    const styleObj = parseVmlStyle(style2);
+    const width = styleObj.width || "481.8pt";
+    const height = styleObj.height || "82.8pt";
+    const position2 = {
+      type: styleObj.position || "absolute",
+      marginLeft: styleObj["margin-left"] || "0",
+      marginTop: styleObj["margin-top"] || "0"
+    };
+    const rotation = parseFloat(styleObj.rotation) || 0;
+    const hPosition = styleObj["mso-position-horizontal"] || "center";
+    const vPosition = styleObj["mso-position-vertical"] || "center";
+    const hRelativeTo = styleObj["mso-position-horizontal-relative"] || "margin";
+    const vRelativeTo = styleObj["mso-position-vertical-relative"] || "margin";
+    const textAnchor = styleObj["v-text-anchor"] || "middle";
+    const fill = shape.elements?.find((el) => el.name === "v:fill");
+    const fillAttrs = fill?.attributes || {};
+    const rawFillColor = shapeAttrs.fillcolor || fillAttrs.color || "silver";
+    const rawFillColor2 = fillAttrs.color2 || "#3f3f3f";
+    const fillColor = sanitizeColor(rawFillColor, "silver");
+    const fillColor2 = sanitizeColor(rawFillColor2, "#3f3f3f");
+    const opacity = fillAttrs.opacity || "0.5";
+    const fillType = fillAttrs.type || "solid";
+    const stroke = shape.elements?.find((el) => el.name === "v:stroke");
+    const strokeAttrs = stroke?.attributes || {};
+    const stroked = shapeAttrs.stroked || "f";
+    const strokeColor = strokeAttrs.color || "#3465a4";
+    const strokeJoinstyle = strokeAttrs.joinstyle || "round";
+    const strokeEndcap = strokeAttrs.endcap || "flat";
+    const textpathStyle = textpathAttrs.style || "";
+    const textStyleObj = parseVmlStyle(textpathStyle);
+    const rawFontFamily = textStyleObj["font-family"]?.replace(/['"]/g, "");
+    const fontFamily2 = sanitizeFontFamily$1(rawFontFamily);
+    const fontSize2 = textStyleObj["font-size"] || "1pt";
+    const fitshape = textpathAttrs.fitshape || "t";
+    const trim = textpathAttrs.trim || "t";
+    const textpathOn = textpathAttrs.on || "t";
+    const path2 = shape.elements?.find((el) => el.name === "v:path");
+    const pathAttrs = path2?.attributes || {};
+    const textpathok = pathAttrs.textpathok || "t";
+    const wrap2 = shape.elements?.find((el) => el.name === "w10:wrap");
+    const wrapAttrs = wrap2?.attributes || {};
+    const wrapType = wrapAttrs.type || "none";
+    const widthPx = convertToPixels(width);
+    const heightPx = convertToPixels(height);
+    const sanitizedOpacity = sanitizeNumeric(parseFloat(opacity), 0.5, 0, 1);
+    const sanitizedRotation = sanitizeNumeric(rotation, 0, -360, 360);
+    const svgResult = generateTextWatermarkSVG({
+      text: watermarkText,
+      width: widthPx,
+      height: heightPx,
+      rotation: sanitizedRotation,
+      fill: {
+        color: fillColor,
+        opacity: sanitizedOpacity
+      },
+      textStyle: {
+        fontFamily: fontFamily2,
+        fontSize: fontSize2
+      }
+    });
+    const svgDataUri = svgResult.dataUri;
+    const imageWatermarkNode = {
+      type: "image",
+      attrs: {
+        src: svgDataUri,
+        alt: watermarkText,
+        title: watermarkText,
+        extension: "svg",
+        // Mark this as a text watermark for export
+        vmlWatermark: true,
+        vmlTextWatermark: true,
+        // Store VML-specific attributes for round-trip
+        vmlStyle: style2,
+        vmlAttributes: shapeAttrs,
+        vmlTextpathAttributes: textpathAttrs,
+        vmlPathAttributes: pathAttrs,
+        vmlFillAttributes: fillAttrs,
+        vmlStrokeAttributes: strokeAttrs,
+        vmlWrapAttributes: wrapAttrs,
+        // Positioning (same as image watermarks)
+        isAnchor: true,
+        inline: false,
+        wrap: {
+          type: wrapType === "none" ? "None" : wrapType,
+          attrs: {
+            behindDoc: true
+          }
+        },
+        anchorData: {
+          hRelativeFrom: hRelativeTo,
+          vRelativeFrom: vRelativeTo,
+          alignH: hPosition,
+          alignV: vPosition
+        },
+        // Size - use rotated bounding box dimensions to prevent clipping
+        size: {
+          width: svgResult.svgWidth,
+          height: svgResult.svgHeight
+        },
+        marginOffset: {
+          horizontal: convertToPixels(position2.marginLeft),
+          // For center-aligned watermarks relative to margin, Word's margin-top value
+          // is not suitable for browser rendering. Set to 0 to let center alignment work.
+          top: vPosition === "center" && vRelativeTo === "margin" ? 0 : convertToPixels(position2.marginTop)
+        },
+        // Store text watermark specific data for export
+        textWatermarkData: {
+          text: watermarkText,
+          rotation: sanitizedRotation,
+          textStyle: {
+            fontFamily: fontFamily2,
+            fontSize: fontSize2,
+            textAnchor
+          },
+          fill: {
+            color: fillColor,
+            color2: fillColor2,
+            opacity: sanitizedOpacity,
+            type: fillType
+          },
+          stroke: {
+            enabled: stroked !== "f",
+            color: strokeColor,
+            joinstyle: strokeJoinstyle,
+            endcap: strokeEndcap
+          },
+          textpath: {
+            on: textpathOn === "t",
+            fitshape: fitshape === "t",
+            trim: trim === "t",
+            textpathok: textpathok === "t"
+          }
+        }
+      }
+    };
+    return imageWatermarkNode;
+  }
+  function sanitizeFontFamily$1(fontFamily2) {
+    if (!fontFamily2 || typeof fontFamily2 !== "string") {
+      return "Arial";
+    }
+    const sanitized = fontFamily2.replace(/[^a-zA-Z0-9\s,\-]/g, "").trim();
+    return sanitized || "Arial";
+  }
+  function sanitizeColor(color2, defaultColor = "silver") {
+    if (!color2 || typeof color2 !== "string") {
+      return defaultColor;
+    }
+    const sanitized = color2.replace(/[^a-zA-Z0-9#%(),.]/g, "").trim();
+    return sanitized || defaultColor;
+  }
+  function sanitizeNumeric(value, defaultValue, min2 = -Infinity, max2 = Infinity) {
+    const num = typeof value === "number" ? value : parseFloat(value);
+    if (isNaN(num) || !isFinite(num)) {
+      return defaultValue;
+    }
+    return Math.max(min2, Math.min(max2, num));
+  }
+  function generateTextWatermarkSVG({ text: text2, width, height, rotation, fill, textStyle }) {
+    let fontSize2 = height * 0.9;
+    if (textStyle?.fontSize && textStyle.fontSize.trim() !== "1pt") {
+      const match = textStyle.fontSize.match(/^([\d.]+)(pt|px)?$/);
+      if (match) {
+        const value = parseFloat(match[1]);
+        const unit = match[2] || "pt";
+        fontSize2 = (unit === "pt" ? value * (96 / 72) : value) * 50;
+      }
+    }
+    fontSize2 = Math.max(fontSize2, 48);
+    const color2 = sanitizeColor(fill?.color, "silver");
+    const opacity = sanitizeNumeric(fill?.opacity, 0.5, 0, 1);
+    const fontFamily2 = sanitizeFontFamily$1(textStyle?.fontFamily);
+    const sanitizedRotation = sanitizeNumeric(rotation, 0, -360, 360);
+    const sanitizedWidth = sanitizeNumeric(width, 100, 1, 1e4);
+    const sanitizedHeight = sanitizeNumeric(height, 100, 1, 1e4);
+    const sanitizedFontSize = sanitizeNumeric(fontSize2, 48, 1, 1e3);
+    const radians = sanitizedRotation * Math.PI / 180;
+    const cos = Math.abs(Math.cos(radians));
+    const sin = Math.abs(Math.sin(radians));
+    const rotatedWidth = sanitizedWidth * cos + sanitizedHeight * sin;
+    const rotatedHeight = sanitizedWidth * sin + sanitizedHeight * cos;
+    const svgWidth = Math.max(sanitizedWidth, rotatedWidth);
+    const svgHeight = Math.max(sanitizedHeight, rotatedHeight);
+    const centerX = svgWidth / 2;
+    const centerY = svgHeight / 2;
+    const svg2 = `<svg xmlns="http://www.w3.org/2000/svg" width="${svgWidth}" height="${svgHeight}" viewBox="0 0 ${svgWidth} ${svgHeight}">
+  <text
+    x="${centerX}"
+    y="${centerY}"
+    text-anchor="middle"
+    dominant-baseline="middle"
+    font-family="${fontFamily2}"
+    font-size="${sanitizedFontSize}px"
+    font-weight="bold"
+    fill="${color2}"
+    opacity="${opacity}"
+    transform="rotate(${sanitizedRotation} ${centerX} ${centerY})">${escapeXml(text2)}</text>
+</svg>`;
+    return {
+      dataUri: `data:image/svg+xml,${encodeURIComponent(svg2)}`,
+      svgWidth,
+      svgHeight
+    };
+  }
+  function escapeXml(text2) {
+    return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  function parseVmlStyle(style2) {
+    const result = {};
+    if (!style2) return result;
+    const declarations = style2.split(";").filter((s2) => s2.trim());
+    for (const decl of declarations) {
+      const colonIndex = decl.indexOf(":");
+      if (colonIndex === -1) continue;
+      const prop = decl.substring(0, colonIndex).trim();
+      const value = decl.substring(colonIndex + 1).trim();
+      if (prop && value) {
+        result[prop] = value;
+      }
+    }
+    return result;
+  }
   function convertToPixels(value) {
     if (typeof value === "number") return value;
     if (!value || typeof value !== "string") return 0;
@@ -35610,9 +35969,13 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       if (textbox) {
         return { type: "shapeContainer", handler: handleShapeTextboxImport };
       }
+      const textpath = shape.elements?.find((el) => el.name === "v:textpath");
+      if (textpath) {
+        return { type: "image", handler: handleShapeTextWatermarkImport };
+      }
       const imagedata = shape.elements?.find((el) => el.name === "v:imagedata");
       if (imagedata) {
-        return { type: "image", handler: handleShapeImageImport };
+        return { type: "image", handler: handleShapeImageWatermarkImport };
       }
     }
     return { type: "unknown", handler: null };
@@ -35712,7 +36075,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     return wrapTextInRun(pict);
   }
-  function translateVmlWatermark(params2) {
+  function translateImageWatermark(params2) {
     const { node: node2 } = params2;
     const { attrs } = node2;
     if (attrs.vmlAttributes && attrs.vmlImagedata) {
@@ -35742,7 +36105,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
       return par2;
     }
-    const style2 = buildVmlStyle(attrs);
+    const style2 = buildVmlStyle$1(attrs);
     const shape = {
       name: "v:shape",
       attributes: {
@@ -35777,23 +36140,23 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     return par;
   }
-  function buildVmlStyle(attrs) {
+  function buildVmlStyle$1(attrs) {
     const styles = [];
     styles.push("position:absolute");
     if (attrs.size) {
       if (attrs.size.width) {
-        styles.push(`width:${convertToPt(attrs.size.width)}pt`);
+        styles.push(`width:${convertToPt$1(attrs.size.width)}pt`);
       }
       if (attrs.size.height) {
-        styles.push(`height:${convertToPt(attrs.size.height)}pt`);
+        styles.push(`height:${convertToPt$1(attrs.size.height)}pt`);
       }
     }
     if (attrs.marginOffset) {
       if (attrs.marginOffset.horizontal !== void 0) {
-        styles.push(`margin-left:${convertToPt(attrs.marginOffset.horizontal)}pt`);
+        styles.push(`margin-left:${convertToPt$1(attrs.marginOffset.horizontal)}pt`);
       }
       if (attrs.marginOffset.top !== void 0) {
-        styles.push(`margin-top:${convertToPt(attrs.marginOffset.top)}pt`);
+        styles.push(`margin-top:${convertToPt$1(attrs.marginOffset.top)}pt`);
       }
     }
     if (attrs.wrap?.attrs?.behindDoc) {
@@ -35817,9 +36180,215 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     styles.push("mso-height-percent:0");
     return styles.join(";");
   }
-  function convertToPt(pixels) {
+  function convertToPt$1(pixels) {
     return pixels * 72 / 96;
   }
+  function translateTextWatermark(params2) {
+    const { node: node2 } = params2;
+    const { attrs } = node2;
+    const text2 = attrs.textWatermarkData?.text || attrs.vmlTextpathAttributes?.string || "";
+    if (attrs.vmlAttributes && attrs.vmlTextpathAttributes) {
+      const shapeElements2 = [];
+      if (attrs.vmlPathAttributes) {
+        shapeElements2.push({
+          name: "v:path",
+          attributes: attrs.vmlPathAttributes
+        });
+      }
+      shapeElements2.push({
+        name: "v:textpath",
+        attributes: {
+          ...attrs.vmlTextpathAttributes,
+          string: text2
+        }
+      });
+      if (attrs.vmlFillAttributes && Object.keys(attrs.vmlFillAttributes).length > 0) {
+        shapeElements2.push({
+          name: "v:fill",
+          attributes: attrs.vmlFillAttributes
+        });
+      }
+      if (attrs.vmlStrokeAttributes && Object.keys(attrs.vmlStrokeAttributes).length > 0) {
+        shapeElements2.push({
+          name: "v:stroke",
+          attributes: attrs.vmlStrokeAttributes
+        });
+      }
+      if (attrs.vmlWrapAttributes) {
+        shapeElements2.push({
+          name: "w10:wrap",
+          attributes: attrs.vmlWrapAttributes
+        });
+      }
+      const shape2 = {
+        name: "v:shape",
+        attributes: attrs.vmlAttributes,
+        elements: shapeElements2
+      };
+      const pict2 = {
+        name: "w:pict",
+        elements: [shape2]
+      };
+      const par2 = {
+        name: "w:p",
+        elements: [wrapTextInRun(pict2)]
+      };
+      return par2;
+    }
+    const wmData = attrs.textWatermarkData || {};
+    const style2 = buildVmlStyle(attrs, wmData);
+    const textpathStyle = buildTextpathStyle(wmData);
+    const shapeElements = [];
+    shapeElements.push({
+      name: "v:path",
+      attributes: {
+        textpathok: "t"
+      }
+    });
+    shapeElements.push({
+      name: "v:textpath",
+      attributes: {
+        on: "t",
+        fitshape: "t",
+        string: text2,
+        style: textpathStyle,
+        ...wmData.textpath?.trim !== void 0 && { trim: wmData.textpath.trim ? "t" : "f" }
+      }
+    });
+    const fillAttrs = {};
+    const fill = wmData.fill || attrs.fill;
+    if (fill) {
+      if (fill.type) fillAttrs.type = fill.type;
+      if (fill.color2) fillAttrs.color2 = fill.color2;
+      if (fill.opacity !== void 0) fillAttrs.opacity = fill.opacity.toString();
+      if (fill.detectmouseclick !== void 0) {
+        fillAttrs["o:detectmouseclick"] = fill.detectmouseclick ? "t" : "f";
+      }
+    }
+    if (Object.keys(fillAttrs).length > 0) {
+      shapeElements.push({
+        name: "v:fill",
+        attributes: fillAttrs
+      });
+    }
+    const stroke = wmData.stroke || attrs.stroke;
+    if (stroke && stroke.enabled !== false) {
+      const strokeAttrs = {};
+      if (stroke.color) strokeAttrs.color = stroke.color;
+      if (stroke.joinstyle) strokeAttrs.joinstyle = stroke.joinstyle;
+      if (stroke.endcap) strokeAttrs.endcap = stroke.endcap;
+      if (Object.keys(strokeAttrs).length > 0) {
+        shapeElements.push({
+          name: "v:stroke",
+          attributes: strokeAttrs
+        });
+      }
+    }
+    shapeElements.push({
+      name: "w10:wrap",
+      attributes: {
+        type: attrs.wrap?.type?.toLowerCase() || "none"
+      }
+    });
+    const shape = {
+      name: "v:shape",
+      attributes: {
+        id: `PowerPlusWaterMarkObject${generateRandomSigned32BitIntStrId().replace("-", "")}`,
+        "o:spid": `shape_${Math.floor(Math.random() * 1e4)}`,
+        type: "#_x0000_t136",
+        style: style2,
+        fillcolor: fill?.color || "silver",
+        stroked: stroke?.enabled !== false ? "t" : "f",
+        "o:allowincell": "f",
+        ...attrs.vmlAttributes?.adj && { adj: attrs.vmlAttributes.adj }
+      },
+      elements: shapeElements
+    };
+    const pict = {
+      name: "w:pict",
+      elements: [shape]
+    };
+    const par = {
+      name: "w:p",
+      elements: [wrapTextInRun(pict)]
+    };
+    return par;
+  }
+  function buildVmlStyle(attrs, wmData) {
+    const styles = [];
+    styles.push("position:absolute");
+    if (attrs.marginOffset) {
+      if (attrs.marginOffset.horizontal !== void 0) {
+        styles.push(`margin-left:${convertToPt(attrs.marginOffset.horizontal)}pt`);
+      }
+      if (attrs.marginOffset.top !== void 0) {
+        styles.push(`margin-top:${convertToPt(attrs.marginOffset.top)}pt`);
+      }
+    } else {
+      styles.push("margin-left:0.05pt");
+      styles.push("margin-top:315.7pt");
+    }
+    if (attrs.size) {
+      if (attrs.size.width) {
+        styles.push(`width:${convertToPt(attrs.size.width)}pt`);
+      }
+      if (attrs.size.height) {
+        styles.push(`height:${convertToPt(attrs.size.height)}pt`);
+      }
+    }
+    const wrapType = attrs.wrap?.type;
+    let msoWrapStyle = "none";
+    if (wrapType) {
+      const wrapTypeLower = wrapType.toLowerCase();
+      if (wrapTypeLower === "topandbottom") {
+        msoWrapStyle = "top-and-bottom";
+      } else if (["square", "tight", "through"].includes(wrapTypeLower)) {
+        msoWrapStyle = wrapTypeLower;
+      }
+    }
+    styles.push(`mso-wrap-style:${msoWrapStyle}`);
+    const textAnchor = wmData.textStyle?.textAnchor || attrs.textStyle?.textAnchor;
+    if (textAnchor) {
+      styles.push(`v-text-anchor:${textAnchor}`);
+    }
+    const rotation = wmData.rotation || attrs.rotation;
+    if (rotation !== void 0 && rotation !== 0) {
+      styles.push(`rotation:${rotation}`);
+    }
+    if (attrs.anchorData) {
+      if (attrs.anchorData.alignH) {
+        styles.push(`mso-position-horizontal:${attrs.anchorData.alignH}`);
+      }
+      if (attrs.anchorData.alignV) {
+        styles.push(`mso-position-vertical:${attrs.anchorData.alignV}`);
+      }
+      if (attrs.anchorData.hRelativeFrom) {
+        styles.push(`mso-position-horizontal-relative:${attrs.anchorData.hRelativeFrom}`);
+      }
+      if (attrs.anchorData.vRelativeFrom) {
+        styles.push(`mso-position-vertical-relative:${attrs.anchorData.vRelativeFrom}`);
+      }
+    }
+    return styles.join(";");
+  }
+  function buildTextpathStyle(wmData) {
+    const styles = [];
+    if (wmData.textStyle) {
+      if (wmData.textStyle.fontFamily) {
+        styles.push(`font-family:"${wmData.textStyle.fontFamily}"`);
+      }
+      if (wmData.textStyle.fontSize) {
+        styles.push(`font-size:${wmData.textStyle.fontSize}`);
+      }
+    }
+    return styles.join(";");
+  }
+  function convertToPt(pixels) {
+    if (typeof pixels === "number") {
+      return pixels * 72 / 96;
+    }
+    return parseFloat(pixels) || 0;
+  }
   const XML_NODE_NAME = "w:pict";
   const SD_NODE_NAME = ["shapeContainer", "contentBlock", "image"];
   const validXmlAttributes = [];
@@ -35847,7 +36416,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       contentBlock: () => translateContentBlock(params2),
       image: () => {
         if (node2.attrs?.vmlWatermark) {
-          return translateVmlWatermark(params2);
+          if (node2.attrs?.vmlTextWatermark) {
+            return translateTextWatermark(params2);
+          }
+          return translateImageWatermark(params2);
         }
         return null;
       },
@@ -36992,7 +37564,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.5.0-next.5") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.5.0-next.7") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -62875,7 +63447,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.5.0-next.5";
+  const summaryVersion = "1.5.0-next.7";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -65533,7 +66105,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.5.0-next.5");
+      console.debug("[checkVersionMigrations] Current editor version", "1.5.0-next.7");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -91008,7 +91580,14 @@ ${o}
     definitions: {},
     abstracts: {}
   };
-  const ooxmlResolver = createOoxmlResolver({ pPr: translator$14, rPr: translator$1O });
+  const toOoxmlTranslator = (translator2) => ({
+    xmlName: translator2.xmlName,
+    encode: (params2) => translator2.encode(params2)
+  });
+  const ooxmlResolver = createOoxmlResolver({
+    pPr: toOoxmlTranslator(translator$14),
+    rPr: toOoxmlTranslator(translator$1O)
+  });
   const hydrateParagraphStyleAttrs = (para, context, preResolved) => {
     if (!hasParagraphStyleContext(context)) {
       return null;
@@ -146937,7 +147516,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.5.0-next.5";
+      this.version = "1.5.0-next.7";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;