@jsamuel1/pptxgenjs 4.1.0 → 4.1.2

package/dist/pptxgen.es.js

@@ -1,4 +1,4 @@
-/* PptxGenJS 4.0.1 @ 2026-06-07T05:05:05.129Z */
+/* PptxGenJS 4.1.1 @ 2026-06-07T21:17:30.873Z */
 import JSZip from 'jszip';
 
 /******************************************************************************
@@ -579,6 +579,7 @@ var MASTER_OBJECTS;
 var SLIDE_OBJECT_TYPES;
 (function (SLIDE_OBJECT_TYPES) {
     SLIDE_OBJECT_TYPES["chart"] = "chart";
+    SLIDE_OBJECT_TYPES["group"] = "group";
     SLIDE_OBJECT_TYPES["hyperlink"] = "hyperlink";
     SLIDE_OBJECT_TYPES["image"] = "image";
     SLIDE_OBJECT_TYPES["media"] = "media";
@@ -662,7 +663,8 @@ function getUuid(uuidFormat) {
     return uuidFormat.replace(/[xy]/g, function (c) {
         const r = (Math.random() * 16) | 0;
         const v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
+        // OOXML ST_Guid requires uppercase hex: \{[0-9A-F]{8}-...\}
+        return v.toString(16).toUpperCase();
     });
 }
 /**
@@ -923,6 +925,170 @@ function correctShadowOptions(ShadowProps) {
     }
     return ShadowProps;
 }
+/**
+ * Convert an SVG `<path d="…">` definition to an OOXML custom geometry (`<a:custGeom>`).
+ *
+ * Supports the following SVG path commands (both absolute upper-case and relative lower-case):
+ * - `M`/`m` moveTo            → `<a:moveTo>`  (extra coordinate pairs become implicit `lineTo`)
+ * - `L`/`l` lineTo            → `<a:lnTo>`
+ * - `H`/`h` horizontal lineTo → `<a:lnTo>`
+ * - `V`/`v` vertical lineTo   → `<a:lnTo>`
+ * - `C`/`c` cubic Bézier      → `<a:cubicBezTo>`
+ * - `Q`/`q` quadratic Bézier  → `<a:quadBezTo>`
+ * - `Z`/`z` close path        → `<a:close>`
+ *
+ * Relative commands are tracked against the current pen position and converted to absolute
+ * coordinates. Coordinates are scaled from the SVG viewBox into EMU via `914400 / width`, so the
+ * viewBox width maps to exactly 1 inch (914400 EMU) of path coordinate space. The shape's on-slide
+ * dimensions still come from the `<a:xfrm><a:ext>` set by the caller — the path coordinate system is
+ * stretched to fit it — so the absolute scale here only needs to be internally consistent.
+ *
+ * @param {string} svgPathD - the SVG path `d` attribute (e.g. `"M 0 0 L 12 0 L 6 12 Z"`)
+ * @param {number} width - SVG viewBox width
+ * @param {number} height - SVG viewBox height
+ * @returns {string} OOXML `<a:custGeom>…</a:custGeom>` string (empty string on invalid input)
+ * @see ECMA-376 §20.1.9.8 (custGeom) / §20.1.9.16 (path2D)
+ */
+function svgPathToOoxml(svgPathD, width, height) {
+    var _a;
+    if (!svgPathD || typeof svgPathD !== 'string' || !(width > 0) || !(height > 0))
+        return '';
+    const scale = 914400 / width;
+    const pathW = Math.round(width * scale);
+    const pathH = Math.round(height * scale);
+    // Match each command letter followed by its (possibly empty) run of numeric arguments
+    const commandRegex = /([MmLlHhVvCcQqZz])([^MmLlHhVvCcQqZz]*)/g;
+    // Match numbers incl. decimals, leading sign, and scientific notation
+    const numberRegex = /-?\d*\.?\d+(?:[eE][-+]?\d+)?/g;
+    const sc = (v) => Math.round(v * scale);
+    let curX = 0;
+    let curY = 0;
+    let startX = 0;
+    let startY = 0;
+    let xml = '';
+    let match;
+    while ((match = commandRegex.exec(svgPathD)) !== null) {
+        const cmd = match[1];
+        const isRel = cmd >= 'a' && cmd <= 'z';
+        const upper = cmd.toUpperCase();
+        const args = ((_a = match[2].match(numberRegex)) !== null && _a !== void 0 ? _a : []).map(Number);
+        let i = 0;
+        switch (upper) {
+            case 'M': {
+                // First coordinate pair is a moveTo; any subsequent pairs are implicit lineTo (per SVG spec)
+                let first = true;
+                while (i + 1 < args.length) {
+                    let x = args[i];
+                    let y = args[i + 1];
+                    if (isRel) {
+                        x += curX;
+                        y += curY;
+                    }
+                    curX = x;
+                    curY = y;
+                    if (first) {
+                        startX = curX;
+                        startY = curY;
+                        xml += `<a:moveTo><a:pt x="${sc(curX)}" y="${sc(curY)}"/></a:moveTo>`;
+                        first = false;
+                    }
+                    else {
+                        xml += `<a:lnTo><a:pt x="${sc(curX)}" y="${sc(curY)}"/></a:lnTo>`;
+                    }
+                    i += 2;
+                }
+                break;
+            }
+            case 'L': {
+                while (i + 1 < args.length) {
+                    let x = args[i];
+                    let y = args[i + 1];
+                    if (isRel) {
+                        x += curX;
+                        y += curY;
+                    }
+                    curX = x;
+                    curY = y;
+                    xml += `<a:lnTo><a:pt x="${sc(curX)}" y="${sc(curY)}"/></a:lnTo>`;
+                    i += 2;
+                }
+                break;
+            }
+            case 'H': {
+                while (i < args.length) {
+                    let x = args[i];
+                    if (isRel)
+                        x += curX;
+                    curX = x;
+                    xml += `<a:lnTo><a:pt x="${sc(curX)}" y="${sc(curY)}"/></a:lnTo>`;
+                    i += 1;
+                }
+                break;
+            }
+            case 'V': {
+                while (i < args.length) {
+                    let y = args[i];
+                    if (isRel)
+                        y += curY;
+                    curY = y;
+                    xml += `<a:lnTo><a:pt x="${sc(curX)}" y="${sc(curY)}"/></a:lnTo>`;
+                    i += 1;
+                }
+                break;
+            }
+            case 'C': {
+                while (i + 5 < args.length) {
+                    let x1 = args[i];
+                    let y1 = args[i + 1];
+                    let x2 = args[i + 2];
+                    let y2 = args[i + 3];
+                    let x = args[i + 4];
+                    let y = args[i + 5];
+                    if (isRel) {
+                        x1 += curX;
+                        y1 += curY;
+                        x2 += curX;
+                        y2 += curY;
+                        x += curX;
+                        y += curY;
+                    }
+                    xml += `<a:cubicBezTo><a:pt x="${sc(x1)}" y="${sc(y1)}"/><a:pt x="${sc(x2)}" y="${sc(y2)}"/><a:pt x="${sc(x)}" y="${sc(y)}"/></a:cubicBezTo>`;
+                    curX = x;
+                    curY = y;
+                    i += 6;
+                }
+                break;
+            }
+            case 'Q': {
+                while (i + 3 < args.length) {
+                    let x1 = args[i];
+                    let y1 = args[i + 1];
+                    let x = args[i + 2];
+                    let y = args[i + 3];
+                    if (isRel) {
+                        x1 += curX;
+                        y1 += curY;
+                        x += curX;
+                        y += curY;
+                    }
+                    xml += `<a:quadBezTo><a:pt x="${sc(x1)}" y="${sc(y1)}"/><a:pt x="${sc(x)}" y="${sc(y)}"/></a:quadBezTo>`;
+                    curX = x;
+                    curY = y;
+                    i += 4;
+                }
+                break;
+            }
+            case 'Z': {
+                xml += '<a:close/>';
+                // Pen returns to the start of the current subpath
+                curX = startX;
+                curY = startY;
+                break;
+            }
+        }
+    }
+    return `<a:custGeom><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:rect l="l" t="t" r="r" b="b"/><a:pathLst><a:path w="${pathW}" h="${pathH}">${xml}</a:path></a:pathLst></a:custGeom>`;
+}
 
 /**
  * PptxGenJS: Table Generation
@@ -2313,6 +2479,90 @@ function addShapeDefinition(target, shapeName, opts) {
     // LAST: Add object to slide
     target._slideObjects.push(newObject);
 }
+/**
+ * Feature 7: Adds a rounded-rectangle callout/badge to a slide definition.
+ * Thin sugar over `addTextDefinition` with `shape:'roundRect'`, centred text, and a
+ * corner-radius `adj` value computed from `cornerRadius` (inches) per:
+ *   `adj = Math.round((cornerRadius / (h / 2)) * 50000)`.
+ * @param {PresSlide} target slide object that the callout should be added to
+ * @param {CalloutProps} opts callout options
+ */
+function addCalloutDefinition(target, opts) {
+    const options = typeof opts === 'object' ? opts : {};
+    const h = options.h !== undefined ? Number(options.h) : 0.4;
+    const w = options.w !== undefined ? options.w : 1.5;
+    const cornerRadius = options.cornerRadius !== undefined ? options.cornerRadius : 0.1;
+    // Map inches -> OOXML `adj` (percentage of half-shortest-side × 1000). Guard divide-by-zero.
+    const calloutAdj = h > 0 ? Math.round((cornerRadius / (h / 2)) * 50000) : 0;
+    const fill = options.fill !== undefined ? options.fill : '7C3AED';
+    const textOpts = {
+        shape: SHAPE_TYPE.ROUNDED_RECTANGLE,
+        x: options.x !== undefined ? options.x : 1,
+        y: options.y !== undefined ? options.y : 1,
+        w,
+        h,
+        fill: typeof fill === 'string' ? { color: fill } : fill,
+        color: options.fontColor !== undefined ? options.fontColor : 'FFFFFF',
+        fontSize: options.fontSize !== undefined ? options.fontSize : 12,
+        bold: options.fontBold !== undefined ? options.fontBold : true,
+        align: options.align || 'center',
+        valign: options.valign || 'middle',
+        _calloutAdj: calloutAdj,
+    };
+    if (options.objectName)
+        textOpts.objectName = options.objectName;
+    addTextDefinition(target, [{ text: options.text || '', options: null }], textOpts, false);
+}
+/**
+ * Feature 6: Adds a shape group to a slide definition and returns a group handle.
+ * The group emits a `<p:grpSp>` whose `<a:xfrm>` carries the absolute position/size plus
+ * `chOff="0,0"`/`chExt` equal to the extent — so child shapes/text use coordinates relative
+ * to the group origin (1:1 scale). Children are added via the returned object's
+ * `addShape()` / `addText()`, which reuse the existing shape/text intake but push onto the
+ * group's private child array instead of the slide.
+ * @param {PresSlide} target slide the group should be added to
+ * @param {GroupProps} opts group position/size options
+ * @return {SlideGroup} group handle exposing `addShape` / `addText`
+ */
+function addGroupDefinition(target, opts) {
+    const options = typeof opts === 'object' ? opts : {};
+    const grpObjects = [];
+    const groupObj = {
+        _type: SLIDE_OBJECT_TYPES.group,
+        options: {
+            x: options.x !== undefined ? options.x : 0,
+            y: options.y !== undefined ? options.y : 0,
+            w: options.w !== undefined ? options.w : 0,
+            h: options.h !== undefined ? options.h : 0,
+            objectName: options.objectName ? encodeXmlEntities(options.objectName) : `Group ${target._slideObjects.filter(obj => obj._type === SLIDE_OBJECT_TYPES.group).length + 1}`,
+        },
+        _grpObjects: grpObjects,
+    };
+    target._slideObjects.push(groupObj);
+    // Proxy target: existing intake fns push onto the group's child array but reuse the parent
+    // slide's rels/layout/color so child shapes/text render identically to top-level ones.
+    const childTarget = {
+        _slideObjects: grpObjects,
+        _rels: target._rels,
+        _relsChart: target._relsChart,
+        _relsMedia: target._relsMedia,
+        _slideLayout: target._slideLayout,
+        _presLayout: target._presLayout,
+        color: target.color,
+    };
+    const group = {
+        addShape(shapeName, shapeOpts) {
+            addShapeDefinition(childTarget, shapeName, (shapeOpts || {}));
+            return group;
+        },
+        addText(text, textOpts) {
+            const textParam = typeof text === 'string' || typeof text === 'number' ? [{ text, options: textOpts }] : text;
+            addTextDefinition(childTarget, textParam, (textOpts || {}), false);
+            return group;
+        },
+    };
+    return group;
+}
 /**
  * Adds a table object to a slide definition.
  * @param {PresSlide} target - slide object that the table should be added to
@@ -2683,7 +2933,11 @@ function addTextDefinition(target, text, opts, isPlaceholder) {
             itemOpts.lineSpacingMultiple = itemOpts.lineSpacingMultiple && !isNaN(itemOpts.lineSpacingMultiple) ? itemOpts.lineSpacingMultiple : null;
             // D: Transform text options to bodyProperties as thats how we build XML
             itemOpts._bodyProp = itemOpts._bodyProp || {};
-            itemOpts._bodyProp.autoFit = itemOpts.autoFit || false; // DEPRECATED: (3.3.0) If true, shape will collapse to text size (Fit To shape)
+            // Back-compat: legacy `autoFit: true` ("resize shape to fit text") now maps to `fit: 'resize'`.
+            // Routing through `fit` keeps a single code path (and avoids emitting `<a:spAutoFit/>` twice). @deprecated 3.3.0
+            if (itemOpts.autoFit === true && !itemOpts.fit)
+                itemOpts.fit = 'resize';
+            itemOpts._bodyProp.autoFit = false; // DEPRECATED: (3.3.0) superseded by `fit` (see above)
             itemOpts._bodyProp.anchor = !itemOpts.placeholder ? TEXT_VALIGN.ctr : null; // VALS: [t,ctr,b]
             itemOpts._bodyProp.vert = itemOpts.vert || null; // VALS: [eaVert,horz,mongolianVert,vert,vert270,wordArtVert,wordArtVertRtl]
             itemOpts._bodyProp.wrap = typeof itemOpts.wrap === 'boolean' ? itemOpts.wrap : true;
@@ -2992,6 +3246,27 @@ class Slide {
         addShapeDefinition(this, shapeName, options);
         return this;
     }
+    /**
+     * Add a shape group to Slide (Feature 6).
+     * Returns a group handle whose `addShape()`/`addText()` use coordinates relative to the
+     * group origin; the group emits a `<p:grpSp>` with an absolute `<a:xfrm>` + `chOff`/`chExt`.
+     * @param {GroupProps} options - group position/size options
+     * @return {SlideGroup} group handle exposing `addShape` / `addText`
+     */
+    addGroup(options) {
+        return addGroupDefinition(this, options);
+    }
+    /**
+     * Add a rounded-rectangle callout/badge to Slide (Feature 7).
+     * Sugar over `addShape('roundRect', …)` with centred text and an `adj`
+     * corner-radius derived from `cornerRadius` (inches).
+     * @param {CalloutProps} options - callout options
+     * @return {Slide} this Slide
+     */
+    addCallout(options) {
+        addCalloutDefinition(this, options);
+        return this;
+    }
     /**
      * Add table to Slide
      * @param {TableRow[]} tableRows - table rows
@@ -5290,6 +5565,20 @@ function slideObjectToXml(slide) {
             if (placeholderObj.options.h || placeholderObj.options.h === 0)
                 cy = getSmartParseNumber(placeholderObj.options.h, 'Y', slide._presLayout);
         }
+        // Normalize negative extents: PPTX requires cx/cy >= 0 (ST_PositiveCoordinate); encode direction via flip
+        // A shape drawn "backwards" (e.g. a line with negative w/h) otherwise emits an invalid `<a:ext>` that triggers PowerPoint repair.
+        if (cx < 0) {
+            x += cx;
+            cx = Math.abs(cx);
+            imgWidth = cx;
+            slideItemObj.options.flipH = !slideItemObj.options.flipH;
+        }
+        if (cy < 0) {
+            y += cy;
+            cy = Math.abs(cy);
+            imgHeight = cy;
+            slideItemObj.options.flipV = !slideItemObj.options.flipV;
+        }
         //
         if (slideItemObj.options.flipH)
             locationAttr += ' flipH="1"';
@@ -5560,7 +5849,11 @@ function slideObjectToXml(slide) {
                 strSlideXml += `<a:xfrm${locationAttr}>`;
                 strSlideXml += `<a:off x="${x}" y="${y}"/>`;
                 strSlideXml += `<a:ext cx="${cx}" cy="${cy}"/></a:xfrm>`;
-                if (slideItemObj.shape === 'custGeom') {
+                if (slideItemObj.options.svgPath) {
+                    // Feature 9: Convert an SVG path to OOXML custom geometry (<a:custGeom>) instead of a preset geometry.
+                    strSlideXml += svgPathToOoxml(slideItemObj.options.svgPath.d, slideItemObj.options.svgPath.viewBox.w, slideItemObj.options.svgPath.viewBox.h);
+                }
+                else if (slideItemObj.shape === 'custGeom') {
                     strSlideXml += '<a:custGeom><a:avLst />';
                     strSlideXml += '<a:gdLst>';
                     strSlideXml += '</a:gdLst>';
@@ -5607,7 +5900,11 @@ function slideObjectToXml(slide) {
                 }
                 else {
                     strSlideXml += '<a:prstGeom prst="' + slideItemObj.shape + '"><a:avLst>';
-                    if (slideItemObj.options.rectRadius) {
+                    if (slideItemObj.options._calloutAdj !== undefined && slideItemObj.options._calloutAdj !== null) {
+                        // Feature 7: addCallout() supplies a pre-computed `adj` value; emit it verbatim.
+                        strSlideXml += `<a:gd name="adj" fmla="val ${slideItemObj.options._calloutAdj}"/>`;
+                    }
+                    else if (slideItemObj.options.rectRadius) {
                         strSlideXml += `<a:gd name="adj" fmla="val ${Math.round((slideItemObj.options.rectRadius * EMU * 100000) / Math.min(cx, cy))}"/>`;
                     }
                     else if (slideItemObj.options.angleRange) {
@@ -5637,23 +5934,33 @@ function slideObjectToXml(slide) {
                     // FUTURE: `endArrowSize` < a: headEnd type = "arrow" w = "lg" len = "lg" /> 'sm' | 'med' | 'lg'(values are 1 - 9, making a 3x3 grid of w / len possibilities)
                     strSlideXml += '</a:ln>';
                 }
-                // EFFECTS > SHADOW: REF: @see http://officeopenxml.com/drwSp-effects.php
-                if (slideItemObj.options.shadow && slideItemObj.options.shadow.type !== 'none') {
-                    // derive emit-time values into locals so we don't mutate the user's options.shadow
-                    // (re-emission would otherwise re-convert pt→EMU and produce absurd values).
-                    const sh = slideItemObj.options.shadow;
-                    const shadowType = sh.type || 'outer';
-                    const shadowBlur = valToPts(sh.blur || 8);
-                    const shadowOffset = valToPts(sh.offset || 4);
-                    const shadowAngle = Math.round((sh.angle || 270) * 60000);
-                    const shadowOpacity = Math.round((sh.opacity || 0.75) * 100000);
-                    const shadowColor = sh.color || DEF_TEXT_SHADOW.color;
-                    strSlideXml += '<a:effectLst>';
-                    strSlideXml += ` <a:${shadowType}Shdw ${shadowType === 'outer' ? 'sx="100000" sy="100000" kx="0" ky="0" algn="bl" rotWithShape="0"' : ''} blurRad="${shadowBlur}" dist="${shadowOffset}" dir="${shadowAngle}">`;
-                    strSlideXml += ` <a:srgbClr val="${shadowColor}">`;
-                    strSlideXml += ` <a:alpha val="${shadowOpacity}"/></a:srgbClr>`;
-                    strSlideXml += ' </a:outerShdw>';
-                    strSlideXml += '</a:effectLst>';
+                // EFFECTS > SHADOW + GLOW (Feature 10): REF: @see http://officeopenxml.com/drwSp-effects.php
+                // Both effects share a single <a:effectLst>; emit it once if either is present.
+                {
+                    const hasShadow = !!(slideItemObj.options.shadow && slideItemObj.options.shadow.type !== 'none');
+                    const hasGlow = !!slideItemObj.options.glow;
+                    if (hasShadow || hasGlow) {
+                        strSlideXml += '<a:effectLst>';
+                        if (hasShadow) {
+                            // derive emit-time values into locals so we don't mutate the user's options.shadow
+                            // (re-emission would otherwise re-convert pt→EMU and produce absurd values).
+                            const sh = slideItemObj.options.shadow;
+                            const shadowType = sh.type || 'outer';
+                            const shadowBlur = valToPts(sh.blur || 8);
+                            const shadowOffset = valToPts(sh.offset || 4);
+                            const shadowAngle = Math.round((sh.angle || 270) * 60000);
+                            const shadowOpacity = Math.round((sh.opacity || 0.75) * 100000);
+                            const shadowColor = sh.color || DEF_TEXT_SHADOW.color;
+                            strSlideXml += `<a:${shadowType}Shdw ${shadowType === 'outer' ? 'sx="100000" sy="100000" kx="0" ky="0" algn="bl" rotWithShape="0"' : ''} blurRad="${shadowBlur}" dist="${shadowOffset}" dir="${shadowAngle}">`;
+                            strSlideXml += `<a:srgbClr val="${shadowColor}">`;
+                            strSlideXml += `<a:alpha val="${shadowOpacity}"/></a:srgbClr>`;
+                            strSlideXml += `</a:${shadowType}Shdw>`;
+                        }
+                        if (hasGlow) {
+                            strSlideXml += createGlowElement(slideItemObj.options.glow, DEF_TEXT_GLOW);
+                        }
+                        strSlideXml += '</a:effectLst>';
+                    }
                 }
                 /* TODO: FUTURE: Text wrapping (copied from MS-PPTX export)
                     // Commented out b/c i'm not even sure this works - current code produces text that wraps in shapes and textboxes, so...
@@ -5801,6 +6108,20 @@ function slideObjectToXml(slide) {
                 strSlideXml += ' </a:graphic>';
                 strSlideXml += '</p:graphicFrame>';
                 break;
+            case SLIDE_OBJECT_TYPES.group:
+                // Feature 6: nested shape group. The `<a:xfrm>` carries the absolute position/size;
+                // `chOff="0,0"` + `chExt`=ext gives a 1:1 child coordinate space, so children use
+                // coordinates relative to the group origin. Children reuse the standard shape/text
+                // emitters via `genGroupChildrenXml`.
+                strSlideXml += '<p:grpSp>';
+                strSlideXml += `<p:nvGrpSpPr><p:cNvPr id="${idx + 2}" name="${slideItemObj.options.objectName || `Group ${idx + 1}`}"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>`;
+                strSlideXml += `<p:grpSpPr><a:xfrm${locationAttr}>`;
+                strSlideXml += `<a:off x="${x}" y="${y}"/><a:ext cx="${cx}" cy="${cy}"/>`;
+                strSlideXml += `<a:chOff x="0" y="0"/><a:chExt cx="${cx}" cy="${cy}"/>`;
+                strSlideXml += '</a:xfrm></p:grpSpPr>';
+                strSlideXml += genGroupChildrenXml(slide, slideItemObj._grpObjects, idx);
+                strSlideXml += '</p:grpSp>';
+                break;
             default:
                 strSlideXml += '';
                 break;
@@ -5872,6 +6193,47 @@ function slideObjectToXml(slide) {
     // LAST: Return
     return strSlideXml;
 }
+/**
+ * Feature 6: Render a shape group's child objects as the inner markup of a `<p:grpSp>`.
+ * Reuses the full slide emitter (`slideObjectToXml`) on the same slide with its object list
+ * temporarily swapped to the group's children (and slide-number footer suppressed), then
+ * extracts just the `<p:spTree>` child markup (everything after the root `</p:grpSpPr>` up to
+ * `</p:spTree>`). Child `<p:cNvPr>` ids are offset to stay unique within the slide part so
+ * PowerPoint does not flag the file for repair.
+ * @param {PresSlide | SlideLayout} slide - parent slide (provides layout/rels/presLayout)
+ * @param {ISlideObject[]} grpObjects - the group's child slide objects
+ * @param {number} groupIdx - the group's index within the slide (used to namespace child ids)
+ * @return {string} child markup to nest inside `<p:grpSp>`
+ */
+function genGroupChildrenXml(slide, grpObjects, groupIdx) {
+    if (!grpObjects || grpObjects.length === 0)
+        return '';
+    // Temporarily render the children through the normal slide pipeline. Background is emitted
+    // before `<p:spTree>` (outside the extracted region) so it is harmless; the slide-number
+    // footer is emitted inside `<p:spTree>`, so suppress it during the recursive render.
+    const savedObjects = slide._slideObjects;
+    const savedSlideNum = slide._slideNumberProps;
+    slide._slideObjects = grpObjects;
+    slide._slideNumberProps = null;
+    let fullXml;
+    try {
+        fullXml = slideObjectToXml(slide);
+    }
+    finally {
+        slide._slideObjects = savedObjects;
+        slide._slideNumberProps = savedSlideNum;
+    }
+    const startMarker = '</p:grpSpPr>';
+    const startIdx = fullXml.indexOf(startMarker);
+    const endIdx = fullXml.lastIndexOf('</p:spTree>');
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return '';
+    let childXml = fullXml.substring(startIdx + startMarker.length, endIdx);
+    // Keep child cNvPr ids unique within the slide part (avoid PowerPoint "needs repair").
+    const idBase = (groupIdx + 1) * 1000;
+    childXml = childXml.replace(/<p:cNvPr id="(\d+)"/g, (_m, n) => `<p:cNvPr id="${idBase + Number(n)}"`);
+    return childXml;
+}
 /**
  * Transforms slide relations to XML string.
  * Extra relations that are not dynamic can be passed using the 2nd arg (e.g. theme relation in master file).
@@ -6200,6 +6562,13 @@ function genXmlBodyProperties(slideObject) {
             bodyProperties += ' anchor="' + slideObject.options._bodyProp.anchor + '"'; // VALS: [t,ctr,b]
         if (slideObject.options._bodyProp.vert)
             bodyProperties += ' vert="' + slideObject.options._bodyProp.vert + '"'; // VALS: [eaVert,horz,mongolianVert,vert,vert270,wordArtVert,wordArtVertRtl]
+        // D2: Multi-column text (numCol/spcCol attributes on <a:bodyPr>)
+        // NOTE: must be appended as attributes BEFORE the opening tag is closed below (section E)
+        if (slideObject.options.columns && slideObject.options.columns > 1) {
+            bodyProperties += ` numCol="${Math.round(slideObject.options.columns)}"`;
+            const spcColIn = typeof slideObject.options.columnSpacing === 'number' ? slideObject.options.columnSpacing : 0.5;
+            bodyProperties += ` spcCol="${Math.round(spcColIn * EMU)}"`;
+        }
         // E: Close <a:bodyPr element
         bodyProperties += '>';
         /**
@@ -6211,10 +6580,10 @@ function genXmlBodyProperties(slideObject) {
             // NOTE: Use of '<a:noAutofit/>' instead of '' causes issues in PPT-2013!
             if (slideObject.options.fit === 'none')
                 bodyProperties += '';
-            // NOTE: Shrink does not work automatically - PowerPoint calculates the `fontScale` value dynamically upon resize
-            // else if (slideObject.options.fit === 'shrink') bodyProperties += '<a:normAutofit fontScale="85000" lnSpcReduction="20000"/>' // MS-PPT > Format shape > Text Options: "Shrink text on overflow"
+            // "Shrink text on overflow": emit a fixed `fontScale` (70%) so the text is scaled down to fit the shape.
+            // NOTE: PowerPoint recalculates `fontScale` dynamically once the text/shape is edited; the emitted value is the initial scale.
             else if (slideObject.options.fit === 'shrink')
-                bodyProperties += '<a:normAutofit/>';
+                bodyProperties += '<a:normAutofit fontScale="70000"/>';
             else if (slideObject.options.fit === 'resize')
                 bodyProperties += '<a:spAutoFit/>';
         }
@@ -6742,14 +7111,15 @@ function genXmlAnimPayload(anim, spid, nextId) {
     }
     // flyIn ADDS a <p:anim> that translates the shape from offscreen to its final position.
     // direction (TransitionDirection: left|right|up|down) -> animated attr + tm="0" start formula:
-    //   left  -> ppt_x, "0-#ppt_w/2"   right -> ppt_x, "1+#ppt_w/2"
-    //   up    -> ppt_y, "0-#ppt_h/2"   down  -> ppt_y, "1+#ppt_h/2"
+    //   left  -> ppt_x, "#ppt_x-1slide"   right -> ppt_x, "#ppt_x+1slide"
+    //   up    -> ppt_y, "#ppt_y+1slide"   down  -> ppt_y, "#ppt_y-1slide"
+    // The "1slide" offset starts the shape one full slide-width/height offscreen (PowerPoint-native Fly In).
     if (anim.type === 'flyIn') {
         const flyMap = {
-            left: { attr: 'ppt_x', start: '0-#ppt_w/2' },
-            right: { attr: 'ppt_x', start: '1+#ppt_w/2' },
-            up: { attr: 'ppt_y', start: '0-#ppt_h/2' },
-            down: { attr: 'ppt_y', start: '1+#ppt_h/2' },
+            left: { attr: 'ppt_x', start: '#ppt_x-1slide' },
+            right: { attr: 'ppt_x', start: '#ppt_x+1slide' },
+            up: { attr: 'ppt_y', start: '#ppt_y+1slide' },
+            down: { attr: 'ppt_y', start: '#ppt_y-1slide' },
         };
         const { attr, start } = (_b = flyMap[(_a = anim.direction) !== null && _a !== void 0 ? _a : 'left']) !== null && _b !== void 0 ? _b : flyMap.left;
         payload +=
@@ -7199,7 +7569,7 @@ function makeXmlViewProps() {
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  *  SOFTWARE.
  */
-const VERSION = '4.0.1';
+const VERSION = '4.1.1';
 class PptxGenJS {
     set layout(value) {
         const newLayout = this.LAYOUTS[value];