docgen-utils 1.0.22 → 1.0.24

package/dist/bundle.js

@@ -26853,6 +26853,7 @@ var docgen = (() => {
     exportPptx: () => exportPptx,
     importDocx: () => importDocx,
     importPptx: () => importPptx,
+    parseSlideHtml: () => parseSlideHtml,
     transformHtmlForPptx: () => transformHtmlForPptx
   });
 
@@ -65552,6 +65553,31 @@ ${generateStylesCss(styleMap, themeFonts)}
     }
     return null;
   }
+  function extractTranslation(computed) {
+    const transform = computed.transform;
+    if (!transform || transform === "none")
+      return null;
+    const matrix2dMatch = transform.match(/matrix\(([-\d.e]+),\s*([-\d.e]+),\s*([-\d.e]+),\s*([-\d.e]+),\s*([-\d.e]+),\s*([-\d.e]+)\)/);
+    if (matrix2dMatch) {
+      const tx = parseFloat(matrix2dMatch[5]);
+      const ty = parseFloat(matrix2dMatch[6]);
+      if (tx !== 0 || ty !== 0) {
+        return { x: tx, y: ty };
+      }
+    }
+    const matrix3dMatch = transform.match(/matrix3d\(([^)]+)\)/);
+    if (matrix3dMatch) {
+      const values = matrix3dMatch[1].split(",").map((v) => parseFloat(v.trim()));
+      if (values.length >= 14) {
+        const tx = values[12];
+        const ty = values[13];
+        if (tx !== 0 || ty !== 0) {
+          return { x: tx, y: ty };
+        }
+      }
+    }
+    return null;
+  }
   function getEffectiveOpacity(el, win) {
     let opacity = 1;
     let node = el;
@@ -66543,7 +66569,7 @@ ${generateStylesCss(styleMap, themeFonts)}
           pHeight = parentRect.height;
         }
       }
-      if (pWidth < 1 || pHeight < 1)
+      if (pWidth < 0.5 || pHeight < 0.5)
         continue;
       let pLeft = parseFloat(pComputed.left);
       let pTop = parseFloat(pComputed.top);
@@ -66648,8 +66674,11 @@ ${generateStylesCss(styleMap, themeFonts)}
         borderOffsetLeft = parseFloat(parentComputedForBorder.borderLeftWidth) || 0;
         borderOffsetTop = parseFloat(parentComputedForBorder.borderTopWidth) || 0;
       }
-      const absLeft = parentRect.left + pLeft + borderOffsetLeft;
-      const absTop = parentRect.top + pTop + borderOffsetTop;
+      const translation = extractTranslation(pComputed);
+      const transformOffsetX = translation?.x ?? 0;
+      const transformOffsetY = translation?.y ?? 0;
+      const absLeft = parentRect.left + pLeft + borderOffsetLeft + transformOffsetX;
+      const absTop = parentRect.top + pTop + borderOffsetTop + transformOffsetY;
       const hasBg = pComputed.backgroundColor && pComputed.backgroundColor !== "rgba(0, 0, 0, 0)";
       const bgImage = pComputed.backgroundImage;
       const hasGradient = bgImage && bgImage !== "none" && (bgImage.includes("linear-gradient") || bgImage.includes("radial-gradient"));
@@ -66854,7 +66883,18 @@ ${generateStylesCss(styleMap, themeFonts)}
             const transformStr = computed.textTransform;
             textTransform = (text) => applyTextTransform2(text, transformStr);
           }
+          const runsBeforeRecurse = runs.length;
+          const hadPendingSoftBreak = pendingSoftBreak;
+          if (pendingSoftBreak) {
+            pendingSoftBreak = false;
+          }
           parseInlineFormatting(el, options, runs, textTransform, win);
+          if (hadPendingSoftBreak && runs.length > runsBeforeRecurse) {
+            runs[runsBeforeRecurse].options = {
+              ...runs[runsBeforeRecurse].options,
+              softBreakBefore: true
+            };
+          }
         }
         prevNodeIsText = false;
       }
@@ -67134,6 +67174,28 @@ ${generateStylesCss(styleMap, themeFonts)}
           const imgEl = el;
           const natW = imgEl.naturalWidth;
           const natH = imgEl.naturalHeight;
+          let objectPosition;
+          const objPos = imgComputed.objectPosition;
+          if (objPos && objectFit === "cover") {
+            const parts = objPos.trim().split(/\s+/);
+            const parseFraction = (val, dimension) => {
+              if (val.endsWith("%")) {
+                return parseFloat(val) / 100;
+              }
+              const px = parseFloat(val);
+              if (!isNaN(px) && dimension > 0) {
+                return px / dimension;
+              }
+              return 0.5;
+            };
+            const displayW = wasClipped ? clippedW : rect2.width;
+            const displayH = wasClipped ? clippedH : rect2.height;
+            const xFrac = parts.length >= 1 ? parseFraction(parts[0], displayW) : 0.5;
+            const yFrac = parts.length >= 2 ? parseFraction(parts[1], displayH) : xFrac;
+            if (Math.abs(xFrac - 0.5) > 1e-3 || Math.abs(yFrac - 0.5) > 1e-3) {
+              objectPosition = [xFrac, yFrac];
+            }
+          }
           const imageElement = {
             type: isFullSlideImage ? "slideBackgroundImage" : "image",
             src: imgSrc,
@@ -67145,10 +67207,13 @@ ${generateStylesCss(styleMap, themeFonts)}
             },
             sizing: objectFit === "cover" ? { type: "cover" } : null
           };
-          if (objectFit === "cover" && natW > 0 && natH > 0 && !isFullSlideImage) {
+          if (objectFit === "cover" && natW > 0 && natH > 0) {
             imageElement.naturalWidth = natW;
             imageElement.naturalHeight = natH;
           }
+          if (objectPosition) {
+            imageElement.objectPosition = objectPosition;
+          }
           if (imgRectRadius !== null) {
             imageElement.rectRadius = imgRectRadius;
           }
@@ -67576,8 +67641,21 @@ ${generateStylesCss(styleMap, themeFonts)}
             const textTagSet = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "H4", "H5", "H6", "SPAN"]);
             const allChildren = Array.from(el.children);
             const textChildren = allChildren.filter((child) => {
-              if (textTagSet.has(child.tagName))
+              if (textTagSet.has(child.tagName)) {
+                if (child.tagName === "SPAN") {
+                  const spanComputed = win.getComputedStyle(child);
+                  const spanHasBg = spanComputed.backgroundColor && spanComputed.backgroundColor !== "rgba(0, 0, 0, 0)";
+                  const spanHasBorder = (parseFloat(spanComputed.borderTopWidth) || 0) > 0 || (parseFloat(spanComputed.borderRightWidth) || 0) > 0 || (parseFloat(spanComputed.borderBottomWidth) || 0) > 0 || (parseFloat(spanComputed.borderLeftWidth) || 0) > 0;
+                  const spanHasGradient = spanComputed.backgroundImage && spanComputed.backgroundImage !== "none" && (spanComputed.backgroundImage.includes("linear-gradient") || spanComputed.backgroundImage.includes("radial-gradient"));
+                  const spanBgClip = spanComputed.webkitBackgroundClip || spanComputed.backgroundClip;
+                  const spanTextFillColor = spanComputed.webkitTextFillColor;
+                  const isGradientText = spanBgClip === "text" && (spanTextFillColor === "transparent" || spanTextFillColor === "rgba(0, 0, 0, 0)" || spanTextFillColor && spanTextFillColor.includes("rgba") && spanTextFillColor.endsWith(", 0)"));
+                  if ((spanHasBg || spanHasBorder || spanHasGradient) && !isGradientText) {
+                    return false;
+                  }
+                }
                 return true;
+              }
               if (child.tagName === "DIV") {
                 const childComputed = win.getComputedStyle(child);
                 const childDisplay = childComputed.display;
@@ -67678,7 +67756,9 @@ ${generateStylesCss(styleMap, themeFonts)}
               }
             }
             const hasDirectText = directTextContent.length > 0;
-            const shouldMergeText = hasTextChildren && (isSingleTextChild || nonTextChildren.length === 0) || hasDirectText;
+            const isParentFlexRow = isFlexContainer2 && (computed2.flexDirection === "row" || computed2.flexDirection === "row-reverse" || !computed2.flexDirection) && allChildren.length > 1;
+            const isParentGrid = display === "grid" || display === "inline-grid";
+            const shouldMergeText = !isParentFlexRow && !isParentGrid && (hasTextChildren && (isSingleTextChild || nonTextChildren.length === 0) || hasDirectText);
             if (shouldMergeText) {
               if (isSingleTextChild) {
                 const textEl = textChildren[0];
@@ -68055,10 +68135,34 @@ ${generateStylesCss(styleMap, themeFonts)}
             const plainDivChildCount = el.children.length;
             const isPlainDivFlexRow = (plainDivDisplay === "flex" || plainDivDisplay === "inline-flex") && (plainDivFlexDir === "row" || plainDivFlexDir === "row-reverse") && plainDivChildCount > 1;
             const isPlainDivGrid = plainDivDisplay === "grid" || plainDivDisplay === "inline-grid";
-            const allChildrenAreInlineText = !isPlainDivFlexRow && !isPlainDivGrid && (childElements.length === 0 || childElements.every((ce) => inlineTextTagsSet.has(ce.tagName.toUpperCase())));
+            const isInlineTextChild = (ce) => {
+              const tagName19 = ce.tagName.toUpperCase();
+              if (!inlineTextTagsSet.has(tagName19))
+                return false;
+              if (tagName19 === "SPAN" || tagName19 === "A") {
+                const ceComputed = win.getComputedStyle(ce);
+                const ceHasBg = ceComputed.backgroundColor && ceComputed.backgroundColor !== "rgba(0, 0, 0, 0)";
+                const ceHasBorder = (parseFloat(ceComputed.borderTopWidth) || 0) > 0 || (parseFloat(ceComputed.borderRightWidth) || 0) > 0 || (parseFloat(ceComputed.borderBottomWidth) || 0) > 0 || (parseFloat(ceComputed.borderLeftWidth) || 0) > 0;
+                const ceHasGradient = ceComputed.backgroundImage && ceComputed.backgroundImage !== "none" && (ceComputed.backgroundImage.includes("linear-gradient") || ceComputed.backgroundImage.includes("radial-gradient"));
+                const ceBgClip = ceComputed.webkitBackgroundClip || ceComputed.backgroundClip;
+                const ceTextFillColor = ceComputed.webkitTextFillColor;
+                const isGradientText = ceBgClip === "text" && (ceTextFillColor === "transparent" || ceTextFillColor === "rgba(0, 0, 0, 0)" || ceTextFillColor && ceTextFillColor.includes("rgba") && ceTextFillColor.endsWith(", 0)"));
+                if ((ceHasBg || ceHasBorder || ceHasGradient) && !isGradientText) {
+                  return false;
+                }
+              }
+              return true;
+            };
+            const allChildrenAreInlineText = !isPlainDivFlexRow && !isPlainDivGrid && (childElements.length === 0 || childElements.every((ce) => isInlineTextChild(ce)));
             const structuralChildElements = childElements.filter((ce) => {
               const tagName19 = ce.tagName.toUpperCase();
-              return tagName19 !== "BR" && tagName19 !== "SVG" && !inlineTextTagsSet.has(tagName19);
+              if (tagName19 === "BR" || tagName19 === "SVG")
+                return false;
+              if (!inlineTextTagsSet.has(tagName19))
+                return true;
+              if (!isInlineTextChild(ce))
+                return true;
+              return false;
             });
             const hasStructuralChildren = structuralChildElements.length > 0;
             let extractedText = "";
@@ -68095,6 +68199,7 @@ ${generateStylesCss(styleMap, themeFonts)}
               const textTop = rect2.top;
               const textHeight = rect2.height;
               let textRuns;
+              const isFlexColumn = (plainDivDisplay === "flex" || plainDivDisplay === "inline-flex") && (plainDivFlexDir === "column" || plainDivFlexDir === "column-reverse") && childElements.length > 1;
               if (allChildrenAreInlineText && childElements.length > 0) {
                 const baseRunOptions = {
                   fontSize: pxToPoints(computed22.fontSize),
@@ -68109,7 +68214,44 @@ ${generateStylesCss(styleMap, themeFonts)}
                 if (computed22.textTransform && computed22.textTransform !== "none") {
                   textTransformFn = (text2) => applyTextTransform2(text2, computed22.textTransform);
                 }
-                textRuns = parseInlineFormatting(el, baseRunOptions, [], textTransformFn, win);
+                if (isFlexColumn) {
+                  textRuns = [];
+                  for (let ci = 0; ci < childElements.length; ci++) {
+                    const childEl = childElements[ci];
+                    const childComputed = win.getComputedStyle(childEl);
+                    const childText = getTransformedText(childEl, childComputed);
+                    if (!childText)
+                      continue;
+                    const transformedChildText = textTransformFn(childText);
+                    const childRunOptions = { ...baseRunOptions };
+                    const childFontSize = pxToPoints(childComputed.fontSize);
+                    if (childFontSize)
+                      childRunOptions.fontSize = childFontSize;
+                    const childFontFace = extractFontFace(childComputed.fontFamily);
+                    if (childFontFace)
+                      childRunOptions.fontFace = childFontFace;
+                    const childColor = rgbToHex(childComputed.color);
+                    if (childColor)
+                      childRunOptions.color = childColor;
+                    if (parseInt(childComputed.fontWeight) >= 600) {
+                      childRunOptions.bold = true;
+                    } else if (parseInt(childComputed.fontWeight) < 600) {
+                      childRunOptions.bold = false;
+                    }
+                    if (childComputed.fontStyle === "italic") {
+                      childRunOptions.italic = true;
+                    } else if (childComputed.fontStyle !== "italic") {
+                      childRunOptions.italic = false;
+                    }
+                    const childLs = extractLetterSpacing(childComputed);
+                    if (childLs !== null)
+                      childRunOptions.charSpacing = childLs;
+                    const textWithBreak = ci < childElements.length - 1 ? transformedChildText + "\n" : transformedChildText;
+                    textRuns.push({ text: textWithBreak, options: childRunOptions });
+                  }
+                } else {
+                  textRuns = parseInlineFormatting(el, baseRunOptions, [], textTransformFn, win);
+                }
                 if (textRuns.length === 0) {
                   textRuns = [{ text: extractedText, options: {} }];
                 }
@@ -68448,9 +68590,9 @@ ${generateStylesCss(styleMap, themeFonts)}
       elements.push(...pseudoElements);
     });
     doc.querySelectorAll("div").forEach((divEl) => {
+      const htmlDiv = divEl;
       if (processed.has(divEl))
         return;
-      const htmlDiv = divEl;
       if (htmlDiv === body)
         return;
       const rect = htmlDiv.getBoundingClientRect();
@@ -68473,6 +68615,29 @@ ${generateStylesCss(styleMap, themeFonts)}
     }
     return runs;
   }
+  function computeCoverCrop(naturalWidth, naturalHeight, boxW, boxH, objectPosition) {
+    const imgRatio = naturalHeight / naturalWidth;
+    const boxRatio = boxH / boxW;
+    const isBoxBased = boxRatio > imgRatio;
+    const effW = isBoxBased ? boxH / imgRatio : boxW;
+    const effH = isBoxBased ? boxH : boxW * imgRatio;
+    const [anchorX, anchorY] = objectPosition ?? [0.5, 0.5];
+    const excessW = effW - boxW;
+    const excessH = effH - boxH;
+    const cropX = excessW * anchorX;
+    const cropY = excessH * anchorY;
+    return {
+      effW,
+      effH,
+      sizing: {
+        type: "crop",
+        x: cropX,
+        y: cropY,
+        w: boxW,
+        h: boxH
+      }
+    };
+  }
   function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -68582,7 +68747,12 @@ ${generateStylesCss(styleMap, themeFonts)}
           w: el.position.w,
           h: el.position.h
         };
-        if (el.sizing && el.sizing.type) {
+        if (el.sizing && el.sizing.type === "cover" && el.naturalWidth && el.naturalHeight) {
+          const crop = computeCoverCrop(el.naturalWidth, el.naturalHeight, el.position.w, el.position.h, el.objectPosition);
+          imageOptions.w = crop.effW;
+          imageOptions.h = crop.effH;
+          imageOptions.sizing = crop.sizing;
+        } else if (el.sizing && el.sizing.type) {
           imageOptions.sizing = { type: el.sizing.type, w: el.position.w, h: el.position.h };
         }
         if (el.brightness !== void 0)
@@ -68624,22 +68794,10 @@ ${generateStylesCss(styleMap, themeFonts)}
           h: el.position.h
         };
         if (el.sizing && el.sizing.type === "cover" && el.naturalWidth && el.naturalHeight) {
-          const imgRatio = el.naturalHeight / el.naturalWidth;
-          const boxRatio = el.position.h / el.position.w;
-          const isBoxBased = boxRatio > imgRatio;
-          const effW = isBoxBased ? el.position.h / imgRatio : el.position.w;
-          const effH = isBoxBased ? el.position.h : el.position.w * imgRatio;
-          const cropX = (effW - el.position.w) / 2;
-          const cropY = (effH - el.position.h) / 2;
-          imageOptions.w = effW;
-          imageOptions.h = effH;
-          imageOptions.sizing = {
-            type: "crop",
-            x: cropX,
-            y: cropY,
-            w: el.position.w,
-            h: el.position.h
-          };
+          const crop = computeCoverCrop(el.naturalWidth, el.naturalHeight, el.position.w, el.position.h, el.objectPosition);
+          imageOptions.w = crop.effW;
+          imageOptions.h = crop.effH;
+          imageOptions.sizing = crop.sizing;
         } else if (el.sizing && el.sizing.type) {
           imageOptions.sizing = { type: el.sizing.type, w: el.position.w, h: el.position.h };
         }