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

package/dist/chunks/{PdfViewer-DICnVjkl.es.js → PdfViewer-ClST5VR6.es.js}

@@ -1,6 +1,6 @@
 import { d as defineComponent, h, T as Transition, p as process$1, w as watchEffect, c as computed, r as ref, f as onMounted, X as onUnmounted, E as createElementBlock, G as openBlock, K as createBaseVNode, M as createCommentVNode, I as createVNode, v as unref } from "./vue-BnBKJwCW.es.js";
-import { N as NBaseLoading, u as useSuperdocStore, s as storeToRefs, a as useSelection } from "./index-BhJCVQFg.es.js";
-import { C as derived, r as c, q as cB, aF as fadeInTransition, y as cM, I as warnOnce, J as useConfig, N as useTheme, aG as pxfy, P as createKey, Q as useThemeClass, aH as useCompitable, ai as _export_sfc } from "./index-BgZnM0Uj.es.js";
+import { N as NBaseLoading, u as useSuperdocStore, s as storeToRefs, a as useSelection } from "./index-bw_yQ0EP.es.js";
+import { C as derived, r as c, q as cB, aF as fadeInTransition, y as cM, I as warnOnce, J as useConfig, N as useTheme, aG as pxfy, P as createKey, Q as useThemeClass, aH as useCompitable, ai as _export_sfc } from "./index-7ebfCUN0.es.js";
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{PdfViewer-Bm3aYkue.cjs → PdfViewer-Cli6IR-X.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("./vue-De9wkgLl.cjs");
-const superdoc = require("./index-RKdc-5FM.cjs");
-const index = require("./index-224wdSXe.cjs");
+const superdoc = require("./index-CbbEjpJ0.cjs");
+const index = require("./index-LpMObyDy.cjs");
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{SuperConverter-Cih2T-NE.cjs → SuperConverter-CIjArITT.cjs}

@@ -3643,6 +3643,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",
@@ -19266,9 +19271,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];
@@ -30127,7 +30132,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");
@@ -30153,7 +30158,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 = {
@@ -30199,12 +30204,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 },
@@ -30220,7 +30225,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());
@@ -30232,6 +30237,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;
@@ -30276,9 +30542,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 };
@@ -30378,7 +30648,7 @@ function translateVRectContentBlock(params) {
   };
   return wrapTextInRun(pict);
 }
-function translateVmlWatermark(params) {
+function translateImageWatermark(params) {
   const { node } = params;
   const { attrs } = node;
   if (attrs.vmlAttributes && attrs.vmlImagedata) {
@@ -30408,7 +30678,7 @@ function translateVmlWatermark(params) {
     };
     return par2;
   }
-  const style = buildVmlStyle(attrs);
+  const style = buildVmlStyle$1(attrs);
   const shape = {
     name: "v:shape",
     attributes: {
@@ -30443,23 +30713,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) {
@@ -30483,9 +30753,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 = [];
@@ -30513,7 +30989,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;
     },
@@ -31658,7 +32137,7 @@ class SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.5.0-next.6") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.5.0-next.7") {
     return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**
@@ -32367,8 +32846,8 @@ exports.registeredHandlers = registeredHandlers;
 exports.replaceStep = replaceStep;
 exports.resolveDocxFontFamily = resolveDocxFontFamily;
 exports.resolveRunProperties = resolveRunProperties;
-exports.translator = translator$14;
-exports.translator$1 = translator$1O;
+exports.translator = translator$1O;
+exports.translator$1 = translator$14;
 exports.unflattenListsInHtml = unflattenListsInHtml;
 exports.updateNumberingProperties = updateNumberingProperties;
 exports.wrapTextsInRuns = wrapTextsInRuns;