reamkit 1.9.0 → 1.10.0

package/README.md

@@ -30,7 +30,7 @@ import { Ream } from 'reamkit';
 // e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
 const bytes = new Uint8Array(await file.arrayBuffer());
 
-const doc = Ream.parse(bytes);            // docx, xlsx or pdf — sniffed
+const doc = Ream.parse(bytes);            // docx, xlsx, pptx or pdf — sniffed
 const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
@@ -130,7 +130,7 @@ rendering — inspect or analyze it without converting:
 
 ```ts
 const doc = Ream.parse(bytes);
-doc.format;     // 'docx' | 'xlsx' | 'pdf'
+doc.format;     // 'docx' | 'xlsx' | 'pptx' | 'pdf'
 doc.flow.body;  // paragraphs / tables / images / charts …
 doc.losses;     // read-time losses
 ```
@@ -187,6 +187,12 @@ gradient vector shapes. It reads modern compressed files (cross-reference + obje
 streams) and encrypted ones (RC4 / AES — the user password is passed to
 `Ream.parse(bytes, { password })`, defaulting to the permissions-only case).
 
+**Reads PowerPoint, too.** `Ream.parse` accepts a `.pptx` and turns each slide
+into a page at the deck size — text boxes (with run formatting, alignment,
+bullets and indents), layout/master placeholders, pictures, shapes, DrawingML
+tables, embedded charts, theme colours, slide backgrounds, grouped shapes and
+hyperlinks — then converts onward to PDF, SVG, HTML or DOCX like any source.
+
 See [`CHANGELOG.md`](./CHANGELOG.md) for the release history; the docs
 [**Scope**](https://reamkit.dev/guides/scope/) guide has the full feature matrix
 and known limitations.

package/dist/esm/core/converter/facade.js

@@ -13,6 +13,7 @@ import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
 import { convertXlsxToPdf } from "../../excel/xlsx-to-pdf.js";
+import { pptxReader } from "../../pptx/pptx-reader.js";
 import { pdfReader } from "../../pdf-reader/reader.js";
 //#region src/core/converter/facade.ts
 function toFlowDoc(doc) {
@@ -28,6 +29,7 @@ function readToFlow(reader, bytes) {
 var DEFAULT_READERS = [
 	docxReader,
 	xlsxReader,
+	pptxReader,
 	pdfReader
 ];
 function createConverter(opts = {}) {

package/dist/esm/core/converter/ream.js

@@ -16,6 +16,7 @@ import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
 	pdf: "application/pdf"
 };
 var Ream = class Ream {

package/dist/esm/pptx/placeholder-cascade.d.ts

@@ -0,0 +1,9 @@
+import { RunProperties } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { PoNode } from '../core/po-helpers.js';
+import { PlaceholderRef, ShapeBoxEmu } from './sp-helpers.js';
+export interface PlaceholderCascade {
+    readonly geometryFor: (ph: PlaceholderRef) => ShapeBoxEmu | undefined;
+    readonly defaultsFor: (ph: PlaceholderRef, level: number) => RunProperties;
+}
+export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver): PlaceholderCascade;

package/dist/esm/pptx/placeholder-cascade.js

@@ -0,0 +1,77 @@
+import { poChildren, poIs } from "../core/po-helpers.js";
+import { parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
+//#region src/pptx/placeholder-cascade.ts
+function categoryOf(type) {
+	if (type === "title" || type === "ctrTitle") return "title";
+	if (type === void 0 || type === "body" || type === "subTitle" || type === "obj") return "body";
+	return "other";
+}
+function buildPlaceholderCascade(layoutTree, masterTree, colors) {
+	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout");
+	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster") : [];
+	const txStyles = masterTree ? collectTxStyles(masterTree, colors) : {
+		title: [],
+		body: [],
+		other: []
+	};
+	return {
+		geometryFor(ph) {
+			return matchPlaceholder(layoutPhs, ph)?.box ?? matchPlaceholder(masterPhs, ph)?.box;
+		},
+		defaultsFor(ph, level) {
+			const levels = txStyles[categoryOf(ph.type)];
+			if (levels.length === 0) return {};
+			return levels[Math.min(Math.max(level, 0), levels.length - 1)] ?? {};
+		}
+	};
+}
+function collectPlaceholders(tree, root) {
+	const sld = tree.find((n) => poIs(n, root));
+	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
+	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
+	if (!spTree) return [];
+	const out = [];
+	for (const sp of poChildren(spTree)) {
+		if (!poIs(sp, "p:sp")) continue;
+		const ref = parsePh(sp);
+		if (!ref) continue;
+		const box = parseXfrmBox(poChildren(sp).find((c) => poIs(c, "p:spPr")));
+		out.push({
+			ref,
+			...box ? { box } : {}
+		});
+	}
+	return out;
+}
+function matchPlaceholder(list, ph) {
+	if (ph.idx !== void 0) {
+		const byIdx = list.find((p) => p.ref.idx === ph.idx);
+		if (byIdx) return byIdx;
+	}
+	const byType = list.find((p) => p.ref.type === ph.type);
+	if (byType) return byType;
+	const cat = categoryOf(ph.type);
+	return list.find((p) => categoryOf(p.ref.type) === cat);
+}
+function collectTxStyles(masterTree, colors) {
+	const sld = masterTree.find((n) => poIs(n, "p:sldMaster"));
+	const txStyles = sld ? poChildren(sld).find((c) => poIs(c, "p:txStyles")) : void 0;
+	return {
+		title: levelStyles(txStyles, "p:titleStyle", colors),
+		body: levelStyles(txStyles, "p:bodyStyle", colors),
+		other: levelStyles(txStyles, "p:otherStyle", colors)
+	};
+}
+function levelStyles(txStyles, tag, colors) {
+	const style = txStyles ? poChildren(txStyles).find((c) => poIs(c, tag)) : void 0;
+	if (!style) return [];
+	const out = [];
+	for (let lvl = 1; lvl <= 9; lvl++) {
+		const lvlPr = poChildren(style).find((c) => poIs(c, `a:lvl${lvl}pPr`));
+		const defRPr = lvlPr ? poChildren(lvlPr).find((c) => poIs(c, "a:defRPr")) : void 0;
+		out.push(rPrToRunProps(defRPr, colors));
+	}
+	return out;
+}
+//#endregion
+export { buildPlaceholderCascade };

package/dist/esm/pptx/pptx-reader.d.ts

@@ -0,0 +1,4 @@
+import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function readPptx(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const pptxReader: DocumentReader<FlowDoc>;

package/dist/esm/pptx/pptx-reader.js

@@ -0,0 +1,213 @@
+import { pt } from "../core/ir/units.js";
+import { ResourceStore } from "../core/ir/resources.js";
+import { FEATURES } from "../core/ir/features.js";
+import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { bytesInclude } from "../core/bytes.js";
+import { poAttr, poChildren, poIntAttr, poIs } from "../core/po-helpers.js";
+import { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver } from "../core/drawingml/colors.js";
+import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
+import { parseTheme } from "../core/drawingml/theme-parser.js";
+import { OpcPackage } from "../core/opc/package.js";
+import "../core/opc/index.js";
+import { buildPlaceholderCascade } from "./placeholder-cascade.js";
+import { backdropElement, parseBackgroundFill, parseSlideShapes } from "./slide-parser.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/pptx/pptx-reader.ts
+var EMU_PER_PT = 12700;
+var DEFAULT_CX = 9144e3;
+var DEFAULT_CY = 6858e3;
+var decoder = new TextDecoder();
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	preserveOrder: true,
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+function readPptx(bytes) {
+	const losses = [];
+	const pkg = OpcPackage.open(bytes);
+	const presPath = pkg.getMainDocumentPath();
+	const presData = pkg.getPart(presPath);
+	const resources = new ResourceStore();
+	const charts = /* @__PURE__ */ new Map();
+	let cx = DEFAULT_CX;
+	let cy = DEFAULT_CY;
+	const slideParts = [];
+	if (presData) {
+		const pres = parser.parse(decoder.decode(presData)).find((n) => poIs(n, "p:presentation"));
+		const kids = pres ? poChildren(pres) : [];
+		const sldSz = kids.find((c) => poIs(c, "p:sldSz"));
+		cx = (sldSz ? poIntAttr(sldSz, "cx") : void 0) || DEFAULT_CX;
+		cy = (sldSz ? poIntAttr(sldSz, "cy") : void 0) || DEFAULT_CY;
+		const slideRelById = new Map(pkg.getPartRelationships(presPath).filter((r) => r.type.endsWith("/slide")).map((r) => [r.id, r]));
+		const lst = kids.find((c) => poIs(c, "p:sldIdLst"));
+		const ids = lst ? poChildren(lst).filter((c) => poIs(c, "p:sldId")) : [];
+		for (const sldId of ids) {
+			const rid = poAttr(sldId, "r:id");
+			const rel = rid !== void 0 ? slideRelById.get(rid) : void 0;
+			const part = rel ? pkg.resolveRelatedPart(presPath, rel) : void 0;
+			if (part) slideParts.push(part);
+		}
+	}
+	if (slideParts.length === 0) losses.push({
+		severity: "dropped",
+		feature: FEATURES.text,
+		detail: "presentation has no slides"
+	});
+	const slideCount = Math.max(1, slideParts.length);
+	const pageW = pt(cx / EMU_PER_PT);
+	const pageH = pt(cy / EMU_PER_PT);
+	const stylesByLayout = /* @__PURE__ */ new Map();
+	const body = [];
+	for (let i = 0; i < slideCount; i++) {
+		body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: i > 0 ? { pageBreakBefore: true } : {},
+				runs: [{
+					text: "​",
+					properties: {}
+				}]
+			}
+		});
+		const part = slideParts[i];
+		if (part) {
+			const styles = slideStylesFor(pkg, part.path, stylesByLayout);
+			const ctx = {
+				...styles.cascade ? { cascade: styles.cascade } : {},
+				colors: styles.colors,
+				resolveImage: makeSlideImageResolver(pkg, part.path, resources),
+				resolveChart: makeSlideChartResolver(pkg, part.path, charts, styles.colors),
+				resolveHyperlink: makeHyperlinkResolver(pkg, part.path)
+			};
+			body.push(...parseSlide(part.data, ctx, styles.background, pageW, pageH));
+		}
+	}
+	const section = {
+		pageSize: {
+			width: pageW,
+			height: pageH
+		},
+		margins: {
+			top: pt(0),
+			right: pt(0),
+			bottom: pt(0),
+			left: pt(0)
+		},
+		headers: [],
+		footers: []
+	};
+	return {
+		doc: {
+			kind: "flow",
+			body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
+			sections: [],
+			section,
+			styles: EMPTY_STYLE_SHEET,
+			resources,
+			...charts.size > 0 ? { charts } : {}
+		},
+		losses
+	};
+}
+function parseXml(data) {
+	return parser.parse(decoder.decode(data));
+}
+function parseSlide(data, ctx, inheritedBg, pageW, pageH) {
+	const sld = parseXml(data).find((n) => poIs(n, "p:sld"));
+	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
+	const colors = ctx.colors ?? defaultColorResolver;
+	const bgNode = cSld ? poChildren(cSld).find((c) => poIs(c, "p:bg")) : void 0;
+	const bg = (bgNode ? parseBackgroundFill(bgNode, colors) : void 0) ?? inheritedBg;
+	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
+	const out = [];
+	if (bg) out.push(backdropElement(bg, pageW, pageH));
+	if (spTree) out.push(...parseSlideShapes(spTree, ctx));
+	return out;
+}
+function partBackground(tree, root, colors) {
+	const sld = tree.find((n) => poIs(n, root));
+	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
+	const bg = cSld ? poChildren(cSld).find((c) => poIs(c, "p:bg")) : void 0;
+	return bg ? parseBackgroundFill(bg, colors) : void 0;
+}
+function makeSlideImageResolver(pkg, slidePath, resources) {
+	const cache = /* @__PURE__ */ new Map();
+	return (relId) => {
+		if (cache.has(relId)) return cache.get(relId);
+		const rel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
+		const resolved = rel ? pkg.resolveRelatedPart(slidePath, rel) : void 0;
+		const id = resolved ? resources.put(resolved.data) : void 0;
+		cache.set(relId, id);
+		return id;
+	};
+}
+function makeHyperlinkResolver(pkg, slidePath) {
+	return (relId) => {
+		const rel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
+		return rel && rel.targetMode === "External" ? rel.target : void 0;
+	};
+}
+function makeSlideChartResolver(pkg, slidePath, charts, colors) {
+	const cache = /* @__PURE__ */ new Map();
+	return (relId) => {
+		if (cache.has(relId)) return cache.get(relId);
+		const rel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
+		const resolved = rel ? pkg.resolveRelatedPart(slidePath, rel) : void 0;
+		const chart = resolved ? parseChart(resolved.data, colors) : null;
+		let key;
+		if (chart && resolved) {
+			key = `${slidePath}!${relId}`;
+			charts.set(key, withChartColorStyle(chart, pkg, resolved.path, colors));
+		}
+		cache.set(relId, key);
+		return key;
+	};
+}
+function slideStylesFor(pkg, slidePath, cache) {
+	const layoutRel = pkg.getPartRelationships(slidePath).find((r) => r.type.endsWith("/slideLayout"));
+	const layout = layoutRel ? pkg.resolveRelatedPart(slidePath, layoutRel) : void 0;
+	if (!layout) return { colors: defaultColorResolver };
+	const cached = cache.get(layout.path);
+	if (cached) return cached;
+	const masterRel = pkg.getPartRelationships(layout.path).find((r) => r.type.endsWith("/slideMaster"));
+	const master = masterRel ? pkg.resolveRelatedPart(layout.path, masterRel) : void 0;
+	const colors = master ? deckColorResolver(pkg, master.path) : defaultColorResolver;
+	const layoutTree = parseXml(layout.data);
+	const masterTree = master ? parseXml(master.data) : void 0;
+	const cascade = buildPlaceholderCascade(layoutTree, masterTree, colors);
+	const background = partBackground(layoutTree, "p:sldLayout", colors) ?? (masterTree ? partBackground(masterTree, "p:sldMaster", colors) : void 0);
+	const styles = {
+		cascade,
+		colors,
+		...background ? { background } : {}
+	};
+	cache.set(layout.path, styles);
+	return styles;
+}
+function deckColorResolver(pkg, masterPath) {
+	const themeRel = pkg.getPartRelationships(masterPath).find((r) => r.type.endsWith("/theme"));
+	const theme = themeRel ? pkg.resolveRelatedPart(masterPath, themeRel) : void 0;
+	if (!theme) return defaultColorResolver;
+	const palette = new Map(DEFAULT_THEME_PALETTE);
+	for (const [slot, hex] of parseTheme(theme.data)) palette.set(slot, hex);
+	return makeColorResolver(palette);
+}
+var pptxReader = {
+	id: "pptx",
+	produces: "flow",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.images,
+		FEATURES.shapes,
+		FEATURES.charts,
+		FEATURES.tables
+	]),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "ppt/presentation.xml"),
+	read: (bytes) => readPptx(bytes)
+};
+//#endregion
+export { pptxReader };

package/dist/esm/pptx/slide-parser.d.ts

@@ -0,0 +1,18 @@
+import { BodyElement, ShapeFill } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { Pt, ResourceId } from '../core/ir/index.js';
+import { PoNode } from '../core/po-helpers.js';
+import { PlaceholderCascade } from './placeholder-cascade.js';
+import { ShapeBoxEmu } from './sp-helpers.js';
+export interface SlideContext {
+    readonly cascade?: PlaceholderCascade;
+    readonly resolveImage?: (relId: string) => ResourceId | undefined;
+    readonly resolveChart?: (relId: string) => string | undefined;
+    readonly colors?: ColorResolver;
+    readonly resolveHyperlink?: (relId: string) => string | undefined;
+}
+type GroupTransform = (box: ShapeBoxEmu) => ShapeBoxEmu;
+export declare function parseSlideShapes(container: PoNode, ctx?: SlideContext, transform?: GroupTransform): Array<BodyElement>;
+export declare function parseBackgroundFill(bg: PoNode, colors: ColorResolver): ShapeFill | undefined;
+export declare function backdropElement(fill: ShapeFill, widthPt: Pt, heightPt: Pt): BodyElement;
+export {};

package/dist/esm/pptx/slide-parser.js

@@ -0,0 +1,359 @@
+import { emuToPt } from "../core/ir/units.js";
+import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poText } from "../core/po-helpers.js";
+import { defaultColorResolver, resolveColorNode } from "../core/drawingml/colors.js";
+import { parseCustGeom, parseFill, parseLine, parsePrstGeom } from "../word/drawing-parser.js";
+import { boxFromXfrm, parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
+//#region src/pptx/slide-parser.ts
+var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var TABLE_URI = "http://schemas.openxmlformats.org/drawingml/2006/table";
+var ALGN_TO_ALIGNMENT = {
+	l: "left",
+	ctr: "center",
+	r: "right",
+	just: "both",
+	dist: "distribute"
+};
+var RECT_GEOMETRY = {
+	kind: "preset",
+	preset: "rect",
+	adjust: /* @__PURE__ */ new Map()
+};
+var IDENTITY_TRANSFORM = (box) => box;
+function parseSlideShapes(container, ctx = {}, transform = IDENTITY_TRANSFORM) {
+	const out = [];
+	for (const child of poChildren(container)) if (poIs(child, "p:sp")) {
+		const shape = parseSp(child, ctx, transform);
+		if (shape) out.push({
+			kind: "shape",
+			shape
+		});
+	} else if (poIs(child, "p:pic")) {
+		const image = parsePic(child, ctx, transform);
+		if (image) out.push({
+			kind: "image",
+			image
+		});
+	} else if (poIs(child, "p:graphicFrame")) {
+		const el = parseGraphicFrame(child, ctx, transform);
+		if (el) out.push(el);
+	} else if (poIs(child, "p:grpSp")) out.push(...parseSlideShapes(child, ctx, composeGroupTransform(child, transform)));
+	return out;
+}
+function composeGroupTransform(grpSp, parent) {
+	const grpSpPr = poChildren(grpSp).find((c) => poIs(c, "p:grpSpPr"));
+	const xfrm = grpSpPr ? poChildren(grpSpPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	if (!xfrm) return parent;
+	const off = poChildren(xfrm).find((c) => poIs(c, "a:off"));
+	const ext = poChildren(xfrm).find((c) => poIs(c, "a:ext"));
+	const chOff = poChildren(xfrm).find((c) => poIs(c, "a:chOff"));
+	const chExt = poChildren(xfrm).find((c) => poIs(c, "a:chExt"));
+	const extCx = ext ? poIntAttr(ext, "cx") : void 0;
+	const extCy = ext ? poIntAttr(ext, "cy") : void 0;
+	const chExtCx = chExt ? poIntAttr(chExt, "cx") : void 0;
+	const chExtCy = chExt ? poIntAttr(chExt, "cy") : void 0;
+	if (!extCx || !extCy || !chExtCx || !chExtCy) return parent;
+	const offX = (off ? poIntAttr(off, "x") : void 0) ?? 0;
+	const offY = (off ? poIntAttr(off, "y") : void 0) ?? 0;
+	const chOffX = (chOff ? poIntAttr(chOff, "x") : void 0) ?? 0;
+	const chOffY = (chOff ? poIntAttr(chOff, "y") : void 0) ?? 0;
+	const sx = extCx / chExtCx;
+	const sy = extCy / chExtCy;
+	return (box) => parent({
+		x: offX + (box.x - chOffX) * sx,
+		y: offY + (box.y - chOffY) * sy,
+		cx: box.cx * sx,
+		cy: box.cy * sy
+	});
+}
+function floatAt(box) {
+	return {
+		wrap: "none",
+		posH: {
+			relativeFrom: "page",
+			offsetPt: emuToPt(box.x)
+		},
+		posV: {
+			relativeFrom: "page",
+			offsetPt: emuToPt(box.y)
+		}
+	};
+}
+function parseSp(sp, ctx, transform) {
+	const ph = parsePh(sp);
+	const colors = ctx.colors ?? defaultColorResolver;
+	const spPr = poChildren(sp).find((c) => poIs(c, "p:spPr"));
+	let own = parseXfrmBox(spPr);
+	if (!own && ph && ctx.cascade) own = ctx.cascade.geometryFor(ph);
+	if (!own) return void 0;
+	const box = transform(own);
+	const txBody = poChildren(sp).find((c) => poIs(c, "p:txBody"));
+	const text = txBody ? parseTxBody(txBody, ph, ctx.cascade, colors, ctx.resolveHyperlink) : void 0;
+	const geometry = parseGeometry(spPr);
+	const fill = spPr ? parseFill(spPr, colors) : { kind: "none" };
+	const line = spPr ? parseLine(spPr, colors) : void 0;
+	const visibleLine = line !== void 0 && line.fill !== "none";
+	if (!text && fill.kind === "none" && !visibleLine) return void 0;
+	return {
+		float: floatAt(box),
+		width: emuToPt(box.cx),
+		height: emuToPt(box.cy),
+		geometry,
+		fill,
+		...line ? { line } : {},
+		...text ? { text } : {},
+		paragraphProperties: {}
+	};
+}
+function parseGraphicFrame(gf, ctx, transform) {
+	const own = boxFromXfrm(poChildren(gf).find((c) => poIs(c, "p:xfrm")));
+	if (!own) return void 0;
+	const box = transform(own);
+	const graphicData = poFindDescendant(gf, "a:graphicData");
+	const uri = graphicData ? poAttr(graphicData, "uri") : void 0;
+	if (uri === CHART_URI) {
+		const cChart = poFindDescendant(gf, "c:chart");
+		const relId = cChart ? poAttr(cChart, "id") : void 0;
+		const key = relId !== void 0 ? ctx.resolveChart?.(relId) : void 0;
+		if (key === void 0) return void 0;
+		return {
+			kind: "chart",
+			chart: {
+				float: floatAt(box),
+				chartRelId: key,
+				width: emuToPt(box.cx),
+				height: emuToPt(box.cy),
+				paragraphProperties: {}
+			}
+		};
+	}
+	if (uri === TABLE_URI) {
+		const tbl = poFindDescendant(gf, "a:tbl");
+		return tbl ? {
+			kind: "table",
+			table: parseTable(tbl, ctx.colors ?? defaultColorResolver)
+		} : void 0;
+	}
+}
+function parseBackgroundFill(bg, colors) {
+	const bgPr = poChildren(bg).find((c) => poIs(c, "p:bgPr"));
+	if (bgPr) {
+		const fill = parseFill(bgPr, colors);
+		return fill.kind !== "none" ? fill : void 0;
+	}
+	const bgRef = poChildren(bg).find((c) => poIs(c, "p:bgRef"));
+	if (bgRef) for (const c of poChildren(bgRef)) {
+		const hex = resolveColorNode(c, colors);
+		if (hex) return {
+			kind: "solid",
+			colorHex: hex
+		};
+	}
+}
+function backdropElement(fill, widthPt, heightPt) {
+	return {
+		kind: "shape",
+		shape: {
+			float: {
+				wrap: "none",
+				behind: true,
+				posH: {
+					relativeFrom: "page",
+					offsetPt: emuToPt(0)
+				},
+				posV: {
+					relativeFrom: "page",
+					offsetPt: emuToPt(0)
+				}
+			},
+			width: widthPt,
+			height: heightPt,
+			geometry: RECT_GEOMETRY,
+			fill,
+			paragraphProperties: {}
+		}
+	};
+}
+function parseGeometry(spPr) {
+	if (!spPr) return RECT_GEOMETRY;
+	const prst = poChildren(spPr).find((c) => poIs(c, "a:prstGeom"));
+	if (prst) return parsePrstGeom(prst);
+	const cust = poChildren(spPr).find((c) => poIs(c, "a:custGeom"));
+	if (cust) return parseCustGeom(cust);
+	return RECT_GEOMETRY;
+}
+function parsePic(pic, ctx, transform) {
+	const own = parseXfrmBox(poChildren(pic).find((c) => poIs(c, "p:spPr")));
+	if (!own) return void 0;
+	const box = transform(own);
+	const blipFill = poChildren(pic).find((c) => poIs(c, "p:blipFill"));
+	const blip = blipFill ? poChildren(blipFill).find((c) => poIs(c, "a:blip")) : void 0;
+	const relId = blip ? poAttr(blip, "embed") : void 0;
+	const resource = relId !== void 0 ? ctx.resolveImage?.(relId) : void 0;
+	const altText = picAltText(pic);
+	return {
+		float: floatAt(box),
+		...resource !== void 0 ? { resource } : {},
+		width: emuToPt(box.cx),
+		height: emuToPt(box.cy),
+		paragraphProperties: {},
+		...altText ? { altText } : {}
+	};
+}
+function picAltText(pic) {
+	const nvPicPr = poChildren(pic).find((c) => poIs(c, "p:nvPicPr"));
+	const cNvPr = nvPicPr ? poChildren(nvPicPr).find((c) => poIs(c, "p:cNvPr")) : void 0;
+	const descr = cNvPr ? poAttr(cNvPr, "descr") : void 0;
+	const title = cNvPr ? poAttr(cNvPr, "title") : void 0;
+	return (descr ?? title)?.trim() || void 0;
+}
+function txBodyParagraphs(txBody, ph, cascade, colors, resolveLink) {
+	const content = [];
+	const counters = [];
+	for (const child of poChildren(txBody)) {
+		if (!poIs(child, "a:p")) continue;
+		content.push({
+			kind: "paragraph",
+			paragraph: parseSlideParagraph(child, ph, cascade, colors, resolveLink, counters)
+		});
+	}
+	return content;
+}
+function parseTxBody(txBody, ph, cascade, colors, resolveLink) {
+	const content = txBodyParagraphs(txBody, ph, cascade, colors, resolveLink);
+	if (content.length === 0) return void 0;
+	const bodyPr = poChildren(txBody).find((c) => poIs(c, "a:bodyPr"));
+	const lIns = bodyPr ? poIntAttr(bodyPr, "lIns") : void 0;
+	const tIns = bodyPr ? poIntAttr(bodyPr, "tIns") : void 0;
+	const rIns = bodyPr ? poIntAttr(bodyPr, "rIns") : void 0;
+	const bIns = bodyPr ? poIntAttr(bodyPr, "bIns") : void 0;
+	const a = bodyPr ? poAttr(bodyPr, "anchor") : void 0;
+	const anchor = a === "ctr" ? "ctr" : a === "b" ? "b" : a === "t" ? "t" : void 0;
+	return {
+		content,
+		...lIns !== void 0 ? { insetLeft: emuToPt(lIns) } : {},
+		...tIns !== void 0 ? { insetTop: emuToPt(tIns) } : {},
+		...rIns !== void 0 ? { insetRight: emuToPt(rIns) } : {},
+		...bIns !== void 0 ? { insetBottom: emuToPt(bIns) } : {},
+		...anchor ? { anchor } : {}
+	};
+}
+function parseSlideParagraph(aP, ph, cascade, colors, resolveLink, counters) {
+	const pPr = poChildren(aP).find((c) => poIs(c, "a:pPr"));
+	const level = (pPr ? poIntAttr(pPr, "lvl") : void 0) ?? 0;
+	const defaults = ph && cascade ? cascade.defaultsFor(ph, level) : {};
+	const algn = pPr ? poAttr(pPr, "algn") : void 0;
+	const alignment = algn !== void 0 ? ALGN_TO_ALIGNMENT[algn] : void 0;
+	const runs = [];
+	const marker = bulletMarker(pPr, level, counters);
+	if (marker !== void 0) runs.push({
+		text: marker,
+		properties: defaults,
+		listMarker: true
+	});
+	for (const child of poChildren(aP)) if (poIs(child, "a:r") || poIs(child, "a:fld")) {
+		const run = parseSlideRun(child, defaults, colors, resolveLink);
+		if (run) runs.push(run);
+	}
+	const marL = pPr ? poIntAttr(pPr, "marL") : void 0;
+	const indent = pPr ? poIntAttr(pPr, "indent") : void 0;
+	const indentLeft = marL !== void 0 ? emuToPt(marL) : level > 0 ? emuToPt(level * 457200) : void 0;
+	return {
+		properties: {
+			...alignment ? { alignment } : {},
+			...indentLeft !== void 0 ? { indentLeft } : {},
+			...indent !== void 0 ? { indentFirstLine: emuToPt(indent) } : {}
+		},
+		runs
+	};
+}
+function bulletMarker(pPr, level, counters) {
+	if (!pPr) return void 0;
+	if (poChildren(pPr).some((c) => poIs(c, "a:buNone"))) return void 0;
+	const buChar = poChildren(pPr).find((c) => poIs(c, "a:buChar"));
+	if (buChar) return `${poAttr(buChar, "char") ?? "•"}  `;
+	const buAuto = poChildren(pPr).find((c) => poIs(c, "a:buAutoNum"));
+	if (!buAuto) return void 0;
+	const type = poAttr(buAuto, "type") ?? "arabicPeriod";
+	const startAt = poIntAttr(buAuto, "startAt") ?? 1;
+	const prev = counters[level];
+	const n = (prev === void 0 ? startAt - 1 : prev) + 1;
+	counters[level] = n;
+	counters.length = level + 1;
+	return `${n}${autoNumSuffix(type)}  `;
+}
+function autoNumSuffix(type) {
+	if (type.endsWith("ParenR") || type.endsWith("ParenBoth")) return ")";
+	if (type.endsWith("Period")) return ".";
+	return "";
+}
+function parseSlideRun(node, defaults, colors, resolveLink) {
+	const t = poChildren(node).find((c) => poIs(c, "a:t"));
+	const text = t ? poText(t) : "";
+	if (text.length === 0) return void 0;
+	const rPr = poChildren(node).find((c) => poIs(c, "a:rPr"));
+	const hlink = rPr ? poChildren(rPr).find((c) => poIs(c, "a:hlinkClick")) : void 0;
+	const linkId = hlink ? poAttr(hlink, "id") : void 0;
+	const href = linkId !== void 0 ? resolveLink?.(linkId) : void 0;
+	return {
+		text,
+		properties: {
+			...defaults,
+			...rPrToRunProps(rPr, colors)
+		},
+		...href ? { href } : {}
+	};
+}
+function parseTable(tbl, colors) {
+	const grid = [];
+	const tblGrid = poChildren(tbl).find((c) => poIs(c, "a:tblGrid"));
+	if (tblGrid) {
+		for (const col of poChildren(tblGrid)) if (poIs(col, "a:gridCol")) grid.push(emuToPt(poIntAttr(col, "w") ?? 0));
+	}
+	const rows = [];
+	for (const tr of poChildren(tbl)) if (poIs(tr, "a:tr")) rows.push(parseTableRow(tr, colors));
+	return {
+		properties: {},
+		grid,
+		rows
+	};
+}
+function parseTableRow(tr, colors) {
+	const h = poIntAttr(tr, "h");
+	const cells = [];
+	for (const tc of poChildren(tr)) {
+		if (!poIs(tc, "a:tc")) continue;
+		if (poAttr(tc, "hMerge") === "1") continue;
+		cells.push(parseTableCell(tc, colors));
+	}
+	return {
+		properties: { ...h !== void 0 ? { height: emuToPt(h) } : {} },
+		cells
+	};
+}
+function parseTableCell(tc, colors) {
+	const txBody = poChildren(tc).find((c) => poIs(c, "a:txBody"));
+	const content = txBody ? txBodyParagraphs(txBody, void 0, void 0, colors, void 0) : [];
+	const gridSpan = poIntAttr(tc, "gridSpan");
+	const rowSpan = poIntAttr(tc, "rowSpan");
+	const merge = rowSpan !== void 0 && rowSpan > 1 ? "start" : poAttr(tc, "vMerge") === "1" ? "middle" : void 0;
+	const tcPr = poChildren(tc).find((c) => poIs(c, "a:tcPr"));
+	const shadingHex = tcPr ? cellFillHex(tcPr, colors) : void 0;
+	return {
+		properties: {
+			...gridSpan !== void 0 && gridSpan > 1 ? { colSpan: gridSpan } : {},
+			...merge ? { merge } : {},
+			...shadingHex ? { shading: { colorHex: shadingHex } } : {}
+		},
+		content
+	};
+}
+function cellFillHex(tcPr, colors) {
+	const solidFill = poChildren(tcPr).find((c) => poIs(c, "a:solidFill"));
+	if (!solidFill) return void 0;
+	for (const c of poChildren(solidFill)) {
+		const hex = resolveColorNode(c, colors);
+		if (hex) return hex;
+	}
+}
+//#endregion
+export { backdropElement, parseBackgroundFill, parseSlideShapes };

package/dist/esm/pptx/sp-helpers.d.ts

@@ -0,0 +1,17 @@
+import { RunProperties } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { PoNode } from '../core/po-helpers.js';
+export interface PlaceholderRef {
+    readonly type?: string;
+    readonly idx?: string;
+}
+export interface ShapeBoxEmu {
+    readonly x: number;
+    readonly y: number;
+    readonly cx: number;
+    readonly cy: number;
+}
+export declare function parsePh(sp: PoNode): PlaceholderRef | undefined;
+export declare function boxFromXfrm(xfrm: PoNode | undefined): ShapeBoxEmu | undefined;
+export declare function parseXfrmBox(spPr: PoNode | undefined): ShapeBoxEmu | undefined;
+export declare function rPrToRunProps(rPr: PoNode | undefined, colors: ColorResolver): RunProperties;

package/dist/esm/pptx/sp-helpers.js

@@ -0,0 +1,60 @@
+import { pt } from "../core/ir/units.js";
+import { poAttr, poChildren, poIntAttr, poIs } from "../core/po-helpers.js";
+import { resolveColorNode } from "../core/drawingml/colors.js";
+//#region src/pptx/sp-helpers.ts
+var isTrue = (v) => v === "1" || v === "true" || v === "on";
+function parsePh(sp) {
+	const nvSpPr = poChildren(sp).find((c) => poIs(c, "p:nvSpPr"));
+	const nvPr = nvSpPr ? poChildren(nvSpPr).find((c) => poIs(c, "p:nvPr")) : void 0;
+	const ph = nvPr ? poChildren(nvPr).find((c) => poIs(c, "p:ph")) : void 0;
+	if (!ph) return void 0;
+	const type = poAttr(ph, "type");
+	const idx = poAttr(ph, "idx");
+	return {
+		...type !== void 0 ? { type } : {},
+		...idx !== void 0 ? { idx } : {}
+	};
+}
+function boxFromXfrm(xfrm) {
+	if (!xfrm) return void 0;
+	const off = poChildren(xfrm).find((c) => poIs(c, "a:off"));
+	const ext = poChildren(xfrm).find((c) => poIs(c, "a:ext"));
+	const cx = ext ? poIntAttr(ext, "cx") : void 0;
+	const cy = ext ? poIntAttr(ext, "cy") : void 0;
+	if (cx === void 0 || cy === void 0 || cx <= 0 || cy <= 0) return void 0;
+	return {
+		x: (off ? poIntAttr(off, "x") : void 0) ?? 0,
+		y: (off ? poIntAttr(off, "y") : void 0) ?? 0,
+		cx,
+		cy
+	};
+}
+function parseXfrmBox(spPr) {
+	return boxFromXfrm(spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0);
+}
+function rPrToRunProps(rPr, colors) {
+	if (!rPr) return {};
+	const sz = poIntAttr(rPr, "sz");
+	const u = poAttr(rPr, "u");
+	const colorHex = solidFillColor(rPr, colors);
+	const latin = poChildren(rPr).find((c) => poIs(c, "a:latin"));
+	const typeface = latin ? poAttr(latin, "typeface")?.trim() : void 0;
+	return {
+		...isTrue(poAttr(rPr, "b")) ? { bold: true } : {},
+		...isTrue(poAttr(rPr, "i")) ? { italic: true } : {},
+		...u !== void 0 && u !== "none" ? { underline: "single" } : {},
+		...sz !== void 0 ? { fontSizePt: pt(sz / 100) } : {},
+		...colorHex ? { colorHex } : {},
+		...typeface ? { fontFamily: { ascii: typeface } } : {}
+	};
+}
+function solidFillColor(rPr, colors) {
+	const solidFill = poChildren(rPr).find((c) => poIs(c, "a:solidFill"));
+	if (!solidFill) return void 0;
+	for (const c of poChildren(solidFill)) {
+		const hex = resolveColorNode(c, colors);
+		if (hex) return hex;
+	}
+}
+//#endregion
+export { boxFromXfrm, parsePh, parseXfrmBox, rPrToRunProps };

package/dist/esm/word/drawing-parser.d.ts

@@ -36,3 +36,7 @@ export declare function resolveMc(altContent: PoNode): ReadonlyArray<PoNode>;
 export declare function expandMcChildren(children: ReadonlyArray<PoNode>): Array<PoNode>;
 export declare function parseDrawing(drawing: PoNode, resolveColor: ColorResolver, parseBody?: ParseBody): DrawingContent | null;
 export declare function parseVmlPicture(node: PoNode): DrawingContent | null;
+export declare function parsePrstGeom(prst: PoNode): ShapeGeometry;
+export declare function parseCustGeom(cust: PoNode): ShapeGeometry;
+export declare function parseFill(spPr: PoNode, resolveColor: ColorResolver): ShapeFill;
+export declare function parseLine(spPr: PoNode, resolveColor: ColorResolver): ShapeLine | undefined;

package/dist/esm/word/drawing-parser.js

@@ -441,4 +441,4 @@ function clampUnit(x) {
 	return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 //#endregion
-export { expandMcChildren, parseDrawing, parseVmlPicture };
+export { expandMcChildren, parseCustGeom, parseDrawing, parseFill, parseLine, parsePrstGeom, parseVmlPicture };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reamkit",
-  "version": "1.9.0",
-  "description": "Ream — convert DOCX, XLSX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
+  "version": "1.10.0",
+  "description": "Ream — convert DOCX, XLSX, PPTX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",
   "repository": {
@@ -38,6 +38,7 @@
   "keywords": [
     "docx",
     "xlsx",
+    "pptx",
     "pdf",
     "ooxml",
     "ecma-376",
@@ -46,6 +47,7 @@
     "office",
     "word",
     "excel",
+    "powerpoint",
     "converter"
   ],
   "scripts": {