pptx-fix 0.2.0 → 0.3.1

package/README.md

@@ -17,6 +17,7 @@ Common artifacts:
 - **Gradients become flat colors** — 3+ color stops are averaged to a single solid color
 - **Drop shadows become opaque blocks** — shapes with effects render as opaque PDF images that cover content behind them
 - **Fonts shift and text reflows** — Calibri becomes Helvetica Neue, Arial becomes Helvetica, with different metrics
+- **Embedded fonts ignored** — custom fonts embedded in the PPTX are completely ignored by QuickLook, falling back to system substitutes
 
 `pptx-fix` rewrites the OOXML XML inside the PPTX ZIP to work around these OfficeImport quirks. The output is a valid `.pptx` that looks correct in both PowerPoint and Apple's preview.
 
@@ -37,7 +38,7 @@ npm install pptx-fix
 npx pptx-fix input.pptx -o output.pptx
 
 # Apply only specific transforms
-npx pptx-fix input.pptx -o output.pptx --only table-styles,gradients
+npx pptx-fix input.pptx -o output.pptx --only table-styles,gradients,fonts
 
 # See what was changed
 npx pptx-fix input.pptx -o output.pptx --report
@@ -77,9 +78,13 @@ for (const issue of issues) {
 | Transform | Status | What it fixes |
 |-----------|--------|--------------|
 | **table-styles** | Done | Resolves `tableStyleId` references and inlines explicit `<a:lnL/R/T/B>` borders on every cell. Handles `firstRow`, `lastRow`, `bandRow` conditional formatting. Only adds borders where none are explicitly defined. |
-| **geometries** | Planned | Replace unsupported `<a:prstGeom>` (heart, cloud, lightningBolt, sun, moon, frame, arc, chord, etc.) with `<a:custGeom>` path data. |
-| **gradients** | Planned | Collapse 3+ stop gradients to 2-stop (start + end color) so QuickLook renders a gradient instead of a flat color. |
-| **effects** | Planned | Strip or adjust shapes with `<effectLst>` (drop shadow, glow, reflection) that render as opaque PDF blocks covering content. |
+| **geometries** | Done | Replaces unsupported `<a:prstGeom>` presets (~120 shapes not in OfficeImport's supported set) with the visually-closest supported alternative (e.g. heart→ellipse, cloud→cloudCallout) so shapes are visible instead of invisible. |
+| **gradients** | Done | Collapses 3+ stop gradients to 2-stop (first + last color) so QuickLook renders a gradient instead of a flat color. |
+| **effects** | Done | Strips `<effectLst>` and `<effectDag>` (drop shadow, glow, reflection) from shape properties to prevent opaque PDF block rendering. |
+| **fonts** | Done | Replaces high-risk Windows fonts (Calibri +14.4%, Segoe UI +14%, Corbel +18.8%, etc.) with metrically-closest cross-platform alternatives to prevent text reflow on macOS. Also fixes fonts in theme XML. |
+| **groups** | Done | Ungroups shape groups so children render individually instead of being merged into a single opaque PDF block. Transforms child coordinates from group-space to slide-space. Skips rotated groups. |
+| **embedded-fonts** | Done | Strips embedded font data (ignored by QuickLook) and replaces font references with the metrically-closest cross-platform alternative. Reduces file size and ensures consistent rendering. |
+| **chart-fallbacks** | Done | Renders charts to PNG and embeds as fallback images so QuickLook displays charts instead of blank rectangles. Requires Playwright (optional — skips silently if not installed). |
 
 Detection of all issues (including font substitution, chart fallbacks, text inscription shifts, and more) is handled by [quicklook-pptx-renderer](https://www.npmjs.com/package/quicklook-pptx-renderer)'s 12-rule linter. Run `pptx-fix analyze` to see all issues, or use the linter directly in CI.
 
@@ -123,7 +128,7 @@ The round-trip preserves all XML elements the tool doesn't explicitly modify —
 For comprehensive linting with 12 rules, CI integration, cross-platform rendering, and pixel-diff comparison against actual QuickLook output, see [**quicklook-pptx-renderer**](https://www.npmjs.com/package/quicklook-pptx-renderer) — a companion renderer + linter that replicates Apple's QuickLook output pixel for pixel, runs on Linux/Docker without a Mac.
 
 ```bash
-# Lint (12 rules, JSON output for CI)
+# Lint (JSON output for CI)
 npx quicklook-pptx lint presentation.pptx --json
 
 # Render slides as PNG (see exactly what Mac users see)

package/dist/analyze.d.ts

@@ -2,4 +2,4 @@
  * Analyze a PPTX for issues that will cause QuickLook rendering problems.
  * Delegates to quicklook-pptx-renderer's linter — single source of truth.
  */
-export { lint as analyze, formatIssues, type LintResult, type LintIssue } from "quicklook-pptx-renderer";
+export { lint as analyze, formatIssues, type LintResult, type LintIssue, type LintFix } from "quicklook-pptx-renderer";

package/dist/chart-fallbacks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Chart fallback generator — render charts to PNG and embed as fallback
+ * images so QuickLook displays charts instead of blank rectangles.
+ *
+ * QuickLook (OfficeImport) doesn't parse chart XML — it only uses
+ * pre-rendered fallback images stored in the PPTX. Tools like python-pptx
+ * and PptxGenJS don't generate these fallback images.
+ *
+ * Uses Playwright to screenshot chart HTML rendered by quicklook-pptx-renderer.
+ * Playwright is a dynamic import — if not installed, this step is skipped.
+ */
+import type JSZip from "jszip";
+/**
+ * Add fallback images to charts that don't have them.
+ * Requires Playwright — skips silently if not installed.
+ */
+export declare function addChartFallbacks(zip: JSZip, pptxBuffer: Buffer, reportLines: string[]): Promise<void>;

package/dist/chart-fallbacks.js

@@ -0,0 +1,221 @@
+/**
+ * Chart fallback generator — render charts to PNG and embed as fallback
+ * images so QuickLook displays charts instead of blank rectangles.
+ *
+ * QuickLook (OfficeImport) doesn't parse chart XML — it only uses
+ * pre-rendered fallback images stored in the PPTX. Tools like python-pptx
+ * and PptxGenJS don't generate these fallback images.
+ *
+ * Uses Playwright to screenshot chart HTML rendered by quicklook-pptx-renderer.
+ * Playwright is a dynamic import — if not installed, this step is skipped.
+ */
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+const CHART_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+const IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+const relsParserOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    parseTagValue: false,
+    parseAttributeValue: false,
+    isArray: (name) => name === "Relationship",
+};
+const relsBuilderOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    suppressEmptyNode: false,
+};
+/** Find charts without fallback images in the PPTX. */
+async function findChartsWithoutFallback(zip) {
+    const parser = new XMLParser(relsParserOptions);
+    const results = [];
+    const slideFiles = Object.keys(zip.files)
+        .filter(f => /^ppt\/slides\/slide\d+\.xml$/.test(f))
+        .sort();
+    for (const slidePath of slideFiles) {
+        const slideNum = parseInt(slidePath.match(/\d+/)[0]);
+        // Read slide rels
+        const slideRelsPath = slidePath.replace("slides/", "slides/_rels/").replace(".xml", ".xml.rels");
+        const slideRelsFile = zip.file(slideRelsPath);
+        if (!slideRelsFile)
+            continue;
+        const slideRels = parser.parse(await slideRelsFile.async("string"));
+        const rels = slideRels.Relationships?.Relationship ?? [];
+        // Find chart relationships
+        const chartRels = rels.filter((r) => r["@_Type"]?.includes("/chart") || r["@_Type"] === CHART_REL_TYPE);
+        for (const chartRel of chartRels) {
+            const target = chartRel["@_Target"];
+            if (!target)
+                continue;
+            // Resolve chart path relative to slide
+            const chartPath = target.startsWith("../")
+                ? "ppt/" + target.slice(3)
+                : "ppt/slides/" + target;
+            // Check if chart already has a fallback image
+            const chartRelsPath = chartPath.replace(/([^/]+)$/, "_rels/$1.rels");
+            const chartRelsFile = zip.file(chartRelsPath);
+            if (chartRelsFile) {
+                const chartRelsXml = parser.parse(await chartRelsFile.async("string"));
+                const chartRelsList = chartRelsXml.Relationships?.Relationship ?? [];
+                const hasImage = chartRelsList.some((r) => r["@_Type"]?.includes("/image") || r["@_Type"] === IMAGE_REL_TYPE);
+                if (hasImage)
+                    continue; // Already has fallback
+            }
+            // Get chart bounds from slide XML
+            const slideXmlStr = await zip.file(slidePath).async("string");
+            const slideXml = parser.parse(slideXmlStr);
+            const bounds = findChartBounds(slideXml, chartRel["@_Id"]);
+            if (!bounds)
+                continue;
+            results.push({ slideNum, chartPath, chartRelsPath, bounds });
+        }
+    }
+    return results;
+}
+/** Find the graphicFrame bounds for a chart by its relationship ID. */
+function findChartBounds(slideXml, rId) {
+    const frames = findGraphicFrames(slideXml);
+    for (const frame of frames) {
+        const chartRef = frame.graphic?.graphicData?.chart;
+        if (!chartRef)
+            continue;
+        if (chartRef["@_id"] === rId || chartRef["@_r:id"] === rId) {
+            const xfrm = frame.xfrm;
+            if (!xfrm?.off || !xfrm?.ext)
+                continue;
+            return {
+                x: Number(xfrm.off["@_x"] ?? 0),
+                y: Number(xfrm.off["@_y"] ?? 0),
+                cx: Number(xfrm.ext["@_cx"] ?? 0),
+                cy: Number(xfrm.ext["@_cy"] ?? 0),
+            };
+        }
+    }
+    return null;
+}
+function findGraphicFrames(node) {
+    const results = [];
+    if (!node || typeof node !== "object")
+        return results;
+    if (node.graphicFrame) {
+        const frames = Array.isArray(node.graphicFrame) ? node.graphicFrame : [node.graphicFrame];
+        results.push(...frames);
+    }
+    for (const key of Object.keys(node)) {
+        if (key.startsWith("@_"))
+            continue;
+        const children = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const child of children) {
+            results.push(...findGraphicFrames(child));
+        }
+    }
+    return results;
+}
+/** Render a chart to PNG using Playwright and the renderer. */
+async function renderChartToPng(pptxBuffer, chart, chromium) {
+    const { PptxPackage, readPresentation, generateHtml } = await import("quicklook-pptx-renderer");
+    const pkg = await PptxPackage.open(pptxBuffer);
+    const pres = await readPresentation(pkg);
+    const { html } = await generateHtml(pres, { pkg });
+    const EMU_PER_PX = 12700;
+    const slideWidth = pres.slideSize.cx / EMU_PER_PX;
+    const slideHeight = pres.slideSize.cy / EMU_PER_PX;
+    const browser = await chromium.launch();
+    try {
+        const page = await browser.newPage({ viewport: { width: Math.ceil(slideWidth), height: Math.ceil(slideHeight) } });
+        await page.setContent(html, { waitUntil: "networkidle" });
+        // Navigate to the correct slide (slides are stacked vertically in the HTML)
+        const slideSelector = `.slide:nth-child(${chart.slideNum})`;
+        const slideEl = await page.$(slideSelector);
+        if (slideEl)
+            await slideEl.scrollIntoViewIfNeeded();
+        const clip = {
+            x: chart.bounds.x / EMU_PER_PX,
+            y: chart.bounds.y / EMU_PER_PX + (chart.slideNum - 1) * slideHeight,
+            width: chart.bounds.cx / EMU_PER_PX,
+            height: chart.bounds.cy / EMU_PER_PX,
+        };
+        const png = await page.screenshot({ clip, type: "png" });
+        return Buffer.from(png);
+    }
+    finally {
+        await browser.close();
+    }
+}
+/** Embed a fallback PNG for a chart into the PPTX zip. */
+async function embedFallback(zip, chart, png, index) {
+    const parser = new XMLParser(relsParserOptions);
+    const builder = new XMLBuilder(relsBuilderOptions);
+    // Add PNG to media folder
+    const mediaPath = `ppt/media/chart${index}-fallback.png`;
+    zip.file(mediaPath, png);
+    // Get or create chart rels
+    const chartRelsFile = zip.file(chart.chartRelsPath);
+    let relsXml;
+    if (chartRelsFile) {
+        relsXml = parser.parse(await chartRelsFile.async("string"));
+    }
+    else {
+        relsXml = {
+            Relationships: {
+                "@_xmlns": "http://schemas.openxmlformats.org/package/2006/relationships",
+                Relationship: [],
+            },
+        };
+    }
+    if (!relsXml.Relationships)
+        relsXml.Relationships = { "@_xmlns": "http://schemas.openxmlformats.org/package/2006/relationships" };
+    if (!relsXml.Relationships.Relationship)
+        relsXml.Relationships.Relationship = [];
+    if (!Array.isArray(relsXml.Relationships.Relationship)) {
+        relsXml.Relationships.Relationship = [relsXml.Relationships.Relationship];
+    }
+    // Compute relative path from chart to media
+    const chartDir = chart.chartPath.replace(/[^/]+$/, "");
+    const relTarget = "../" + mediaPath.slice(4); // strip "ppt/"
+    const rId = `rId${relsXml.Relationships.Relationship.length + 1}`;
+    relsXml.Relationships.Relationship.push({
+        "@_Id": rId,
+        "@_Type": IMAGE_REL_TYPE,
+        "@_Target": relTarget,
+    });
+    zip.file(chart.chartRelsPath, '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' + builder.build(relsXml));
+    // Ensure Content_Types.xml includes png
+    const ctFile = zip.file("[Content_Types].xml");
+    if (ctFile) {
+        let ct = await ctFile.async("string");
+        if (!ct.includes('Extension="png"')) {
+            ct = ct.replace("</Types>", '  <Default Extension="png" ContentType="image/png"/>\n</Types>');
+            zip.file("[Content_Types].xml", ct);
+        }
+    }
+}
+/**
+ * Add fallback images to charts that don't have them.
+ * Requires Playwright — skips silently if not installed.
+ */
+export async function addChartFallbacks(zip, pptxBuffer, reportLines) {
+    let chromium;
+    try {
+        const pw = await import("playwright");
+        chromium = pw.chromium;
+    }
+    catch {
+        return; // Playwright not installed — skip
+    }
+    const charts = await findChartsWithoutFallback(zip);
+    if (charts.length === 0)
+        return;
+    for (let i = 0; i < charts.length; i++) {
+        const chart = charts[i];
+        try {
+            const png = await renderChartToPng(pptxBuffer, chart, chromium);
+            await embedFallback(zip, chart, png, i + 1);
+            reportLines.push(`Slide ${chart.slideNum}: added chart fallback image (${png.length} bytes)`);
+        }
+        catch (err) {
+            reportLines.push(`Slide ${chart.slideNum}: chart fallback failed — ${err.message}`);
+        }
+    }
+}

package/dist/cli.js

@@ -25,6 +25,10 @@ function positional() {
     return out;
 }
 async function main() {
+    if (hasFlag("--version") || hasFlag("-v")) {
+        console.log("0.3.1");
+        process.exit(0);
+    }
     const pos = positional();
     const command = pos[0];
     if (command === "analyze") {

package/dist/embedded-fonts.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strip embedded fonts from a PPTX and replace with cross-platform alternatives.
+ *
+ * QuickLook (OfficeImport) ignores embedded fonts entirely — they bloat the
+ * file and the text renders with system substitutes anyway. This:
+ *  1. Finds the best cross-platform replacement for each embedded font
+ *  2. Replaces all font references across slides and themes
+ *  3. Removes the font data files, embeddedFontLst, rels, and content types
+ */
+import type JSZip from "jszip";
+export declare function stripEmbeddedFonts(zip: JSZip, reportLines: string[]): Promise<void>;

package/dist/embedded-fonts.js

@@ -0,0 +1,170 @@
+/**
+ * Strip embedded fonts from a PPTX and replace with cross-platform alternatives.
+ *
+ * QuickLook (OfficeImport) ignores embedded fonts entirely — they bloat the
+ * file and the text renders with system substitutes anyway. This:
+ *  1. Finds the best cross-platform replacement for each embedded font
+ *  2. Replaces all font references across slides and themes
+ *  3. Removes the font data files, embeddedFontLst, rels, and content types
+ */
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+import { FONT_METRICS, FONT_SUBSTITUTIONS, findClosestFont } from "quicklook-pptx-renderer";
+const SAFE_CANDIDATES = Object.keys(FONT_METRICS).filter(f => !FONT_SUBSTITUTIONS[f]);
+const FONT_ELEMENTS = new Set(["latin", "ea", "cs", "sym", "buFont"]);
+const relsParserOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    parseTagValue: false,
+    parseAttributeValue: false,
+    isArray: (name) => name === "Relationship",
+};
+const relsBuilderOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    suppressEmptyNode: false,
+};
+const presParserOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    parseTagValue: false,
+    parseAttributeValue: false,
+    trimValues: false,
+    isArray: (name) => name === "embeddedFont",
+};
+const presBuilderOptions = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: false,
+    suppressEmptyNode: false,
+    suppressBooleanAttributes: false,
+};
+/** Find the best cross-platform replacement for a font name. */
+function findReplacement(fontName) {
+    if (!FONT_METRICS[fontName])
+        return null;
+    const matches = findClosestFont(fontName, {
+        candidates: SAFE_CANDIDATES,
+        sameCategory: true,
+        limit: 1,
+    });
+    return matches.length > 0 ? matches[0].font : null;
+}
+/** Walk an XML tree and replace typeface attributes matching the replacement map. */
+function replaceTypefaces(node, replacements) {
+    if (!node || typeof node !== "object")
+        return;
+    for (const key of FONT_ELEMENTS) {
+        if (!node[key])
+            continue;
+        const elements = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const el of elements) {
+            const typeface = el["@_typeface"];
+            if (typeface && replacements.has(typeface)) {
+                el["@_typeface"] = replacements.get(typeface);
+            }
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key.startsWith("@_") || FONT_ELEMENTS.has(key))
+            continue;
+        const children = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const child of children) {
+            replaceTypefaces(child, replacements);
+        }
+    }
+}
+export async function stripEmbeddedFonts(zip, reportLines) {
+    const presFile = zip.file("ppt/presentation.xml");
+    if (!presFile)
+        return;
+    const parser = new XMLParser(presParserOptions);
+    const presXml = parser.parse(await presFile.async("string"));
+    const presNode = presXml?.Presentation ?? presXml?.presentation ?? presXml;
+    if (!presNode)
+        return;
+    const embFontLst = presNode.embeddedFontLst?.embeddedFont;
+    if (!embFontLst)
+        return;
+    const entries = Array.isArray(embFontLst) ? embFontLst : [embFontLst];
+    if (entries.length === 0)
+        return;
+    // Build replacement map and collect rIds to remove
+    const replacements = new Map();
+    const fontNames = [];
+    const rIdsToRemove = new Set();
+    for (const entry of entries) {
+        const typeface = entry.font?.["@_typeface"];
+        if (typeface) {
+            fontNames.push(typeface);
+            const replacement = findReplacement(typeface);
+            if (replacement)
+                replacements.set(typeface, replacement);
+        }
+        for (const variant of ["regular", "bold", "italic", "boldItalic"]) {
+            const rId = entry[variant]?.["@_id"];
+            if (rId)
+                rIdsToRemove.add(rId);
+        }
+    }
+    if (rIdsToRemove.size === 0)
+        return;
+    // Replace font references across slides and themes
+    if (replacements.size > 0) {
+        const xmlFiles = Object.keys(zip.files).filter(f => /^ppt\/(slides\/slide|theme\/theme)\d+\.xml$/.test(f));
+        for (const path of xmlFiles) {
+            const xml = await zip.file(path).async("string");
+            const parsed = parser.parse(xml);
+            replaceTypefaces(parsed, replacements);
+            const builder = new XMLBuilder(presBuilderOptions);
+            zip.file(path, builder.build(parsed));
+        }
+    }
+    // Remove embeddedFontLst from presentation XML
+    delete presNode.embeddedFontLst;
+    const builder = new XMLBuilder(presBuilderOptions);
+    zip.file("ppt/presentation.xml", builder.build(presXml));
+    // Remove font files via presentation rels
+    const relsPath = "ppt/_rels/presentation.xml.rels";
+    const relsFile = zip.file(relsPath);
+    if (relsFile) {
+        const relsParser = new XMLParser(relsParserOptions);
+        const relsXml = relsParser.parse(await relsFile.async("string"));
+        const rels = relsXml?.Relationships?.Relationship ?? [];
+        const kept = [];
+        for (const rel of rels) {
+            if (rIdsToRemove.has(rel["@_Id"])) {
+                const target = rel["@_Target"];
+                const resolved = target.startsWith("/")
+                    ? target.slice(1)
+                    : "ppt/" + (target.startsWith("../") ? target.slice(3) : target);
+                zip.remove(resolved);
+            }
+            else {
+                kept.push(rel);
+            }
+        }
+        relsXml.Relationships.Relationship = kept;
+        const relsBuilder = new XMLBuilder(relsBuilderOptions);
+        zip.file(relsPath, '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' + relsBuilder.build(relsXml));
+    }
+    // Clean up Content_Types.xml — remove fntdata entries if no font files remain
+    const hasFontFiles = Object.keys(zip.files).some(f => f.endsWith(".fntdata"));
+    if (!hasFontFiles) {
+        const ctFile = zip.file("[Content_Types].xml");
+        if (ctFile) {
+            let ct = await ctFile.async("string");
+            ct = ct.replace(/<Default[^>]*Extension="fntdata"[^>]*\/>\s*/g, "");
+            ct = ct.replace(/<Override[^>]*PartName="[^"]*\/fonts\/[^"]*"[^>]*\/>\s*/g, "");
+            zip.file("[Content_Types].xml", ct);
+        }
+    }
+    // Report
+    const details = fontNames.map(f => {
+        const r = replacements.get(f);
+        return r ? `"${f}" → "${r}"` : `"${f}" (stripped)`;
+    }).join(", ");
+    reportLines.push(`embedded fonts: ${details}`);
+}

package/dist/index.d.ts

@@ -6,6 +6,6 @@
  * output is a valid PPTX that looks correct in Apple's OfficeImport pipeline.
  */
 export { fix, type FixOptions, type FixResult } from "./writer.js";
-export { analyze, formatIssues, type LintResult, type LintIssue } from "./analyze.js";
+export { analyze, formatIssues, type LintResult, type LintIssue, type LintFix } from "./analyze.js";
 export { type TransformName, ALL_TRANSFORMS } from "./transforms/index.js";
-export { FONT_METRICS, findClosestFont, widthDelta, type FontMetrics, type FontMatch, type FontCategory } from "quicklook-pptx-renderer";
+export { FONT_METRICS, FONT_SUBSTITUTIONS, SUPPORTED_GEOMETRIES, GEOMETRY_FALLBACKS, findClosestFont, widthDelta, type FontMetrics, type FontMatch, type FontCategory, } from "quicklook-pptx-renderer";

package/dist/index.js

@@ -8,4 +8,4 @@
 export { fix } from "./writer.js";
 export { analyze, formatIssues } from "./analyze.js";
 export { ALL_TRANSFORMS } from "./transforms/index.js";
-export { FONT_METRICS, findClosestFont, widthDelta } from "quicklook-pptx-renderer";
+export { FONT_METRICS, FONT_SUBSTITUTIONS, SUPPORTED_GEOMETRIES, GEOMETRY_FALLBACKS, findClosestFont, widthDelta, } from "quicklook-pptx-renderer";

package/dist/transforms/effects.d.ts

@@ -1,6 +1,6 @@
 /**
- * effects transform — Strip or adjust shapes with effectLst that render
- * as opaque PDF blocks in QuickLook.
+ * effects transform — Strip effectLst/effectDag from shape properties so
+ * shapes render as CSS instead of opaque PDF blocks in QuickLook.
  *
  * Detection is handled by quicklook-pptx-renderer's linter (opaque-pdf-block rule).
  */

package/dist/transforms/effects.js

@@ -1,13 +1,53 @@
 /**
- * effects transform — Strip or adjust shapes with effectLst that render
- * as opaque PDF blocks in QuickLook.
+ * effects transform — Strip effectLst/effectDag from shape properties so
+ * shapes render as CSS instead of opaque PDF blocks in QuickLook.
  *
  * Detection is handled by quicklook-pptx-renderer's linter (opaque-pdf-block rule).
  */
+function stripEffects(node, changes) {
+    if (!node || typeof node !== "object")
+        return;
+    // Shape elements: sp, cxnSp, pic
+    const shapeKeys = ["sp", "cxnSp", "pic"];
+    for (const key of shapeKeys) {
+        if (!node[key])
+            continue;
+        const shapes = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const shape of shapes) {
+            const spPr = shape.spPr;
+            if (!spPr)
+                continue;
+            const name = shape.nvSpPr?.cNvPr?.["@_name"]
+                ?? shape.nvCxnSpPr?.cNvPr?.["@_name"]
+                ?? shape.nvPicPr?.cNvPr?.["@_name"]
+                ?? "shape";
+            if (spPr.effectLst) {
+                delete spPr.effectLst;
+                changes.push(`stripped effects from "${name}"`);
+            }
+            if (spPr.effectDag) {
+                delete spPr.effectDag;
+                changes.push(`stripped effect DAG from "${name}"`);
+            }
+        }
+    }
+    // Groups: recurse into grpSp children
+    if (node.grpSp) {
+        const groups = Array.isArray(node.grpSp) ? node.grpSp : [node.grpSp];
+        for (const group of groups) {
+            stripEffects(group, changes);
+        }
+    }
+    // Recurse into spTree (the slide's shape tree)
+    if (node.spTree) {
+        stripEffects(node.spTree, changes);
+    }
+}
 export const effects = {
     name: "effects",
-    apply(_slideXml, _slideNum, _ctx) {
-        // TODO: configurable — strip effects, reorder z-index, or no-op
-        return { changed: false, changes: [] };
+    apply(slideXml, _slideNum, _ctx) {
+        const changes = [];
+        stripEffects(slideXml, changes);
+        return { changed: changes.length > 0, changes };
     },
 };

package/dist/transforms/fonts.d.ts

@@ -1,6 +1,13 @@
 /**
- * fonts transform — Add explicit <a:latin>, <a:ea>, <a:cs> fallback
- * typefaces matching what OfficeImport's TCFontUtils would pick.
+ * fonts transform — Replace high-risk Windows fonts with metrically-closest
+ * cross-platform alternatives to prevent text reflow on macOS.
+ *
+ * macOS substitutes Windows fonts (Calibri → Helvetica Neue +14.4%, etc.)
+ * with different-width fonts, causing text overflow and line breaks to shift.
+ * This replaces those fonts with cross-platform safe fonts that have minimal
+ * width delta on macOS, chosen by the findClosestFont similarity algorithm.
+ *
+ * Detection is handled by quicklook-pptx-renderer's linter (font-substitution rule).
  */
 import type { Transform } from "./index.js";
 export declare const fonts: Transform;

package/dist/transforms/fonts.js

@@ -1,15 +1,75 @@
 /**
- * fonts transform — Add explicit <a:latin>, <a:ea>, <a:cs> fallback
- * typefaces matching what OfficeImport's TCFontUtils would pick.
+ * fonts transform — Replace high-risk Windows fonts with metrically-closest
+ * cross-platform alternatives to prevent text reflow on macOS.
+ *
+ * macOS substitutes Windows fonts (Calibri → Helvetica Neue +14.4%, etc.)
+ * with different-width fonts, causing text overflow and line breaks to shift.
+ * This replaces those fonts with cross-platform safe fonts that have minimal
+ * width delta on macOS, chosen by the findClosestFont similarity algorithm.
+ *
+ * Detection is handled by quicklook-pptx-renderer's linter (font-substitution rule).
  */
+import { FONT_METRICS, FONT_SUBSTITUTIONS, findClosestFont, widthDelta } from "quicklook-pptx-renderer";
+const DELTA_THRESHOLD = 10;
+// Fonts available on macOS — everything in the metrics DB except Windows-only
+const SAFE_CANDIDATES = Object.keys(FONT_METRICS).filter(f => !FONT_SUBSTITUTIONS[f]);
+const replacementCache = new Map();
+function getReplacement(fontName) {
+    if (replacementCache.has(fontName))
+        return replacementCache.get(fontName);
+    const macSub = FONT_SUBSTITUTIONS[fontName];
+    const srcMetrics = FONT_METRICS[fontName];
+    const subMetrics = macSub ? FONT_METRICS[macSub] : undefined;
+    if (!macSub || !srcMetrics || !subMetrics || Math.abs(widthDelta(srcMetrics, subMetrics)) < DELTA_THRESHOLD) {
+        replacementCache.set(fontName, null);
+        return null;
+    }
+    const matches = findClosestFont(fontName, {
+        candidates: SAFE_CANDIDATES,
+        sameCategory: true,
+        limit: 1,
+    });
+    const result = matches.length > 0 ? matches[0].font : null;
+    replacementCache.set(fontName, result);
+    return result;
+}
+const FONT_ELEMENTS = new Set(["latin", "ea", "cs", "sym", "buFont"]);
+function replaceFonts(node, seen, changes) {
+    if (!node || typeof node !== "object")
+        return;
+    for (const key of FONT_ELEMENTS) {
+        if (!node[key])
+            continue;
+        const elements = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const el of elements) {
+            const typeface = el["@_typeface"];
+            if (!typeface || typeface.startsWith("+"))
+                continue;
+            const replacement = getReplacement(typeface);
+            if (replacement) {
+                el["@_typeface"] = replacement;
+                if (!seen.has(typeface)) {
+                    seen.add(typeface);
+                    changes.push(`replaced font "${typeface}" ��� "${replacement}"`);
+                }
+            }
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key.startsWith("@_") || FONT_ELEMENTS.has(key))
+            continue;
+        const children = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const child of children) {
+            replaceFonts(child, seen, changes);
+        }
+    }
+}
 export const fonts = {
     name: "fonts",
-    detect(_slideXml, _slideNum) {
-        // TODO: detect text runs missing explicit font declarations
-        return [];
-    },
-    apply(_slideXml, _slideNum, _ctx) {
-        // TODO: implement — add fallback typefaces
-        return { changed: false, changes: [] };
+    apply(slideXml, _slideNum, _ctx) {
+        const changes = [];
+        const seen = new Set();
+        replaceFonts(slideXml, seen, changes);
+        return { changed: changes.length > 0, changes };
     },
 };

package/dist/transforms/geometries.d.ts

@@ -1,6 +1,6 @@
 /**
- * geometries transform — Replace unsupported preset geometries with
- * equivalent <a:custGeom> path data.
+ * geometries transform — Replace unsupported preset geometries with the
+ * visually-closest supported alternative so shapes are visible in QuickLook.
  *
  * Detection is handled by quicklook-pptx-renderer's linter (unsupported-geometry rule).
  */

package/dist/transforms/geometries.js

@@ -1,13 +1,43 @@
 /**
- * geometries transform — Replace unsupported preset geometries with
- * equivalent <a:custGeom> path data.
+ * geometries transform — Replace unsupported preset geometries with the
+ * visually-closest supported alternative so shapes are visible in QuickLook.
  *
  * Detection is handled by quicklook-pptx-renderer's linter (unsupported-geometry rule).
  */
+import { SUPPORTED_GEOMETRIES, GEOMETRY_FALLBACKS } from "quicklook-pptx-renderer";
+function fixGeometries(node, changes) {
+    if (!node || typeof node !== "object")
+        return;
+    if (node.sp) {
+        const shapes = Array.isArray(node.sp) ? node.sp : [node.sp];
+        for (const shape of shapes) {
+            const spPr = shape.spPr;
+            if (!spPr?.prstGeom)
+                continue;
+            const prst = spPr.prstGeom["@_prst"];
+            if (!prst || SUPPORTED_GEOMETRIES.has(prst))
+                continue;
+            const fallback = GEOMETRY_FALLBACKS[prst] ?? "rect";
+            const name = shape.nvSpPr?.cNvPr?.["@_name"] ?? "shape";
+            spPr.prstGeom["@_prst"] = fallback;
+            changes.push(`replaced unsupported geometry "${prst}" with ${fallback} on "${name}"`);
+        }
+    }
+    if (node.grpSp) {
+        const groups = Array.isArray(node.grpSp) ? node.grpSp : [node.grpSp];
+        for (const group of groups) {
+            fixGeometries(group, changes);
+        }
+    }
+    if (node.spTree) {
+        fixGeometries(node.spTree, changes);
+    }
+}
 export const geometries = {
     name: "geometries",
-    apply(_slideXml, _slideNum, _ctx) {
-        // TODO: replace prstGeom with custGeom containing equivalent path data
-        return { changed: false, changes: [] };
+    apply(slideXml, _slideNum, _ctx) {
+        const changes = [];
+        fixGeometries(slideXml, changes);
+        return { changed: changes.length > 0, changes };
     },
 };

package/dist/transforms/gradients.js

@@ -4,10 +4,36 @@
  *
  * Detection is handled by quicklook-pptx-renderer's linter (gradient-flattened rule).
  */
+function collapseGradients(node, changes, slideNum) {
+    if (!node || typeof node !== "object")
+        return;
+    if (node.gradFill) {
+        const fills = Array.isArray(node.gradFill) ? node.gradFill : [node.gradFill];
+        for (const fill of fills) {
+            const gsLst = fill.gsLst;
+            if (!gsLst)
+                continue;
+            const stops = gsLst.gs;
+            if (!Array.isArray(stops) || stops.length < 3)
+                continue;
+            gsLst.gs = [stops[0], stops[stops.length - 1]];
+            changes.push(`collapsed ${stops.length}-stop gradient to 2 stops`);
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key.startsWith("@_"))
+            continue;
+        const children = Array.isArray(node[key]) ? node[key] : [node[key]];
+        for (const child of children) {
+            collapseGradients(child, changes, slideNum);
+        }
+    }
+}
 export const gradients = {
     name: "gradients",
-    apply(_slideXml, _slideNum, _ctx) {
-        // TODO: collapse 3+ stop gradients to 2-stop (endpoints only)
-        return { changed: false, changes: [] };
+    apply(slideXml, slideNum, _ctx) {
+        const changes = [];
+        collapseGradients(slideXml, changes, slideNum);
+        return { changed: changes.length > 0, changes };
     },
 };

package/dist/transforms/groups.d.ts

@@ -0,0 +1,12 @@
+/**
+ * groups transform — Ungroup shape groups so children render individually
+ * instead of being merged into a single opaque PDF block by QuickLook.
+ *
+ * Coordinate math: each child's position is relative to the group's
+ * chOff/chExt (child coordinate space). To ungroup, we transform each
+ * child's coordinates from group-space to slide-space.
+ *
+ * Detection is handled by quicklook-pptx-renderer's linter (group-as-pdf rule).
+ */
+import type { Transform } from "./index.js";
+export declare const groups: Transform;

package/dist/transforms/groups.js

@@ -0,0 +1,103 @@
+/**
+ * groups transform — Ungroup shape groups so children render individually
+ * instead of being merged into a single opaque PDF block by QuickLook.
+ *
+ * Coordinate math: each child's position is relative to the group's
+ * chOff/chExt (child coordinate space). To ungroup, we transform each
+ * child's coordinates from group-space to slide-space.
+ *
+ * Detection is handled by quicklook-pptx-renderer's linter (group-as-pdf rule).
+ */
+const CHILD_KEYS = ["sp", "pic", "cxnSp", "graphicFrame"];
+function getXfrm(child, key) {
+    if (key === "graphicFrame")
+        return child.xfrm;
+    return child.spPr?.xfrm;
+}
+function transformCoords(xfrm, groupOff, groupExt, chOff, chExt) {
+    const off = xfrm.off;
+    const ext = xfrm.ext;
+    if (!off || !ext)
+        return;
+    const scaleX = chExt.cx > 0 ? groupExt.cx / chExt.cx : 1;
+    const scaleY = chExt.cy > 0 ? groupExt.cy / chExt.cy : 1;
+    off["@_x"] = String(Math.round(groupOff.x + (Number(off["@_x"] ?? 0) - chOff.x) * scaleX));
+    off["@_y"] = String(Math.round(groupOff.y + (Number(off["@_y"] ?? 0) - chOff.y) * scaleY));
+    ext["@_cx"] = String(Math.round(Number(ext["@_cx"] ?? 0) * scaleX));
+    ext["@_cy"] = String(Math.round(Number(ext["@_cy"] ?? 0) * scaleY));
+}
+function ensureArray(parent, key) {
+    if (!parent[key])
+        parent[key] = [];
+    if (!Array.isArray(parent[key]))
+        parent[key] = [parent[key]];
+    return parent[key];
+}
+function ungroupInto(parent, changes) {
+    if (!parent.grpSp)
+        return;
+    const groups = Array.isArray(parent.grpSp) ? parent.grpSp : [parent.grpSp];
+    const kept = [];
+    for (const group of groups) {
+        // Recurse into nested groups first (ungroup from inside out)
+        ungroupInto(group, changes);
+        const xfrm = group.grpSpPr?.xfrm;
+        if (!xfrm?.off || !xfrm?.ext || !xfrm?.chOff || !xfrm?.chExt) {
+            kept.push(group);
+            continue;
+        }
+        // Skip groups with rotation — ungrouping would lose the visual effect
+        if (xfrm["@_rot"] && Number(xfrm["@_rot"]) !== 0) {
+            kept.push(group);
+            continue;
+        }
+        const groupOff = { x: Number(xfrm.off["@_x"] ?? 0), y: Number(xfrm.off["@_y"] ?? 0) };
+        const groupExt = { cx: Number(xfrm.ext["@_cx"] ?? 1), cy: Number(xfrm.ext["@_cy"] ?? 1) };
+        const chOff = { x: Number(xfrm.chOff["@_x"] ?? 0), y: Number(xfrm.chOff["@_y"] ?? 0) };
+        const chExt = { cx: Number(xfrm.chExt["@_cx"] ?? 1), cy: Number(xfrm.chExt["@_cy"] ?? 1) };
+        const name = group.nvGrpSpPr?.cNvPr?.["@_name"] ?? "group";
+        let childCount = 0;
+        for (const key of CHILD_KEYS) {
+            if (!group[key])
+                continue;
+            const children = Array.isArray(group[key]) ? group[key] : [group[key]];
+            const target = ensureArray(parent, key);
+            for (const child of children) {
+                const childXfrm = getXfrm(child, key);
+                if (childXfrm)
+                    transformCoords(childXfrm, groupOff, groupExt, chOff, chExt);
+                target.push(child);
+                childCount++;
+            }
+        }
+        // Any nested groups that couldn't be ungrouped stay as top-level groups
+        if (group.grpSp) {
+            const nested = Array.isArray(group.grpSp) ? group.grpSp : [group.grpSp];
+            for (const ng of nested) {
+                const ngXfrm = ng.grpSpPr?.xfrm;
+                if (ngXfrm)
+                    transformCoords(ngXfrm, groupOff, groupExt, chOff, chExt);
+                kept.push(ng);
+            }
+        }
+        if (childCount > 0) {
+            changes.push(`ungrouped "${name}" (${childCount} children)`);
+        }
+    }
+    if (kept.length > 0) {
+        parent.grpSp = kept;
+    }
+    else {
+        delete parent.grpSp;
+    }
+}
+export const groups = {
+    name: "groups",
+    apply(slideXml, _slideNum, _ctx) {
+        const changes = [];
+        const spTree = slideXml?.sld?.cSld?.spTree ?? slideXml?.cSld?.spTree;
+        if (spTree)
+            ungroupInto(spTree, changes);
+        return { changed: changes.length > 0, changes };
+    },
+};

package/dist/transforms/index.d.ts

@@ -5,7 +5,7 @@
  * Detection is handled by quicklook-pptx-renderer's linter.
  * These transforms only apply fixes.
  */
-export type TransformName = "table-styles" | "gradients" | "geometries" | "effects";
+export type TransformName = "table-styles" | "gradients" | "geometries" | "effects" | "fonts" | "groups" | "embedded-fonts";
 export interface TransformContext {
     tableStyleXml?: any;
 }

package/dist/transforms/index.js

@@ -9,9 +9,13 @@ import { tableStyles } from "./table-styles.js";
 import { gradients } from "./gradients.js";
 import { geometries } from "./geometries.js";
 import { effects } from "./effects.js";
+import { fonts } from "./fonts.js";
+import { groups } from "./groups.js";
 export const ALL_TRANSFORMS = [
     tableStyles,
     gradients,
     geometries,
     effects,
+    fonts,
+    groups,
 ];

package/dist/writer.js

@@ -8,12 +8,15 @@ import JSZip from "jszip";
 import { XMLParser, XMLBuilder } from "fast-xml-parser";
 import { xmlParserOptions, xmlBuilderOptions } from "./xml.js";
 import { ALL_TRANSFORMS } from "./transforms/index.js";
+import { addChartFallbacks } from "./chart-fallbacks.js";
+import { stripEmbeddedFonts } from "./embedded-fonts.js";
 export async function fix(pptxBuffer, options) {
     const zip = await JSZip.loadAsync(pptxBuffer);
     const parser = new XMLParser(xmlParserOptions);
     const builder = new XMLBuilder(xmlBuilderOptions);
     const reportLines = [];
-    const enabledNames = new Set(options?.transforms ?? ALL_TRANSFORMS.map(t => t.name));
+    const allNames = [...ALL_TRANSFORMS.map(t => t.name), "embedded-fonts"];
+    const enabledNames = new Set(options?.transforms ?? allNames);
     const enabled = ALL_TRANSFORMS.filter(t => enabledNames.has(t.name));
     // Find all slide XML files
     const slideFiles = Object.keys(zip.files)
@@ -51,6 +54,28 @@ export async function fix(pptxBuffer, options) {
             zip.file(slidePath, builder.build(parsed));
         }
     }
+    // Process theme XML for font replacement
+    if (enabledNames.has("fonts")) {
+        const fontsTransform = enabled.find(t => t.name === "fonts");
+        const themeFiles = Object.keys(zip.files).filter(f => /^ppt\/theme\/theme\d+\.xml$/.test(f));
+        for (const themePath of themeFiles) {
+            const xml = await zip.file(themePath).async("string");
+            const parsed = parser.parse(xml);
+            const result = fontsTransform.apply(parsed, 0, { tableStyleXml });
+            if (result.changed) {
+                zip.file(themePath, builder.build(parsed));
+                for (const line of result.changes) {
+                    reportLines.push(`Theme: ${line}`);
+                }
+            }
+        }
+    }
+    // Strip embedded fonts (QuickLook ignores them, they just bloat the file)
+    if (enabledNames.has("embedded-fonts")) {
+        await stripEmbeddedFonts(zip, reportLines);
+    }
+    // Generate chart fallback images (requires Playwright — skips if not installed)
+    await addChartFallbacks(zip, pptxBuffer, reportLines);
     const outBuffer = Buffer.from(await zip.generateAsync({ type: "nodebuffer" }));
     const result = { buffer: outBuffer };
     if (options?.report) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pptx-fix",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Fix PowerPoint files that render incorrectly on macOS QuickLook and iOS — resolves missing table borders, invisible shapes, flattened gradients, and opaque blocks caused by OfficeImport rendering gaps.",
   "type": "module",
   "main": "dist/index.js",
@@ -61,7 +61,7 @@
   "dependencies": {
     "fast-xml-parser": "^5.2.0",
     "jszip": "^3.10.1",
-    "quicklook-pptx-renderer": "^0.2.1"
+    "quicklook-pptx-renderer": "^0.3.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",