quicklook-pptx-renderer 0.1.0

package/dist/reader/presentation.js

@@ -0,0 +1,127 @@
+import { readTheme } from "./theme.js";
+import { readTextListStyle } from "./text-list-style.js";
+export { readTextListStyle };
+import { readSlideMaster } from "./slide-master.js";
+import { readSlideLayout } from "./slide-layout.js";
+import { readSlide } from "./slide.js";
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+function readSize(node) {
+    return {
+        cx: Number(node?.["@_cx"] ?? 0),
+        cy: Number(node?.["@_cy"] ?? 0),
+    };
+}
+function relsByType(rels, type) {
+    return [...rels.values()].filter((r) => r.type === type);
+}
+const EMPTY_THEME = {
+    name: "",
+    colorScheme: { name: "", colors: {} },
+    fontScheme: {
+        name: "",
+        majorFont: { latin: "", eastAsian: "", complexScript: "", scriptFonts: {} },
+        minorFont: { latin: "", eastAsian: "", complexScript: "", scriptFonts: {} },
+    },
+    styleMatrix: { fillStyles: [], lineStyles: [], effectStyles: [], bgFillStyles: [] },
+};
+export async function readPresentation(pkg) {
+    const presXml = await pkg.getPartXml("ppt/presentation.xml");
+    const presNode = presXml?.Presentation ?? presXml?.presentation ?? presXml ?? {};
+    const slideSize = readSize(presNode.sldSz);
+    const notesSize = readSize(presNode.notesSz);
+    const defaultTextStyle = presNode.defaultTextStyle
+        ? readTextListStyle(presNode.defaultTextStyle)
+        : undefined;
+    const presRels = await pkg.getRelationships("ppt/presentation.xml");
+    const layoutsByPath = new Map();
+    // --- Slide masters ---
+    const masterIds = toArray(presNode.sldMasterIdLst?.sldMasterId);
+    const masters = [];
+    for (const mid of masterIds) {
+        // r:id attribute becomes @_id after removeNSPrefix (collides with numeric id, but rId value wins)
+        const rId = mid["@_rId"] ?? mid["@_id"];
+        const rel = presRels.get(rId);
+        if (!rel)
+            continue;
+        const masterPath = pkg.resolveRelTarget("ppt/presentation.xml", rel.target);
+        const masterXml = await pkg.getPartXml(masterPath);
+        if (!masterXml)
+            continue;
+        const masterPartial = readSlideMaster(masterXml);
+        const masterRels = await pkg.getRelationships(masterPath);
+        // Read theme
+        const themeRel = relsByType(masterRels, "theme")[0];
+        let theme = EMPTY_THEME;
+        if (themeRel) {
+            const themePath = pkg.resolveRelTarget(masterPath, themeRel.target);
+            const themeXml = await pkg.getPartXml(themePath);
+            if (themeXml)
+                theme = readTheme(themeXml);
+        }
+        // Read slide layouts for this master
+        const layoutRels = relsByType(masterRels, "slideLayout");
+        const layouts = [];
+        for (const lr of layoutRels) {
+            const layoutPath = pkg.resolveRelTarget(masterPath, lr.target);
+            const layoutXml = await pkg.getPartXml(layoutPath);
+            if (!layoutXml)
+                continue;
+            const layoutPartial = readSlideLayout(layoutXml);
+            const layout = { ...layoutPartial, slideMaster: null };
+            layouts.push(layout);
+            layoutsByPath.set(layoutPath, layout);
+        }
+        const master = {
+            ...masterPartial,
+            theme,
+            slideLayouts: layouts,
+        };
+        // Wire layout->master back-references
+        for (const layout of layouts) {
+            layout.slideMaster = master;
+        }
+        masters.push(master);
+    }
+    // --- Slides ---
+    const slideIds = toArray(presNode.sldIdLst?.sldId);
+    const slides = [];
+    for (const sid of slideIds) {
+        const rId = sid["@_rId"] ?? sid["@_id"];
+        const rel = presRels.get(rId);
+        if (!rel)
+            continue;
+        const slidePath = pkg.resolveRelTarget("ppt/presentation.xml", rel.target);
+        const slideXml = await pkg.getPartXml(slidePath);
+        if (!slideXml)
+            continue;
+        // Pass raw XML so readDrawables can recover document order
+        const rawBuf = await pkg.getPartBuffer(slidePath);
+        const rawXml = rawBuf?.toString("utf8");
+        const slidePartial = readSlide(slideXml, rawXml);
+        const slideRels = await pkg.getRelationships(slidePath);
+        // Find this slide's layout
+        const layoutRel = relsByType(slideRels, "slideLayout")[0];
+        let slideLayout;
+        if (layoutRel) {
+            const layoutPath = pkg.resolveRelTarget(slidePath, layoutRel.target);
+            slideLayout = layoutsByPath.get(layoutPath);
+        }
+        // Fallback: first layout of first master
+        if (!slideLayout && masters.length > 0 && masters[0].slideLayouts.length > 0) {
+            slideLayout = masters[0].slideLayouts[0];
+        }
+        slides.push({
+            ...slidePartial,
+            slideLayout: slideLayout,
+        });
+    }
+    return {
+        slides,
+        slideMasters: masters,
+        slideSize,
+        notesSize,
+        defaultTextStyle,
+    };
+}

package/dist/reader/slide-layout.d.ts

@@ -0,0 +1,2 @@
+import type { SlideLayout } from "../model/types.js";
+export declare function readSlideLayout(xml: any): Omit<SlideLayout, "slideMaster">;

package/dist/reader/slide-layout.js

@@ -0,0 +1,28 @@
+import { readDrawables } from "./drawing.js";
+import { readBackground, readColorMap } from "./slide-master.js";
+function readColorMapOverride(node) {
+    if (node == null)
+        return undefined;
+    if (node.overrideClrMapping)
+        return readColorMap(node.overrideClrMapping);
+    // masterClrMapping means "use master's map" — no override
+    return undefined;
+}
+export function readSlideLayout(xml) {
+    const root = xml.sldLayout ?? xml;
+    const cSld = root.cSld ?? {};
+    const spTree = cSld.spTree ?? {};
+    const result = {
+        drawables: readDrawables(spTree),
+    };
+    const bg = readBackground(cSld.bg);
+    if (bg)
+        result.background = bg;
+    const layoutType = root["@_type"];
+    if (layoutType)
+        result.layoutType = layoutType;
+    const colorMapOverride = readColorMapOverride(root.clrMapOvr);
+    if (colorMapOverride)
+        result.colorMapOverride = colorMapOverride;
+    return result;
+}

package/dist/reader/slide-master.d.ts

@@ -0,0 +1,4 @@
+import type { SlideMaster, ColorMap, Background } from "../model/types.js";
+export declare function readColorMap(node: any): ColorMap;
+export declare function readBackground(node: any): Background | undefined;
+export declare function readSlideMaster(xml: any): Omit<SlideMaster, "theme" | "slideLayouts">;

package/dist/reader/slide-master.js

@@ -0,0 +1,49 @@
+import { readDrawables } from "./drawing.js";
+import { readFill } from "./fill.js";
+import { readTextListStyle } from "./text-list-style.js";
+const COLOR_MAP_KEYS = [
+    "bg1", "tx1", "bg2", "tx2",
+    "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
+    "hlink", "folHlink",
+];
+export function readColorMap(node) {
+    const mappings = {};
+    for (const key of COLOR_MAP_KEYS) {
+        const val = node[`@_${key}`];
+        if (val)
+            mappings[key] = val;
+    }
+    return { mappings };
+}
+export function readBackground(node) {
+    if (node == null)
+        return undefined;
+    const bgPr = node.bgPr;
+    if (bgPr) {
+        const fill = readFill(bgPr);
+        return fill ? { fill } : undefined;
+    }
+    return undefined;
+}
+export function readSlideMaster(xml) {
+    const root = xml.sldMaster ?? xml;
+    const cSld = root.cSld ?? {};
+    const spTree = cSld.spTree ?? {};
+    const result = {
+        drawables: readDrawables(spTree),
+        colorMap: readColorMap(root.clrMap ?? {}),
+    };
+    const bg = readBackground(cSld.bg);
+    if (bg)
+        result.background = bg;
+    const txStyles = root.txStyles;
+    if (txStyles) {
+        if (txStyles.titleStyle)
+            result.titleTextStyle = readTextListStyle(txStyles.titleStyle);
+        if (txStyles.bodyStyle)
+            result.bodyTextStyle = readTextListStyle(txStyles.bodyStyle);
+        if (txStyles.otherStyle)
+            result.otherTextStyle = readTextListStyle(txStyles.otherStyle);
+    }
+    return result;
+}

package/dist/reader/slide.d.ts

@@ -0,0 +1,2 @@
+import type { Slide } from "../model/types.js";
+export declare function readSlide(xml: any, rawXml?: string): Omit<Slide, "slideLayout">;

package/dist/reader/slide.js

@@ -0,0 +1,26 @@
+import { readDrawables } from "./drawing.js";
+import { readBackground, readColorMap } from "./slide-master.js";
+function readColorMapOverride(node) {
+    if (node == null)
+        return undefined;
+    if (node.overrideClrMapping)
+        return readColorMap(node.overrideClrMapping);
+    return undefined;
+}
+export function readSlide(xml, rawXml) {
+    const root = xml.sld ?? xml;
+    const cSld = root.cSld ?? {};
+    const spTree = cSld.spTree ?? {};
+    const result = {
+        drawables: readDrawables(spTree, rawXml),
+    };
+    if (cSld["@_name"])
+        result.name = cSld["@_name"];
+    const bg = readBackground(cSld.bg);
+    if (bg)
+        result.background = bg;
+    const colorMapOverride = readColorMapOverride(root.clrMapOvr);
+    if (colorMapOverride)
+        result.colorMapOverride = colorMapOverride;
+    return result;
+}

package/dist/reader/text-list-style.d.ts

@@ -0,0 +1,2 @@
+import type { TextListStyle } from "../model/types.js";
+export declare function readTextListStyle(node: any): TextListStyle;

package/dist/reader/text-list-style.js

@@ -0,0 +1,9 @@
+import { readParagraphProperties } from "./text.js";
+export function readTextListStyle(node) {
+    const levels = [];
+    for (let i = 1; i <= 9; i++) {
+        const lvl = node[`lvl${i}pPr`];
+        levels.push(lvl ? readParagraphProperties(lvl) : undefined);
+    }
+    return { levels };
+}

package/dist/reader/text.d.ts

@@ -0,0 +1,5 @@
+import type { TextBody, Paragraph, CharacterProperties, ParagraphProperties } from "../model/types.js";
+export declare function readCharacterProperties(rPr: any): CharacterProperties;
+export declare function readParagraphProperties(pPr: any): ParagraphProperties;
+export declare function readParagraph(pNode: any): Paragraph;
+export declare function readTextBody(node: any): TextBody;

package/dist/reader/text.js

@@ -0,0 +1,295 @@
+import { readColor } from "./color.js";
+import { readFill } from "./fill.js";
+import { readEffects } from "./effects.js";
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+function toNum(val) {
+    return val == null ? undefined : Number(val);
+}
+function toBool(val) {
+    return val === "1" || val === "true";
+}
+function readSpacing(node) {
+    if (node == null)
+        return undefined;
+    if (node.spcPct)
+        return { type: "pct", val: Number(node.spcPct["@_val"] ?? 0) };
+    if (node.spcPts)
+        return { type: "pts", val: Number(node.spcPts["@_val"] ?? 0) };
+    return undefined;
+}
+function readLineEnd(node) {
+    if (node == null)
+        return undefined;
+    const type = node["@_type"];
+    if (!type)
+        return undefined;
+    const end = { type };
+    if (node["@_w"])
+        end.width = node["@_w"];
+    if (node["@_len"])
+        end.length = node["@_len"];
+    return end;
+}
+function readStroke(node) {
+    if (node == null)
+        return undefined;
+    const s = {};
+    if (node["@_w"] != null)
+        s.width = Number(node["@_w"]);
+    if (node["@_cap"])
+        s.cap = node["@_cap"];
+    if (node["@_cmpd"])
+        s.compound = node["@_cmpd"];
+    const fill = readFill(node);
+    if (fill)
+        s.fill = fill;
+    if (node.prstDash?.["@_val"])
+        s.dash = node.prstDash["@_val"];
+    if (node.round != null)
+        s.join = "round";
+    else if (node.bevel != null)
+        s.join = "bevel";
+    else if (node.miter != null) {
+        s.join = "miter";
+        if (node.miter["@_lim"] != null)
+            s.miterLimit = Number(node.miter["@_lim"]);
+    }
+    const head = readLineEnd(node.headEnd);
+    const tail = readLineEnd(node.tailEnd);
+    if (head)
+        s.headEnd = head;
+    if (tail)
+        s.tailEnd = tail;
+    return s;
+}
+export function readCharacterProperties(rPr) {
+    const cp = {};
+    if (rPr == null)
+        return cp;
+    if (rPr.latin?.["@_typeface"])
+        cp.latinFont = rPr.latin["@_typeface"];
+    if (rPr.ea?.["@_typeface"])
+        cp.eastAsianFont = rPr.ea["@_typeface"];
+    if (rPr.cs?.["@_typeface"])
+        cp.complexScriptFont = rPr.cs["@_typeface"];
+    if (rPr.sym?.["@_typeface"])
+        cp.symbolFont = rPr.sym["@_typeface"];
+    cp.fontSize = toNum(rPr["@_sz"]);
+    if (rPr["@_b"] != null)
+        cp.bold = toBool(rPr["@_b"]);
+    if (rPr["@_i"] != null)
+        cp.italic = toBool(rPr["@_i"]);
+    if (rPr["@_u"] != null)
+        cp.underline = rPr["@_u"];
+    if (rPr["@_strike"] != null)
+        cp.strikethrough = rPr["@_strike"];
+    if (rPr["@_cap"] != null)
+        cp.caps = rPr["@_cap"];
+    cp.baseline = toNum(rPr["@_baseline"]);
+    cp.spacing = toNum(rPr["@_spc"]);
+    cp.kerning = toNum(rPr["@_kern"]);
+    if (rPr["@_lang"])
+        cp.lang = rPr["@_lang"];
+    if (rPr["@_dirty"] != null)
+        cp.dirty = toBool(rPr["@_dirty"]);
+    const fill = readFill(rPr);
+    if (fill)
+        cp.fill = fill;
+    const highlight = readColor(rPr.highlight ?? rPr.highlightClr);
+    if (highlight)
+        cp.highlight = highlight;
+    const stroke = readStroke(rPr.ln);
+    if (stroke)
+        cp.stroke = stroke;
+    const uFill = readFill(rPr.uFill);
+    if (uFill)
+        cp.underlineFill = uFill;
+    const effects = readEffects(rPr.effectLst);
+    if (effects.length)
+        cp.effects = effects;
+    if (rPr.hlinkClick?.["@_id"])
+        cp.hyperlink = rPr.hlinkClick["@_id"];
+    return cp;
+}
+function readBullet(pPr) {
+    if (pPr.buNone != null)
+        return { type: "none" };
+    if (pPr.buChar != null) {
+        // Decode XML character references (&#xHHHH;) that fast-xml-parser leaves as literal strings
+        const raw = pPr.buChar["@_char"] ?? "";
+        const decoded = raw.replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+            .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10)));
+        return { type: "char", char: decoded };
+    }
+    if (pPr.buAutoNum != null) {
+        const b = {
+            type: "autoNum",
+            autoNumScheme: pPr.buAutoNum["@_type"],
+        };
+        if (pPr.buAutoNum["@_startAt"] != null)
+            b.startAt = Number(pPr.buAutoNum["@_startAt"]);
+        return b;
+    }
+    if (pPr.buBlip != null) {
+        return { type: "blip", blipRId: pPr.buBlip.blip?.["@_embed"] };
+    }
+    return undefined;
+}
+export function readParagraphProperties(pPr) {
+    const pp = readCharacterProperties(pPr?.defRPr);
+    if (pPr == null)
+        return pp;
+    pp.level = toNum(pPr["@_lvl"]);
+    if (pPr["@_algn"])
+        pp.align = pPr["@_algn"];
+    pp.marL = toNum(pPr["@_marL"]);
+    pp.marR = toNum(pPr["@_marR"]);
+    pp.indent = toNum(pPr["@_indent"]);
+    pp.defTabSz = toNum(pPr["@_defTabSz"]);
+    if (pPr["@_rtl"] != null)
+        pp.rtl = toBool(pPr["@_rtl"]);
+    const lnSpc = readSpacing(pPr.lnSpc);
+    if (lnSpc)
+        pp.lineSpacing = lnSpc;
+    const spcBef = readSpacing(pPr.spcBef);
+    if (spcBef)
+        pp.spaceBefore = spcBef;
+    const spcAft = readSpacing(pPr.spcAft);
+    if (spcAft)
+        pp.spaceAfter = spcAft;
+    const bullet = readBullet(pPr);
+    if (bullet)
+        pp.bullet = bullet;
+    const bulletClr = readColor(pPr.buClr);
+    if (bulletClr)
+        pp.bulletColor = bulletClr;
+    if (pPr.buFont?.["@_typeface"])
+        pp.bulletFont = pPr.buFont["@_typeface"];
+    if (pPr.buSzPct?.["@_val"] != null)
+        pp.bulletSizePercent = Number(pPr.buSzPct["@_val"]);
+    if (pPr.buSzPts?.["@_val"] != null)
+        pp.bulletSizePoints = Number(pPr.buSzPts["@_val"]);
+    return pp;
+}
+function readRun(rNode) {
+    const run = {
+        type: "r",
+        text: rNode.t ?? "",
+    };
+    if (rNode.rPr) {
+        const props = readCharacterProperties(rNode.rPr);
+        if (Object.keys(props).length)
+            run.properties = props;
+    }
+    return run;
+}
+function readBreak(brNode) {
+    const br = { type: "br" };
+    if (brNode.rPr) {
+        const props = readCharacterProperties(brNode.rPr);
+        if (Object.keys(props).length)
+            br.properties = props;
+    }
+    return br;
+}
+function readField(fldNode) {
+    const fld = {
+        type: "fld",
+        text: fldNode.t ?? "",
+    };
+    if (fldNode["@_type"])
+        fld.fieldType = fldNode["@_type"];
+    if (fldNode.rPr) {
+        const props = readCharacterProperties(fldNode.rPr);
+        if (Object.keys(props).length)
+            fld.properties = props;
+    }
+    return fld;
+}
+export function readParagraph(pNode) {
+    const runs = [];
+    for (const r of toArray(pNode.r))
+        runs.push(readRun(r));
+    for (const br of toArray(pNode.br))
+        runs.push(readBreak(br));
+    for (const fld of toArray(pNode.fld))
+        runs.push(readField(fld));
+    const para = { runs };
+    if (pNode.pPr) {
+        const props = readParagraphProperties(pNode.pPr);
+        if (Object.keys(props).length)
+            para.properties = props;
+    }
+    if (pNode.endParaRPr) {
+        const ep = readCharacterProperties(pNode.endParaRPr);
+        if (Object.keys(ep).length)
+            para.endParaRPr = ep;
+    }
+    return para;
+}
+function readBodyProperties(bp) {
+    const props = {};
+    if (bp == null)
+        return props;
+    if (bp["@_wrap"])
+        props.wrap = bp["@_wrap"];
+    props.lIns = toNum(bp["@_lIns"]);
+    props.tIns = toNum(bp["@_tIns"]);
+    props.rIns = toNum(bp["@_rIns"]);
+    props.bIns = toNum(bp["@_bIns"]);
+    if (bp["@_anchor"])
+        props.anchor = bp["@_anchor"];
+    if (bp["@_anchorCtr"] != null)
+        props.anchorCtr = toBool(bp["@_anchorCtr"]);
+    if (bp["@_rtlCol"] != null)
+        props.rtlCol = toBool(bp["@_rtlCol"]);
+    if (bp["@_vert"])
+        props.vert = bp["@_vert"];
+    props.rot = toNum(bp["@_rot"]);
+    props.numCol = toNum(bp["@_numCol"]);
+    props.spcCol = toNum(bp["@_spcCol"]);
+    if (bp.noAutofit != null)
+        props.autoFit = "noAutoFit";
+    else if (bp.spAutoFit != null)
+        props.autoFit = "spAutoFit";
+    else if (bp.normAutofit != null) {
+        props.autoFit = "normAutoFit";
+        props.fontScale = toNum(bp.normAutofit["@_fontScale"]);
+        props.lnSpcReduction = toNum(bp.normAutofit["@_lnSpcReduction"]);
+    }
+    return props;
+}
+const LEVEL_TAGS = ["lvl1pPr", "lvl2pPr", "lvl3pPr", "lvl4pPr", "lvl5pPr", "lvl6pPr", "lvl7pPr", "lvl8pPr", "lvl9pPr"];
+function readListStyle(node) {
+    if (node == null)
+        return undefined;
+    const levels = [];
+    let any = false;
+    for (let i = 0; i < LEVEL_TAGS.length; i++) {
+        const lvl = node[LEVEL_TAGS[i]];
+        if (lvl) {
+            levels[i] = readParagraphProperties(lvl);
+            any = true;
+        }
+    }
+    // Also handle defPPr as level 0 fallback
+    if (node.defPPr) {
+        levels[0] = readParagraphProperties(node.defPPr);
+        any = true;
+    }
+    return any ? { levels } : undefined;
+}
+export function readTextBody(node) {
+    const body = {
+        paragraphs: toArray(node.p).map(readParagraph),
+    };
+    const bp = readBodyProperties(node.bodyPr);
+    if (Object.keys(bp).length)
+        body.properties = bp;
+    const ls = readListStyle(node.lstStyle);
+    if (ls)
+        body.listStyle = ls;
+    return body;
+}

package/dist/reader/theme.d.ts

@@ -0,0 +1,2 @@
+import type { Theme } from "../model/types.js";
+export declare function readTheme(xml: any): Theme;

package/dist/reader/theme.js

@@ -0,0 +1,109 @@
+import { readColor } from "./color.js";
+import { readFill } from "./fill.js";
+import { readEffects } from "./effects.js";
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+const SCHEME_COLOR_NAMES = [
+    "dk1", "lt1", "dk2", "lt2",
+    "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
+    "hlink", "folHlink",
+];
+function readColorScheme(node) {
+    const colors = {};
+    for (const name of SCHEME_COLOR_NAMES) {
+        const el = node[name];
+        if (el == null)
+            continue;
+        const c = readColor(el);
+        if (c)
+            colors[name] = c;
+    }
+    return { name: node["@_name"] ?? "", colors };
+}
+function readFontCollection(node) {
+    const scriptFonts = {};
+    for (const f of toArray(node.font)) {
+        if (f["@_script"] && f["@_typeface"]) {
+            scriptFonts[f["@_script"]] = f["@_typeface"];
+        }
+    }
+    return {
+        latin: node.latin?.["@_typeface"] ?? "",
+        eastAsian: node.ea?.["@_typeface"] ?? "",
+        complexScript: node.cs?.["@_typeface"] ?? "",
+        scriptFonts,
+    };
+}
+function readFontScheme(node) {
+    return {
+        name: node["@_name"] ?? "",
+        majorFont: readFontCollection(node.majorFont ?? {}),
+        minorFont: readFontCollection(node.minorFont ?? {}),
+    };
+}
+function readStroke(node) {
+    const s = {};
+    if (node["@_w"] != null)
+        s.width = Number(node["@_w"]);
+    if (node["@_cap"])
+        s.cap = node["@_cap"];
+    if (node["@_cmpd"])
+        s.compound = node["@_cmpd"];
+    const fill = readFill(node);
+    if (fill)
+        s.fill = fill;
+    if (node.prstDash?.["@_val"])
+        s.dash = node.prstDash["@_val"];
+    if (node.round != null)
+        s.join = "round";
+    else if (node.bevel != null)
+        s.join = "bevel";
+    else if (node.miter != null) {
+        s.join = "miter";
+        if (node.miter["@_lim"] != null)
+            s.miterLimit = Number(node.miter["@_lim"]);
+    }
+    return s;
+}
+function readStyleMatrix(node) {
+    const fillStyles = toArray(node.fillStyleLst?.solidFill)
+        .map((n) => readFill({ solidFill: n }))
+        .filter(Boolean);
+    // fillStyleLst can contain mixed fill types; read all children in order
+    const fillStyleLst = node.fillStyleLst ?? {};
+    const allFills = [];
+    for (const key of ["solidFill", "gradFill", "blipFill", "pattFill", "noFill", "grpFill"]) {
+        for (const el of toArray(fillStyleLst[key])) {
+            const f = readFill({ [key]: el });
+            if (f)
+                allFills.push(f);
+        }
+    }
+    const bgFillStyleLst = node.bgFillStyleLst ?? {};
+    const bgFills = [];
+    for (const key of ["solidFill", "gradFill", "blipFill", "pattFill", "noFill", "grpFill"]) {
+        for (const el of toArray(bgFillStyleLst[key])) {
+            const f = readFill({ [key]: el });
+            if (f)
+                bgFills.push(f);
+        }
+    }
+    const lineStyles = toArray(node.lnStyleLst?.ln).map(readStroke);
+    const effectStyles = toArray(node.effectStyleLst?.effectStyle).map((es) => readEffects(es.effectLst));
+    return {
+        fillStyles: allFills,
+        lineStyles: lineStyles,
+        effectStyles,
+        bgFillStyles: bgFills,
+    };
+}
+export function readTheme(xml) {
+    const te = xml.theme?.themeElements ?? xml.themeElements ?? {};
+    return {
+        name: xml.theme?.["@_name"] ?? xml["@_name"] ?? "",
+        colorScheme: readColorScheme(te.clrScheme ?? {}),
+        fontScheme: readFontScheme(te.fontScheme ?? {}),
+        styleMatrix: readStyleMatrix(te.fmtScheme ?? {}),
+    };
+}

package/dist/reader/transform.d.ts

@@ -0,0 +1,2 @@
+import type { OrientedBounds } from "../model/types.js";
+export declare function readTransform(xfrm: any): OrientedBounds | undefined;