pptx-angular-viewer 1.16.1 → 1.17.0

package/CHANGELOG.md

@@ -4,6 +4,8 @@ All notable changes to this project are documented here.
 This file is generated from [Conventional Commits](https://www.conventionalcommits.org)
 by [git-cliff](https://git-cliff.org); do not edit it by hand.
 
+## [1.16.1](https://github.com/ChristopherVR/pptx-viewer/releases/tag/pptx-angular-viewer@1.16.1) - 2026-07-13
+
 ## [1.16.0](https://github.com/ChristopherVR/pptx-viewer/releases/tag/pptx-angular-viewer@1.16.0) - 2026-07-11
 
 ## [1.15.0](https://github.com/ChristopherVR/pptx-viewer/releases/tag/pptx-angular-viewer@1.15.0) - 2026-07-11

package/fesm2022/pptx-angular-viewer.mjs

@@ -3736,6 +3736,80 @@ function getWarpCssTransform(preset, adj, adj2) {
     return undefined;
 }
 
+/**
+ * Read the first explicit DrawingML run colour nested inside an OMML tree.
+ * Office Math stores formatting in `a:rPr`, not in `m:rPr`, so this colour
+ * must travel with the generated MathML rather than the text shape's default
+ * paragraph style.
+ */
+function getOmmlMathColor(node) {
+    if (!node || typeof node !== 'object') {
+        return undefined;
+    }
+    const drawingRunProperties = node['a:rPr'];
+    if (drawingRunProperties && typeof drawingRunProperties === 'object') {
+        const solidFill = drawingRunProperties['a:solidFill'];
+        const srgbColor = solidFill && typeof solidFill === 'object'
+            ? solidFill['a:srgbClr']
+            : undefined;
+        const value = srgbColor?.['@_val'];
+        if (typeof value === 'string' && /^[0-9a-f]{6}$/iu.test(value)) {
+            return `#${value.toUpperCase()}`;
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (child && typeof child === 'object') {
+                    const color = getOmmlMathColor(child);
+                    if (color) {
+                        return color;
+                    }
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            const color = getOmmlMathColor(value);
+            if (color) {
+                return color;
+            }
+        }
+    }
+    return undefined;
+}
+/** Read the first explicit DrawingML run size, stored in hundredths of a point. */
+function getOmmlMathFontSize(node) {
+    if (!node || typeof node !== 'object') {
+        return undefined;
+    }
+    const drawingRunProperties = node['a:rPr'];
+    if (drawingRunProperties && typeof drawingRunProperties === 'object') {
+        const size = Number(drawingRunProperties['@_sz']);
+        if (Number.isFinite(size) && size > 0) {
+            return size / 100;
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (child && typeof child === 'object') {
+                    const size = getOmmlMathFontSize(child);
+                    if (size) {
+                        return size;
+                    }
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            const size = getOmmlMathFontSize(value);
+            if (size) {
+                return size;
+            }
+        }
+    }
+    return undefined;
+}
+
 /**
  * omml-to-mathml.ts — pure OMML → MathML conversion.
  *
@@ -4250,7 +4324,11 @@ function convertOmmlToMathMl(ommlNode) {
     if (inner.length === 0) {
         return '';
     }
-    return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${inner}</math>`;
+    const color = getOmmlMathColor(ommlNode);
+    const colorAttribute = color ? ` mathcolor="${color}"` : '';
+    const fontSize = getOmmlMathFontSize(ommlNode);
+    const sizeAttribute = fontSize ? ` mathsize="${fontSize}pt"` : '';
+    return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"${colorAttribute}${sizeAttribute}>${inner}</math>`;
 }
 /**
  * Convenience alias used by the Vue viewer: `ommlToMathml(omml)`.
@@ -16722,6 +16800,37 @@ function mergeAdditiveSelection(baseSelectionIds, hitIds) {
     return Array.from(new Set([...(baseSelectionIds ?? []), ...hitIds]));
 }
 
+/** Union of all selected element boxes, or null for an empty selection. */
+function selectionBounds(boxes) {
+    if (boxes.length === 0) {
+        return null;
+    }
+    const minX = Math.min(...boxes.map((box) => box.x));
+    const minY = Math.min(...boxes.map((box) => box.y));
+    const maxX = Math.max(...boxes.map((box) => box.x + box.width));
+    const maxY = Math.max(...boxes.map((box) => box.y + box.height));
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY, rotation: 0 };
+}
+/** Move all boxes by the same slide-space delta. */
+function moveSelection(boxes, dx, dy) {
+    return boxes.map((box) => ({ ...box, x: box.x + dx, y: box.y + dy }));
+}
+/**
+ * Scale boxes from one selection boundary into another. Each element keeps its
+ * relative position and size within the collective selection.
+ */
+function resizeSelection(boxes, from, to) {
+    const scaleX = from.width === 0 ? 1 : to.width / from.width;
+    const scaleY = from.height === 0 ? 1 : to.height / from.height;
+    return boxes.map((box) => ({
+        ...box,
+        x: to.x + (box.x - from.x) * scaleX,
+        y: to.y + (box.y - from.y) * scaleY,
+        width: Math.max(1, box.width * scaleX),
+        height: Math.max(1, box.height * scaleY),
+    }));
+}
+
 /** Map a number to a CSS pixel string. */
 function px(n) {
     return `${n}px`;
@@ -20459,7 +20568,14 @@ function sanitizeMarkupOrEmpty(markup, config) {
  * @returns The sanitised markup, or the raw input when no DOM is available.
  */
 function sanitizeMathMl(markup) {
-    return sanitizeMarkupOrRaw(markup, { USE_PROFILES: { mathMl: true, svg: true } });
+    const sanitized = sanitizeMarkupOrRaw(markup, { USE_PROFILES: { mathMl: true, svg: true } });
+    // DOMPurify's HTML parser can retain MathML descendants while dropping the
+    // outer namespace-bearing <math> node. Restore that generated, constant
+    // wrapper so browsers keep the fragment in the MathML rendering context.
+    if (/<math(?:\s|>)/iu.test(markup) && !/<math(?:\s|>)/iu.test(sanitized) && sanitized) {
+        return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${sanitized}</math>`;
+    }
+    return sanitized;
 }
 
 /**
@@ -29437,6 +29553,23 @@ function buildFontFaceRule(variant) {
         '}',
     ].join('\n');
 }
+/** Build a safe `@font-face` stylesheet for host-provided font sources. */
+function buildUserFontFaceStyles(fonts) {
+    const rules = [];
+    for (const font of fonts ?? []) {
+        const family = typeof font.family === 'string' ? font.family.trim() : '';
+        const src = typeof font.src === 'string' ? font.src.trim() : '';
+        const isRemoteUrl = /^https?:\/\/[^"\\\n\r{};]+$/iu.test(src);
+        if (!family || FONT_NAME_UNSAFE_CHARS.test(family) || !(isInjectableUrl(src) || isRemoteUrl)) {
+            continue;
+        }
+        const format = normalizeFontFormat(font.format);
+        const weight = typeof font.weight === 'number' || typeof font.weight === 'string' ? font.weight : '400';
+        const style = font.style === 'italic' ? 'italic' : 'normal';
+        rules.push(buildFontFaceRule({ name: family, url: src, format, weight: String(weight), style }));
+    }
+    return rules.join('\n\n');
+}
 /**
  * Resolve a list of embedded fonts into the injectable `@font-face` stylesheet,
  * the distinct substitution-resolved family strings, and any object URLs minted
@@ -32593,6 +32726,60 @@ function createTouchGestureRecognizer(config) {
     };
 }
 
+/**
+ * Build the stable presentation-control state shared by every UI binding.
+ * Empty presentations disable both directions and use the same 0 / 0 label.
+ */
+function buildPresentationTouchControlState(currentSlideIndex, totalSlides) {
+    if (totalSlides <= 0) {
+        return {
+            previousDisabled: true,
+            nextDisabled: true,
+            counterLabel: '0 / 0',
+        };
+    }
+    return {
+        previousDisabled: currentSlideIndex <= 0,
+        nextDisabled: currentSlideIndex >= totalSlides - 1,
+        counterLabel: `${currentSlideIndex + 1} / ${totalSlides}`,
+    };
+}
+
+/** Framework-neutral downward drag recognizer for mobile bottom sheets. */
+function createSheetDismissGesture(onOffset, onDismiss, threshold = 120) {
+    let startY = null;
+    const finish = (event, allowDismiss) => {
+        if (startY === null) {
+            return;
+        }
+        const delta = Math.max(0, event.clientY - startY);
+        startY = null;
+        event.currentTarget?.releasePointerCapture?.(event.pointerId);
+        onOffset(0, false);
+        if (allowDismiss && delta > threshold) {
+            onDismiss();
+        }
+    };
+    return {
+        pointerDown(event) {
+            startY = event.clientY;
+            event.currentTarget?.setPointerCapture?.(event.pointerId);
+            onOffset(0, true);
+        },
+        pointerMove(event) {
+            if (startY !== null) {
+                onOffset(Math.max(0, event.clientY - startY), true);
+            }
+        },
+        pointerUp(event) {
+            finish(event, true);
+        },
+        cancel(event) {
+            finish(event, false);
+        },
+    };
+}
+
 /**
  * insert-chart.ts - framework-agnostic factory for a sensible DEFAULT new
  * chart element, the single source of truth every binding (React, Vue,
@@ -33299,6 +33486,39 @@ function deserializeElementClipboard(text) {
     };
 }
 
+/** Immutably replace one slide's inherited element list. */
+function setTemplateElements(map, slideId, elements) {
+    return { ...map, [slideId]: elements };
+}
+/** Find an inherited element on one slide. */
+function findTemplateElement(map, slideId, elementId) {
+    return slideId ? map[slideId]?.find((element) => element.id === elementId) : undefined;
+}
+/** Gate layout/master hits unless template editing is enabled. */
+function isElementIdInteractive(elementId, editTemplateMode) {
+    return !isTemplateElementId(elementId) || editTemplateMode;
+}
+/** Split layout/master elements out of each loaded slide while preserving order. */
+function partitionTemplateElements(slides) {
+    const templateElementsBySlideId = {};
+    const nextSlides = slides.map((slide) => {
+        const template = slide.elements.filter(isTemplateElement);
+        if (template.length === 0) {
+            return slide;
+        }
+        templateElementsBySlideId[slide.id] = template;
+        return { ...slide, elements: slide.elements.filter((element) => !isTemplateElement(element)) };
+    });
+    return { slides: nextSlides, templateElementsBySlideId };
+}
+/** Merge editable layout/master elements behind slide-owned elements for save/export. */
+function buildSaveSlides$1(slides, templateElementsBySlideId) {
+    return slides.map((slide) => {
+        const template = templateElementsBySlideId[slide.id];
+        return template?.length ? { ...slide, elements: [...template, ...slide.elements] } : slide;
+    });
+}
+
 /**
  * shape-preset-catalog.ts: the Insert > Shape picker catalogue shared by every
  * binding's toolbar/inspector.