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

package/dist/chunks/{SuperConverter-BYBgTS6T.es.js → SuperConverter-S5AfMnkn.es.js}

@@ -3642,6 +3642,11 @@ const DEFAULT_DOCX_DEFS = {
   "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",
@@ -10086,6 +10091,11 @@ const SD_NODE_NAME$g = "tableRow";
 const validXmlAttributes$9 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
+const getColspan$1 = (cell) => {
+  const rawColspan = cell?.attrs?.colspan;
+  const numericColspan = typeof rawColspan === "string" ? parseInt(rawColspan, 10) : rawColspan;
+  return Number.isFinite(numericColspan) && numericColspan > 0 ? numericColspan : 1;
+};
 const encode$v = (params, encodedAttrs) => {
   const { row } = params.extraParams;
   let tableRowProperties = {};
@@ -10218,7 +10228,27 @@ const decode$x = (params, decodedAttrs) => {
     }
     return cell;
   });
-  const trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+  let trimmedContent = sanitizedCells.filter((_2, index2) => !isPlaceholderCell(trimmedSlice[index2]));
+  const preferTableGrid = params.extraParams?.preferTableGrid === true;
+  const totalColumns = params.extraParams?.totalColumns;
+  if (preferTableGrid && typeof totalColumns === "number" && Number.isFinite(totalColumns) && totalColumns > 0) {
+    const rawGridBefore = node.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 cell of trimmedContent) {
+      const colspan = getColspan$1(cell);
+      if (usedColumns + colspan > availableColumns) {
+        break;
+      }
+      constrainedCells.push(cell);
+      usedColumns += colspan;
+    }
+    trimmedContent = constrainedCells;
+  }
   const translateParams = {
     ...params,
     node: { ...node, content: trimmedContent }
@@ -19240,9 +19270,9 @@ function handleImageNode(node, params, isAnchor) {
   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];
@@ -25963,6 +25993,53 @@ const config$d = {
   attributes: validXmlAttributes$5
 };
 const translator$s = NodeTranslator.from(config$d);
+const getColspan = (cell) => {
+  const rawColspan = cell?.attrs?.colspan;
+  const numericColspan = typeof rawColspan === "string" ? parseInt(rawColspan, 10) : rawColspan;
+  return Number.isFinite(numericColspan) && numericColspan > 0 ? numericColspan : 1;
+};
+const resolveGridBefore = (row) => {
+  const rawGridBefore = row?.attrs?.tableRowProperties?.gridBefore ?? row?.attrs?.gridBefore;
+  const numericGridBefore = typeof rawGridBefore === "string" ? parseInt(rawGridBefore, 10) : rawGridBefore;
+  if (!Number.isFinite(numericGridBefore) || numericGridBefore <= 0) return 0;
+  const cells = Array.isArray(row.content) ? row.content : [];
+  let leadingGridBefore = 0;
+  while (leadingGridBefore < cells.length && cells[leadingGridBefore]?.attrs?.__placeholder === "gridBefore") {
+    leadingGridBefore += 1;
+  }
+  return leadingGridBefore > 0 ? 0 : numericGridBefore;
+};
+const advanceColumnsForCell = (columnIndex, cell) => columnIndex + getColspan(cell);
+const getCellStartColumn = (row, targetCell) => {
+  const cells = Array.isArray(row.content) ? row.content : [];
+  let columnIndex = resolveGridBefore(row);
+  for (const cell of cells) {
+    if (cell === targetCell) return columnIndex;
+    columnIndex = advanceColumnsForCell(columnIndex, cell);
+  }
+  return columnIndex;
+};
+const findCellCoveringColumn = (row, targetColumn) => {
+  const cells = Array.isArray(row.content) ? row.content : [];
+  let columnIndex = resolveGridBefore(row);
+  for (const cell of cells) {
+    const colspan = getColspan(cell);
+    if (targetColumn >= columnIndex && targetColumn < columnIndex + colspan) {
+      return cell;
+    }
+    columnIndex = advanceColumnsForCell(columnIndex, cell);
+  }
+  return null;
+};
+const findInsertionIndexForColumn = (row, targetColumn) => {
+  const cells = Array.isArray(row.content) ? row.content : [];
+  let columnIndex = resolveGridBefore(row);
+  for (let index2 = 0; index2 < cells.length; index2++) {
+    if (columnIndex >= targetColumn) return index2;
+    columnIndex = advanceColumnsForCell(columnIndex, cells[index2]);
+  }
+  return cells.length;
+};
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -25978,15 +26055,17 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
       const cell = row.content[cellIndex];
       if (!cell) continue;
       const attrs = cell.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(row, cell);
       for (let offset = 1; offset < maxRowspan; offset++) {
         const rowToChange = rows[rowIndex + offset];
         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: cell.type,
@@ -25997,7 +26076,8 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
             continueMerge: true
           }
         };
-        rowToChange.content.splice(cellIndex, 0, mergedCell);
+        const insertionIndex = findInsertionIndexForColumn(rowToChange, startColumn);
+        rowToChange.content.splice(insertionIndex, 0, mergedCell);
       }
     }
   }
@@ -26149,15 +26229,24 @@ const encode$q = (params) => {
 const decode$s = (params) => {
   const { grid: rawGrid } = params.node.attrs || {};
   const grid = Array.isArray(rawGrid) ? rawGrid : [];
-  const { firstRow = {} } = params.extraParams || {};
+  const { firstRow = {}, preferTableGrid = false, totalColumns: requestedColumns } = params.extraParams || {};
   const cellNodes = firstRow.content?.filter((n) => n.type === "tableCell") ?? [];
-  const colWidthsFromCellNodes = cellNodes.flatMap((cell) => {
+  let colWidthsFromCellNodes = cellNodes.flatMap((cell) => {
     const spanCount = Math.max(1, cell?.attrs?.colspan ?? 1);
     const colwidth = cell.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(params, totalColumns, cellMinWidth);
   const elements = [];
   const pushColumn = (widthTwips, { enforceMinimum = false } = {}) => {
@@ -26417,22 +26506,31 @@ const encode$p = (params, encodedAttrs) => {
 const decode$r = (params, decodedAttrs) => {
   params.node = preProcessVerticalMergeCells(params.node, params);
   const { node } = params;
-  const elements = translateChildNodes(params);
+  const rawGrid = node.attrs?.grid;
+  const grid = Array.isArray(rawGrid) ? rawGrid : [];
+  const preferTableGrid = node.attrs?.userEdited !== true && grid.length > 0;
+  const totalColumns = preferTableGrid ? grid.length : void 0;
+  const extraParams = {
+    ...params.extraParams || {},
+    preferTableGrid,
+    totalColumns
+  };
+  const elements = translateChildNodes({ ...params, extraParams });
   const firstRow = node.content?.find((n) => n.type === "tableRow");
-  const properties = node.attrs.grid;
   const element = translator$c.decode({
     ...params,
-    node: { ...node, attrs: { ...node.attrs, grid: properties } },
+    node: { ...node, attrs: { ...node.attrs, grid } },
     extraParams: {
+      ...extraParams,
       firstRow
     }
   });
   if (element) elements.unshift(element);
   if (node.attrs?.tableProperties) {
-    const properties2 = { ...node.attrs.tableProperties };
+    const properties = { ...node.attrs.tableProperties };
     const element2 = translator$e.decode({
       ...params,
-      node: { ...node, attrs: { ...node.attrs, tableProperties: properties2 } }
+      node: { ...node, attrs: { ...node.attrs, tableProperties: properties } }
     });
     if (element2) elements.unshift(element2);
   }
@@ -30033,7 +30131,7 @@ function buildStyles(styleObject) {
   }
   return style;
 }
-function handleShapeImageImport({ params, pict }) {
+function handleShapeImageWatermarkImport({ params, 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");
@@ -30059,7 +30157,7 @@ function handleShapeImageImport({ params, pict }) {
   const targetPath = rel.attributes["Target"];
   const normalizedPath = normalizeTargetPath(targetPath);
   const style = shapeAttrs.style || "";
-  const styleObj = parseVmlStyle(style);
+  const styleObj = parseVmlStyle$1(style);
   const width = styleObj.width || "100px";
   const height = styleObj.height || "100px";
   const position = {
@@ -30105,12 +30203,12 @@ function handleShapeImageImport({ params, pict }) {
       },
       // Size
       size: {
-        width: convertToPixels(width),
-        height: convertToPixels(height)
+        width: convertToPixels$1(width),
+        height: convertToPixels$1(height)
       },
       marginOffset: {
-        horizontal: convertToPixels(position.marginLeft),
-        top: convertToPixels(position.marginTop)
+        horizontal: convertToPixels$1(position.marginLeft),
+        top: convertToPixels$1(position.marginTop)
       },
       // Image adjustments
       ...gain && { gain },
@@ -30126,7 +30224,7 @@ function normalizeTargetPath(targetPath = "") {
   if (trimmed.startsWith("media/")) return `word/${trimmed}`;
   return `word/${trimmed}`;
 }
-function parseVmlStyle(style) {
+function parseVmlStyle$1(style) {
   const result = {};
   if (!style) return result;
   const declarations = style.split(";").filter((s) => s.trim());
@@ -30138,6 +30236,267 @@ function parseVmlStyle(style) {
   }
   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 style = shapeAttrs.style || "";
+  const styleObj = parseVmlStyle(style);
+  const width = styleObj.width || "481.8pt";
+  const height = styleObj.height || "82.8pt";
+  const position = {
+    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 fontFamily = sanitizeFontFamily(rawFontFamily);
+  const fontSize = textStyleObj["font-size"] || "1pt";
+  const fitshape = textpathAttrs.fitshape || "t";
+  const trim = textpathAttrs.trim || "t";
+  const textpathOn = textpathAttrs.on || "t";
+  const path = shape.elements?.find((el) => el.name === "v:path");
+  const pathAttrs = path?.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,
+      fontSize
+    }
+  });
+  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: style,
+      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(position.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(position.marginTop)
+      },
+      // Store text watermark specific data for export
+      textWatermarkData: {
+        text: watermarkText,
+        rotation: sanitizedRotation,
+        textStyle: {
+          fontFamily,
+          fontSize,
+          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(fontFamily) {
+  if (!fontFamily || typeof fontFamily !== "string") {
+    return "Arial";
+  }
+  const sanitized = fontFamily.replace(/[^a-zA-Z0-9\s,\-]/g, "").trim();
+  return sanitized || "Arial";
+}
+function sanitizeColor(color, defaultColor = "silver") {
+  if (!color || typeof color !== "string") {
+    return defaultColor;
+  }
+  const sanitized = color.replace(/[^a-zA-Z0-9#%(),.]/g, "").trim();
+  return sanitized || defaultColor;
+}
+function sanitizeNumeric(value, defaultValue, min = -Infinity, max = Infinity) {
+  const num = typeof value === "number" ? value : parseFloat(value);
+  if (isNaN(num) || !isFinite(num)) {
+    return defaultValue;
+  }
+  return Math.max(min, Math.min(max, num));
+}
+function generateTextWatermarkSVG({ text, width, height, rotation, fill, textStyle }) {
+  let fontSize = 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";
+      fontSize = (unit === "pt" ? value * (96 / 72) : value) * 50;
+    }
+  }
+  fontSize = Math.max(fontSize, 48);
+  const color = sanitizeColor(fill?.color, "silver");
+  const opacity = sanitizeNumeric(fill?.opacity, 0.5, 0, 1);
+  const fontFamily = sanitizeFontFamily(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(fontSize, 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 svg = `<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="${fontFamily}"
+    font-size="${sanitizedFontSize}px"
+    font-weight="bold"
+    fill="${color}"
+    opacity="${opacity}"
+    transform="rotate(${sanitizedRotation} ${centerX} ${centerY})">${escapeXml(text)}</text>
+</svg>`;
+  return {
+    dataUri: `data:image/svg+xml,${encodeURIComponent(svg)}`,
+    svgWidth,
+    svgHeight
+  };
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function parseVmlStyle(style) {
+  const result = {};
+  if (!style) return result;
+  const declarations = style.split(";").filter((s) => s.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;
@@ -30182,9 +30541,13 @@ function pictNodeTypeStrategy(node) {
     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 };
@@ -30284,7 +30647,7 @@ function translateVRectContentBlock(params) {
   };
   return wrapTextInRun(pict);
 }
-function translateVmlWatermark(params) {
+function translateImageWatermark(params) {
   const { node } = params;
   const { attrs } = node;
   if (attrs.vmlAttributes && attrs.vmlImagedata) {
@@ -30314,7 +30677,7 @@ function translateVmlWatermark(params) {
     };
     return par2;
   }
-  const style = buildVmlStyle(attrs);
+  const style = buildVmlStyle$1(attrs);
   const shape = {
     name: "v:shape",
     attributes: {
@@ -30349,23 +30712,23 @@ function translateVmlWatermark(params) {
   };
   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) {
@@ -30389,9 +30752,215 @@ function buildVmlStyle(attrs) {
   styles.push("mso-height-percent:0");
   return styles.join(";");
 }
-function convertToPt(pixels) {
+function convertToPt$1(pixels) {
   return pixels * 72 / 96;
 }
+function translateTextWatermark(params) {
+  const { node } = params;
+  const { attrs } = node;
+  const text = 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: text
+      }
+    });
+    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 style = 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: text,
+      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,
+      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 = [];
@@ -30419,7 +30988,10 @@ function decode(params) {
     contentBlock: () => translateContentBlock(params),
     image: () => {
       if (node.attrs?.vmlWatermark) {
-        return translateVmlWatermark(params);
+        if (node.attrs?.vmlTextWatermark) {
+          return translateTextWatermark(params);
+        }
+        return translateImageWatermark(params);
       }
       return null;
     },
@@ -31564,7 +32136,7 @@ class SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.5.0-next.5") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.5.0-next.7") {
     return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**
@@ -32239,8 +32811,8 @@ export {
   SelectionRange as Z,
   Transform as _,
   createDocFromHTML as a,
-  translator$14 as a0,
-  translator$1O as a1,
+  translator$1O as a0,
+  translator$14 as a1,
   resolveDocxFontFamily as a2,
   combineIndentProperties as a3,
   _getReferencedTableStyles as a4,