@harbour-enterprises/superdoc 1.4.0-next.1 → 1.4.0-next.3

package/dist/chunks/{PdfViewer-H9_8IbtN.cjs → PdfViewer-BFLlmRke.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("./vue-De9wkgLl.cjs");
-const superdoc = require("./index-BdaseaBw.cjs");
-const index = require("./index-C3KRKogJ.cjs");
+const superdoc = require("./index-D3X3kMWD.cjs");
+const index = require("./index-C0kuhYCD.cjs");
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{PdfViewer-DRTk3dY6.es.js → PdfViewer-D859yVUF.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-BP9aFfwI.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-CEcYlysg.es.js";
+import { N as NBaseLoading, u as useSuperdocStore, s as storeToRefs, a as useSelection } from "./index-DF3OVaQj.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-B-20lDKU.es.js";
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{SuperConverter-CFRB4XNw.es.js → SuperConverter-MYkKoPrv.es.js}

@@ -19026,7 +19026,7 @@ function isMetafileExtension(extension) {
 const DRAWING_XML_TAG = "w:drawing";
 const SHAPE_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
 const GROUP_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup";
-const normalizeTargetPath = (targetPath = "") => {
+const normalizeTargetPath$1 = (targetPath = "") => {
   if (!targetPath) return targetPath;
   const trimmed = targetPath.replace(/^\/+/, "");
   if (trimmed.startsWith("word/")) return trimmed;
@@ -19185,7 +19185,14 @@ function handleImageNode(node, params, isAnchor) {
   }
   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];
+    return val != null && parseFloat(val) < 0;
+  });
   const shouldStretch = Boolean(stretch && fillRect);
+  const shouldCover = shouldStretch && !srcRectHasNegativeValues;
   const spPr = picture.elements.find((el) => el.name === "pic:spPr");
   if (spPr) {
     const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
@@ -19214,7 +19221,7 @@ function handleImageNode(node, params, isAnchor) {
   }
   const { attributes: relAttributes } = rel;
   const targetPath = relAttributes["Target"];
-  const path = normalizeTargetPath(targetPath);
+  const path = normalizeTargetPath$1(targetPath);
   const extension = path.substring(path.lastIndexOf(".") + 1);
   let finalSrc = path;
   let finalExtension = extension;
@@ -19262,7 +19269,7 @@ function handleImageNode(node, params, isAnchor) {
       wrapText: wrap2.attrs.wrapText
     } : {},
     wrapTopAndBottom: wrap2.type === "TopAndBottom",
-    shouldStretch,
+    shouldCover,
     originalPadding: {
       distT: attributes["distT"],
       distB: attributes["distB"],
@@ -19455,7 +19462,7 @@ const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset
     const { elements } = relationships || [];
     const rel = elements?.find((el) => el.attributes["Id"] === rEmbed);
     if (!rel) return null;
-    const targetPath = normalizeTargetPath(rel.attributes?.["Target"]);
+    const targetPath = normalizeTargetPath$1(rel.attributes?.["Target"]);
     const path = targetPath;
     const nvPicPr = pic.elements?.find((el) => el.name === "pic:nvPicPr");
     const cNvPr = nvPicPr?.elements?.find((el) => el.name === "pic:cNvPr");
@@ -29559,6 +29566,10 @@ function filterOutRootInlineNodes(content = []) {
     if (!node || typeof node.type !== "string") return;
     const type = node.type;
     const preservableNodeName = PRESERVABLE_INLINE_XML_NAMES[type];
+    if (type === "image" && node.attrs?.isAnchor) {
+      result.push(node);
+      return;
+    }
     if (!INLINE_TYPES.has(type)) {
       result.push(node);
     } else if (preservableNodeName) {
@@ -29752,6 +29763,137 @@ function buildStyles(styleObject) {
   }
   return style;
 }
+function handleShapeImageImport({ 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");
+  if (!imagedata) return null;
+  const { docx, filename } = params;
+  const shapeAttrs = shape.attributes || {};
+  const imagedataAttrs = imagedata.attributes || {};
+  const rId = imagedataAttrs["r:id"];
+  if (!rId) {
+    console.warn("v:imagedata missing r:id attribute");
+    return null;
+  }
+  const currentFile = filename || "document.xml";
+  let rels = docx[`word/_rels/${currentFile}.rels`];
+  if (!rels) rels = docx[`word/_rels/document.xml.rels`];
+  const relationships = rels?.elements?.find((el) => el.name === "Relationships");
+  const { elements } = relationships || [];
+  const rel = elements?.find((el) => el.attributes["Id"] === rId);
+  if (!rel) {
+    console.warn(`Relationship not found for r:id="${rId}"`);
+    return null;
+  }
+  const targetPath = rel.attributes["Target"];
+  const normalizedPath = normalizeTargetPath(targetPath);
+  const style = shapeAttrs.style || "";
+  const styleObj = parseVmlStyle(style);
+  const width = styleObj.width || "100px";
+  const height = styleObj.height || "100px";
+  const position = {
+    type: styleObj.position || "absolute",
+    marginLeft: styleObj["margin-left"] || "0",
+    marginTop: styleObj["margin-top"] || "0"
+  };
+  const zIndex = styleObj["z-index"] ? parseInt(styleObj["z-index"], 10) : void 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 gain = imagedataAttrs["gain"];
+  const blacklevel = imagedataAttrs["blacklevel"];
+  const title = imagedataAttrs["o:title"] || "Watermark";
+  const imageNode = {
+    type: "image",
+    attrs: {
+      src: normalizedPath,
+      alt: title,
+      extension: normalizedPath.substring(normalizedPath.lastIndexOf(".") + 1),
+      title,
+      rId,
+      // Store VML-specific attributes for round-trip
+      vmlWatermark: true,
+      vmlStyle: style,
+      vmlAttributes: shapeAttrs,
+      vmlImagedata: imagedataAttrs,
+      // Positioning
+      isAnchor: true,
+      inline: false,
+      wrap: {
+        type: "None",
+        attrs: {
+          behindDoc: Number.isFinite(zIndex) ? zIndex < 0 : true
+        }
+      },
+      anchorData: {
+        hRelativeFrom: hRelativeTo,
+        vRelativeFrom: vRelativeTo,
+        alignH: hPosition,
+        alignV: vPosition
+      },
+      // Size
+      size: {
+        width: convertToPixels(width),
+        height: convertToPixels(height)
+      },
+      marginOffset: {
+        horizontal: convertToPixels(position.marginLeft),
+        top: convertToPixels(position.marginTop)
+      },
+      // Image adjustments
+      ...gain && { gain },
+      ...blacklevel && { blacklevel }
+    }
+  };
+  return imageNode;
+}
+function normalizeTargetPath(targetPath = "") {
+  if (!targetPath) return targetPath;
+  const trimmed = targetPath.replace(/^\/+/, "");
+  if (trimmed.startsWith("word/")) return trimmed;
+  if (trimmed.startsWith("media/")) return `word/${trimmed}`;
+  return `word/${trimmed}`;
+}
+function parseVmlStyle(style) {
+  const result = {};
+  if (!style) return result;
+  const declarations = style.split(";").filter((s) => s.trim());
+  for (const decl of declarations) {
+    const [prop, value] = decl.split(":").map((s) => s.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;
+  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 pictNodeTypeStrategy(node) {
   const shape = node.elements?.find((el) => el.name === "v:shape");
   const group = node.elements?.find((el) => el.name === "v:group");
@@ -29770,6 +29912,10 @@ function pictNodeTypeStrategy(node) {
     if (textbox) {
       return { type: "shapeContainer", handler: handleShapeTextboxImport };
     }
+    const imagedata = shape.elements?.find((el) => el.name === "v:imagedata");
+    if (imagedata) {
+      return { type: "image", handler: handleShapeImageImport };
+    }
   }
   return { type: "unknown", handler: null };
 }
@@ -29868,8 +30014,116 @@ function translateVRectContentBlock(params) {
   };
   return wrapTextInRun(pict);
 }
+function translateVmlWatermark(params) {
+  const { node } = params;
+  const { attrs } = node;
+  if (attrs.vmlAttributes && attrs.vmlImagedata) {
+    const shape2 = {
+      name: "v:shape",
+      attributes: attrs.vmlAttributes,
+      elements: [
+        {
+          name: "v:imagedata",
+          attributes: {
+            ...attrs.vmlImagedata,
+            "r:id": attrs.rId
+          }
+        }
+      ]
+    };
+    const pict2 = {
+      name: "w:pict",
+      attributes: {
+        "w14:anchorId": generateRandomSigned32BitIntStrId()
+      },
+      elements: [shape2]
+    };
+    const par2 = {
+      name: "w:p",
+      elements: [wrapTextInRun(pict2)]
+    };
+    return par2;
+  }
+  const style = buildVmlStyle(attrs);
+  const shape = {
+    name: "v:shape",
+    attributes: {
+      id: `WordPictureWatermark${generateRandomSigned32BitIntStrId().replace("-", "")}`,
+      "o:spid": `_x0000_s${Math.floor(Math.random() * 1e4)}`,
+      type: "#_x0000_t75",
+      style,
+      "o:allowincell": "f"
+    },
+    elements: [
+      {
+        name: "v:imagedata",
+        attributes: {
+          "r:id": attrs.rId,
+          "o:title": attrs.title || attrs.alt || "Watermark",
+          ...attrs.gain && { gain: attrs.gain },
+          ...attrs.blacklevel && { blacklevel: attrs.blacklevel }
+        }
+      }
+    ]
+  };
+  const pict = {
+    name: "w:pict",
+    attributes: {
+      "w14:anchorId": generateRandomSigned32BitIntStrId()
+    },
+    elements: [shape]
+  };
+  const par = {
+    name: "w:p",
+    elements: [wrapTextInRun(pict)]
+  };
+  return par;
+}
+function buildVmlStyle(attrs) {
+  const styles = [];
+  styles.push("position:absolute");
+  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`);
+    }
+  }
+  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`);
+    }
+  }
+  if (attrs.wrap?.attrs?.behindDoc) {
+    styles.push("z-index:-251653120");
+  }
+  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}`);
+    }
+  }
+  styles.push("mso-width-percent:0");
+  styles.push("mso-height-percent:0");
+  return styles.join(";");
+}
+function convertToPt(pixels) {
+  return pixels * 72 / 96;
+}
 const XML_NODE_NAME = "w:pict";
-const SD_NODE_NAME = ["shapeContainer", "contentBlock"];
+const SD_NODE_NAME = ["shapeContainer", "contentBlock", "image"];
 const validXmlAttributes = [];
 function encode(params) {
   const { node, pNode } = params.extraParams;
@@ -29893,6 +30147,12 @@ function decode(params) {
     shapeContainer: () => translateShapeContainer(params),
     shapeTextbox: () => translateShapeTextbox(params),
     contentBlock: () => translateContentBlock(params),
+    image: () => {
+      if (node.attrs?.vmlWatermark) {
+        return translateVmlWatermark(params);
+      }
+      return null;
+    },
     default: () => null
   };
   const decoder = types[node.type] ?? types.default;
@@ -31008,7 +31268,7 @@ class SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.4.0-next.1") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.4.0-next.3") {
     return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**