@pollium/vyva-convert 0.0.0-stage → 0.1.0

package/dist/import/pptx-slide.js

@@ -0,0 +1,324 @@
+import { cleanHtml } from "../clean-html.js";
+import { all, attr, first, kid, kids, num, tags, textOf } from "./pptx-xml.js";
+import { TITLE_TYPES, bulletsByDefault, decorOf, isDefined, levelOf, masterLevel, placeholderChain } from "./pptx-placeholders.js";
+import { MAX_CELL_TEXT, MAX_TABLE_COLUMNS, MAX_TABLE_ROWS } from "@pollium/vyva-core/content";
+import { newId } from "@pollium/vyva-core/ids";
+import { escapeHtml } from "@pollium/vyva-core/escape";
+//#region src/import/pptx-slide.ts
+const MAX_ELEMENTS = 300;
+const ANGLE_UNIT = 6e4;
+const DEFAULT_LINE_WIDTH = 12700;
+const MAX_STROKE = 80;
+const PX_PER_POINT = 2;
+const TITLE_SIZE = 64;
+const BODY_SIZE = 32;
+const BULLET_TYPES = ["body", "obj"];
+const ALIGNS = {
+	l: "left",
+	ctr: "center",
+	r: "right",
+	just: "justify"
+};
+const IDENTITY = {
+	offX: 0,
+	offY: 0,
+	chOffX: 0,
+	chOffY: 0,
+	scaleX: 1,
+	scaleY: 1
+};
+const NO_LOOK = {
+	size: null,
+	color: null,
+	isBold: null,
+	align: null
+};
+const mergeLooks = (looks) => looks.reduce((merged, look) => ({
+	size: merged.size ?? look.size,
+	color: merged.color ?? look.color,
+	isBold: merged.isBold ?? look.isBold,
+	align: merged.align ?? look.align
+}), NO_LOOK);
+const innerGroup = (node, group) => {
+	const xfrm = first(kid(node, "p:grpSpPr") ?? node, "a:xfrm");
+	const off = kid(xfrm, "a:off");
+	const ext = kid(xfrm, "a:ext");
+	const childOff = kid(xfrm, "a:chOff");
+	const childExt = kid(xfrm, "a:chExt");
+	return {
+		offX: group.offX + (num(attr(off, "x")) - group.chOffX) * group.scaleX,
+		offY: group.offY + (num(attr(off, "y")) - group.chOffY) * group.scaleY,
+		chOffX: num(attr(childOff, "x")),
+		chOffY: num(attr(childOff, "y")),
+		scaleX: group.scaleX * num(attr(ext, "cx"), 1) / Math.max(1, num(attr(childExt, "cx"), 1)),
+		scaleY: group.scaleY * num(attr(ext, "cy"), 1) / Math.max(1, num(attr(childExt, "cy"), 1))
+	};
+};
+const shapeKindOf = (geometry) => geometry === "roundRect" ? "rounded" : geometry === "ellipse" ? "ellipse" : geometry === "triangle" ? "triangle" : geometry === "line" || geometry === "straightConnector1" ? "line" : "rect";
+const styleColor = (shape, reference, palette) => {
+	const ref = kid(kid(shape, "p:style"), reference);
+	return ref === void 0 || attr(ref, "idx") === "0" ? null : palette.color(ref);
+};
+var SlideReader = class {
+	#options;
+	constructor(options) {
+		this.#options = options;
+	}
+	async read(parts) {
+		const elements = [];
+		const titles = [];
+		for (const part of decorOf(parts)) if (part.tree !== void 0) await this.#visit({
+			part,
+			parts,
+			isDecor: true,
+			elements,
+			titles
+		}, part.tree, IDENTITY);
+		if (parts.slide.tree !== void 0) await this.#visit({
+			part: parts.slide,
+			parts,
+			isDecor: false,
+			elements,
+			titles
+		}, parts.slide.tree, IDENTITY);
+		return {
+			slide: {
+				id: newId(),
+				background: await this.#background(parts),
+				elements: elements.slice(0, MAX_ELEMENTS)
+			},
+			title: titles[0] ?? ""
+		};
+	}
+	async #visit(visit, container, group) {
+		for (const node of tags(container)) if (node.name === "p:sp") this.#shapeInto(visit, node, group);
+		else if (node.name === "p:pic") await this.#pictureInto(visit, node, group);
+		else if (node.name === "p:graphicFrame") this.#tableInto(visit, node, group);
+		else if (node.name === "p:grpSp") await this.#visit(visit, node, innerGroup(node, group));
+	}
+	#transformOf(shapeProps, group) {
+		const xfrm = kid(shapeProps, "a:xfrm") ?? kid(shapeProps, "p:xfrm");
+		const off = kid(xfrm, "a:off");
+		const ext = kid(xfrm, "a:ext");
+		if (off === void 0 || ext === void 0) return null;
+		const { scale } = this.#options;
+		const x = group.offX + (num(attr(off, "x")) - group.chOffX) * group.scaleX;
+		const y = group.offY + (num(attr(off, "y")) - group.chOffY) * group.scaleY;
+		return {
+			x: Math.round(x * scale),
+			y: Math.round(y * scale),
+			w: Math.max(1, Math.round(num(attr(ext, "cx")) * group.scaleX * scale)),
+			h: Math.max(1, Math.round(num(attr(ext, "cy")) * group.scaleY * scale)),
+			rotation: Math.round(num(attr(xfrm, "rot")) / ANGLE_UNIT) % 360
+		};
+	}
+	#frame(transform, isLocked) {
+		return {
+			id: newId(),
+			...transform,
+			opacity: 1,
+			isLocked
+		};
+	}
+	#pixels(size) {
+		const hundredths = num(size);
+		return hundredths > 0 ? Math.round(hundredths / 100 * PX_PER_POINT * this.#options.fontScale) : null;
+	}
+	#runLook(props, palette) {
+		const bold = attr(props, "b");
+		return {
+			size: this.#pixels(attr(props, "sz")),
+			color: palette.color(kid(props, "a:solidFill")),
+			isBold: bold === void 0 ? null : bold === "1"
+		};
+	}
+	#levelLook(level, palette) {
+		return {
+			...this.#runLook(kid(level, "a:defRPr"), palette),
+			align: ALIGNS[attr(level, "algn") ?? ""] ?? null
+		};
+	}
+	#runHtml(run, box, palette) {
+		const props = kid(run, "a:rPr");
+		const text = escapeHtml(all(run, "a:t").map(textOf).join(""));
+		if (text === "") return "";
+		const look = this.#runLook(props, palette);
+		const styles = [...look.color === null || look.color.toLowerCase() === box.color.toLowerCase() ? [] : [`color:${look.color}`], ...look.size === null || look.size === box.fontSize ? [] : [`font-size:${look.size}px`]];
+		let html = styles.length === 0 ? text : `<span style="${styles.join(";")}">${text}</span>`;
+		if (look.isBold === true) html = `<strong>${html}</strong>`;
+		if (attr(props, "i") === "1") html = `<em>${html}</em>`;
+		if (attr(props, "u") !== void 0 && attr(props, "u") !== "none") html = `<u>${html}</u>`;
+		return html;
+	}
+	#textHtml(body, box, hasBullets, palette) {
+		const parts = [];
+		let isListOpen = false;
+		for (const paragraph of kids(body, "a:p")) {
+			const props = kid(paragraph, "a:pPr");
+			const own = ALIGNS[attr(props, "algn") ?? ""];
+			const inner = tags(paragraph).filter((node) => node.name === "a:r" || node.name === "a:br" || node.name === "a:fld").map((run) => run.name === "a:br" ? "<br>" : this.#runHtml(run, box, palette)).join("");
+			if ((props === void 0 ? hasBullets : kids(props, "a:buChar").length > 0 || kids(props, "a:buAutoNum").length > 0 || hasBullets && kids(props, "a:buNone").length === 0) && inner !== "") {
+				if (!isListOpen) parts.push("<ul>");
+				isListOpen = true;
+				parts.push(`<li>${inner}</li>`);
+				continue;
+			}
+			if (isListOpen) parts.push("</ul>");
+			isListOpen = false;
+			parts.push(`<p${own === void 0 || own === box.align ? "" : ` style="text-align:${own}"`}>${inner}</p>`);
+		}
+		if (isListOpen) parts.push("</ul>");
+		return cleanHtml(parts.join(""));
+	}
+	#textStyle(visit, chain, type, body) {
+		const palette = visit.part.palette;
+		const firstRun = all(body, "a:r").map((run) => kid(run, "a:rPr")).find(isDefined);
+		const firstAlign = ALIGNS[attr(kid(kids(body, "a:p")[0], "a:pPr"), "algn") ?? ""] ?? null;
+		const look = mergeLooks([
+			{
+				...this.#runLook(firstRun, palette),
+				align: firstAlign
+			},
+			...chain.map((shape) => this.#levelLook(levelOf(shape), palette)),
+			this.#levelLook(masterLevel(visit.parts, type), palette),
+			{
+				...NO_LOOK,
+				color: styleColor(chain[0], "a:fontRef", palette)
+			}
+		]);
+		const isTitle = TITLE_TYPES.includes(type ?? "");
+		const anchor = chain.map((shape) => attr(kid(kid(shape, "p:txBody"), "a:bodyPr"), "anchor")).find(isDefined);
+		const { theme } = this.#options;
+		return {
+			fontSize: look.size ?? (isTitle ? TITLE_SIZE : BODY_SIZE),
+			color: look.color ?? theme.text,
+			align: look.align ?? "left",
+			verticalAlign: anchor === "ctr" ? "middle" : anchor === "b" ? "bottom" : "top",
+			lineHeight: 1.2,
+			isBold: look.isBold ?? false
+		};
+	}
+	#shapeInto(visit, shape, group) {
+		const placeholder = first(shape, "p:ph");
+		if (placeholder !== void 0 && visit.isDecor) return;
+		const element = this.#shape(visit, shape, placeholder, group);
+		if (element === null) return;
+		visit.elements.push(element);
+		if (element.type === "text" && TITLE_TYPES.includes(attr(placeholder, "type") ?? "")) visit.titles.push(element.html.replace(/<[^>]+>/g, "").trim());
+	}
+	#shape(visit, shape, placeholder, group) {
+		const chain = placeholder === void 0 ? [shape] : placeholderChain(shape, placeholder, visit.parts);
+		const props = chain.map((link) => kid(link, "p:spPr"));
+		const transform = this.#transformOf(props[0], group) ?? props.slice(1).map((inherited) => this.#transformOf(inherited, IDENTITY)).find((found) => found !== null) ?? null;
+		if (transform === null) return null;
+		const { palette } = visit.part;
+		const kind = shapeKindOf(attr(chain.map((link) => first(link, "a:prstGeom")).find(isDefined), "prst") ?? "rect");
+		const filled = props.find((candidate) => palette.hasFill(candidate));
+		const fill = filled === void 0 ? styleColor(shape, "a:fillRef", palette) : palette.fill(filled);
+		const line = kid(props[0], "a:ln");
+		const stroke = line !== void 0 && palette.hasFill(line) ? palette.fill(line) : styleColor(shape, "a:lnRef", palette);
+		const strokeWidth = stroke === null ? 0 : Math.min(MAX_STROKE, Math.max(1, Math.round(num(attr(line, "w"), DEFAULT_LINE_WIDTH) * this.#options.scale)));
+		const body = kid(shape, "p:txBody");
+		const frame = this.#frame(transform, visit.isDecor);
+		if (body !== void 0 && all(body, "a:t").some((node) => textOf(node).trim() !== "")) {
+			const type = placeholder === void 0 ? null : attr(placeholder, "type") ?? "body";
+			const style = this.#textStyle(visit, chain, type, body);
+			const levels = [...chain.map(levelOf), masterLevel(visit.parts, type)].filter(isDefined);
+			const html = this.#textHtml(body, style, type !== null && BULLET_TYPES.includes(type) && bulletsByDefault(levels), palette);
+			if (placeholder === void 0 && kind !== "line" && (kind !== "rect" || stroke !== null)) return {
+				...frame,
+				type: "shape",
+				shape: kind,
+				fill,
+				stroke,
+				strokeWidth,
+				text: {
+					html,
+					style
+				}
+			};
+			return {
+				...frame,
+				type: "text",
+				html,
+				fill,
+				style
+			};
+		}
+		if (fill === null && stroke === null) return null;
+		return {
+			...frame,
+			type: "shape",
+			shape: line !== void 0 && first(line, "a:tailEnd") !== void 0 && kind === "line" ? "arrow" : kind,
+			fill: kind === "line" ? null : fill,
+			stroke,
+			strokeWidth
+		};
+	}
+	async #pictureInto(visit, node, group) {
+		if (visit.isDecor && first(node, "p:ph") !== void 0) return;
+		const embed = attr(first(node, "a:blip"), "r:embed");
+		const transform = this.#transformOf(kid(node, "p:spPr"), group);
+		const target = embed === void 0 ? void 0 : visit.part.relations[embed]?.target;
+		if (transform === null || target === void 0) return;
+		const fileId = await this.#options.image(target);
+		if (fileId === null) return;
+		const image = {
+			...this.#frame(transform, visit.isDecor),
+			type: "image",
+			fileId,
+			fit: "cover",
+			radius: 0,
+			alt: attr(first(node, "p:cNvPr"), "descr") ?? "",
+			credit: null
+		};
+		visit.elements.push(image);
+	}
+	#tableInto(visit, frame, group) {
+		const table = first(frame, "a:tbl");
+		const transform = this.#transformOf(frame, group);
+		if (table === void 0 || transform === null) return;
+		const rows = all(table, "a:tr").slice(0, MAX_TABLE_ROWS).map((row) => all(row, "a:tc").slice(0, MAX_TABLE_COLUMNS).map((cell) => all(cell, "a:t").map(textOf).join("").slice(0, MAX_CELL_TEXT)));
+		if (rows.length === 0) return;
+		const element = {
+			...this.#frame(transform, visit.isDecor),
+			type: "table",
+			rows,
+			hasHeader: attr(first(table, "a:tblPr"), "firstRow") === "1",
+			fontSize: Math.max(12, Math.round(Math.min(40, transform.h / Math.max(rows.length, 1) * .4))),
+			headerFill: this.#options.theme.accent,
+			borderColor: this.#options.theme.muted
+		};
+		visit.elements.push(element);
+	}
+	async #background(parts) {
+		for (const part of [
+			parts.slide,
+			parts.layout,
+			parts.master
+		]) {
+			const background = part === null ? void 0 : first(part.root, "p:bg");
+			if (part !== null && background !== void 0) return this.#backgroundOf(background, part);
+		}
+		return null;
+	}
+	async #backgroundOf(background, part) {
+		const props = kid(background, "p:bgPr");
+		const embed = attr(props === void 0 ? void 0 : first(props, "a:blip"), "r:embed");
+		const target = embed === void 0 ? void 0 : part.relations[embed]?.target;
+		const fileId = target === void 0 ? null : await this.#options.image(target);
+		if (fileId !== null) return {
+			type: "image",
+			fileId,
+			fit: "cover",
+			dim: 0
+		};
+		const color = props === void 0 ? part.palette.color(kid(background, "p:bgRef")) : part.palette.fill(props);
+		return color === null ? null : {
+			type: "color",
+			color
+		};
+	}
+};
+//#endregion
+export { SlideReader as default };

package/dist/import/pptx-theme.d.ts

@@ -0,0 +1,18 @@
+import { XmlDocument, XmlElement } from "./pptx-xml.js";
+import { DeckTheme } from "@pollium/vyva-core/content";
+//#region src/import/pptx-theme.d.ts
+export interface PptxTheme {
+  colors: Record<string, string>;
+  bodyFont: string | null;
+}
+export declare const themeOf: (document: XmlDocument | undefined) => PptxTheme;
+export default class Palette {
+  #private;
+  constructor(theme: PptxTheme, colorMap: XmlElement | undefined);
+  color(root: XmlElement | undefined): string | null;
+  hasFill(props: XmlElement | undefined): boolean;
+  fill(props: XmlElement | undefined): string | null;
+  deckTheme(): DeckTheme;
+}
+export declare const colorMapOf: (master: XmlElement | undefined) => XmlElement | undefined;
+//#endregion

package/dist/import/pptx-theme.js

@@ -0,0 +1,161 @@
+import { attr, first, kid, kids, num, tags } from "./pptx-xml.js";
+import { FONT_FAMILIES } from "@pollium/vyva-core/content";
+import { DomUtils } from "htmlparser2";
+import { DECK_THEME } from "@pollium/vyva-core/themes";
+//#region src/import/pptx-theme.ts
+const PERCENT = 1e5;
+const HEX = /^[0-9a-f]{6}$/i;
+const COLOR_TAGS = /* @__PURE__ */ new Set([
+	"a:srgbClr",
+	"a:sysClr",
+	"a:schemeClr"
+]);
+const FILL_TAGS = /* @__PURE__ */ new Set([
+	"a:solidFill",
+	"a:gradFill",
+	"a:noFill",
+	"a:blipFill",
+	"a:pattFill",
+	"a:grpFill"
+]);
+const DEFAULT_COLOR_MAP = {
+	bg1: "lt1",
+	tx1: "dk1",
+	bg2: "lt2",
+	tx2: "dk2"
+};
+const FONT_SUBSTITUTES = {
+	arial: "Inter",
+	helvetica: "Inter",
+	"segoe ui": "Inter",
+	calibri: "Open Sans",
+	"calibri light": "Open Sans",
+	verdana: "Open Sans",
+	tahoma: "Open Sans",
+	"century gothic": "Montserrat",
+	"gill sans": "Montserrat",
+	"gill sans mt": "Montserrat",
+	georgia: "Merriweather",
+	cambria: "Lora",
+	"times new roman": "Lora",
+	garamond: "Lora",
+	"courier new": "JetBrains Mono",
+	consolas: "JetBrains Mono"
+};
+const rgbOf = (hex) => {
+	const channel = (at) => Number.parseInt(hex.slice(at, at + 2), 16) / 255;
+	return [
+		channel(0),
+		channel(2),
+		channel(4)
+	];
+};
+const hexOf = (rgb) => `#${rgb.map((channel) => Math.round(Math.min(1, Math.max(0, channel)) * 255).toString(16).padStart(2, "0")).join("")}`;
+const hueChannel = (p, q, at) => {
+	const t = at < 0 ? at + 1 : at > 1 ? at - 1 : at;
+	if (t < 1 / 6) return p + (q - p) * 6 * t;
+	if (t < 1 / 2) return q;
+	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+	return p;
+};
+const withLuminance = (hex, mod, off) => {
+	const [r, g, b] = rgbOf(hex);
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	const lightness = Math.min(1, Math.max(0, (max + min) / 2 * mod + off));
+	if (delta === 0) return hexOf([
+		lightness,
+		lightness,
+		lightness
+	]);
+	const saturation = (max + min) / 2 > .5 ? delta / (2 - max - min) : delta / (max + min);
+	const hue = (max === r ? (g - b) / delta + (g < b ? 6 : 0) : max === g ? (b - r) / delta + 2 : (r - g) / delta + 4) / 6;
+	const q = lightness < .5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
+	const p = 2 * lightness - q;
+	return hexOf([
+		hueChannel(p, q, hue + 1 / 3),
+		hueChannel(p, q, hue),
+		hueChannel(p, q, hue - 1 / 3)
+	]);
+};
+const literalOf = (color) => {
+	const value = color?.name === "a:sysClr" ? attr(color, "lastClr") : color?.name === "a:srgbClr" ? attr(color, "val") : void 0;
+	return value !== void 0 && HEX.test(value) ? value.toLowerCase() : null;
+};
+const fontName = (document, scheme) => {
+	const font = first(document, scheme);
+	return attr(font === void 0 ? void 0 : kid(font, "a:latin"), "typeface") ?? null;
+};
+const themeOf = (document) => {
+	if (document === void 0) return {
+		colors: {},
+		bodyFont: null
+	};
+	const scheme = first(document, "a:clrScheme");
+	return {
+		colors: scheme === void 0 ? {} : Object.fromEntries(tags(scheme).flatMap((slot) => {
+			const value = literalOf(tags(slot)[0]);
+			return value === null ? [] : [[slot.name.replace(/^a:/, ""), value]];
+		})),
+		bodyFont: fontName(document, "a:minorFont")
+	};
+};
+var Palette = class {
+	#theme;
+	#colorMap;
+	constructor(theme, colorMap) {
+		this.#theme = theme;
+		this.#colorMap = {
+			...DEFAULT_COLOR_MAP,
+			...colorMap?.attribs
+		};
+	}
+	color(root) {
+		if (root === void 0) return null;
+		const node = COLOR_TAGS.has(root.name) ? root : DomUtils.findOne((element) => COLOR_TAGS.has(element.name), root.children, true);
+		if (node === null) return null;
+		const base = node.name === "a:schemeClr" ? this.#scheme(attr(node, "val") ?? "") : literalOf(node);
+		if (base === null) return null;
+		const mod = kid(node, "a:lumMod");
+		const off = kid(node, "a:lumOff");
+		if (mod === void 0 && off === void 0) return `#${base}`;
+		return withLuminance(base, num(attr(mod, "val"), PERCENT) / PERCENT, num(attr(off, "val")) / PERCENT);
+	}
+	hasFill(props) {
+		return props !== void 0 && tags(props).some((node) => FILL_TAGS.has(node.name));
+	}
+	fill(props) {
+		if (props === void 0) return null;
+		const solid = kid(props, "a:solidFill");
+		if (solid !== void 0) return this.color(solid);
+		const gradient = kid(props, "a:gradFill");
+		const stop = gradient === void 0 ? void 0 : first(gradient, "a:gs");
+		return stop === void 0 ? null : this.color(stop);
+	}
+	#font() {
+		const name = this.#theme.bodyFont;
+		if (name === null) return null;
+		return FONT_FAMILIES.find((font) => font.toLowerCase() === name.toLowerCase()) ?? FONT_SUBSTITUTES[name.toLowerCase()] ?? null;
+	}
+	deckTheme() {
+		const fallback = DECK_THEME;
+		const slot = (name) => {
+			const value = this.#scheme(name);
+			return value === null ? null : `#${value}`;
+		};
+		return {
+			font: this.#font() ?? fallback.font,
+			background: slot("bg1") ?? fallback.background,
+			text: slot("tx1") ?? fallback.text,
+			accent: slot("accent1") ?? fallback.accent,
+			muted: slot("tx2") ?? fallback.muted
+		};
+	}
+	#scheme(name) {
+		return this.#theme.colors[this.#colorMap[name] ?? name] ?? null;
+	}
+};
+const colorMapOf = (master) => master === void 0 ? void 0 : kids(master, "p:clrMap")[0];
+//#endregion
+export { colorMapOf, Palette as default, themeOf };

package/dist/import/pptx-xml.d.ts

@@ -0,0 +1,23 @@
+import { DomUtils, parseDocument } from "htmlparser2";
+//#region src/import/pptx-xml.d.ts
+export type XmlElement = Parameters<typeof DomUtils.getAttributeValue>[0];
+export type XmlDocument = ReturnType<typeof parseDocument>;
+type XmlRoot = XmlElement | XmlDocument;
+export type PackageFiles = Record<string, Uint8Array>;
+export declare const xml: (text: string) => XmlDocument;
+export declare const all: (root: XmlRoot, name: string) => XmlElement[];
+export declare const first: (root: XmlRoot, name: string) => XmlElement | undefined;
+export declare const tags: (root: XmlRoot) => XmlElement[];
+export declare const kids: (root: XmlElement, name: string) => XmlElement[];
+export declare const kid: (root: XmlElement | undefined, name: string) => XmlElement | undefined;
+export declare const attr: (element: XmlElement | undefined, name: string) => string | undefined;
+export declare const textOf: (element: XmlElement) => string;
+export declare const num: (value: string | undefined, fallback?: number) => number;
+export interface Relation {
+  target: string;
+  type: string;
+}
+export type Relations = Record<string, Relation>;
+export declare const relationsOf: (files: PackageFiles, part: string) => Relations;
+export declare const relatedPart: (relations: Relations, type: string) => string | null;
+//#endregion

package/dist/import/pptx-xml.js

@@ -0,0 +1,27 @@
+import { DomUtils, parseDocument } from "htmlparser2";
+import { strFromU8 } from "fflate";
+import { posix } from "node:path";
+//#region src/import/pptx-xml.ts
+const xml = (text) => parseDocument(text, { xmlMode: true });
+const all = (root, name) => DomUtils.getElementsByTagName(name, root, true);
+const first = (root, name) => all(root, name)[0];
+const tags = (root) => root.children.filter((node) => DomUtils.isTag(node));
+const kids = (root, name) => tags(root).filter((node) => node.name === name);
+const kid = (root, name) => root === void 0 ? void 0 : kids(root, name)[0];
+const attr = (element, name) => element?.attribs[name];
+const textOf = (element) => DomUtils.textContent(element);
+const num = (value, fallback = 0) => {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : fallback;
+};
+const relationsOf = (files, part) => {
+	const data = files[posix.join(posix.dirname(part), "_rels", `${posix.basename(part)}.rels`)];
+	if (data === void 0) return {};
+	return Object.fromEntries(all(xml(strFromU8(data)), "Relationship").map((relation) => [attr(relation, "Id") ?? "", {
+		target: posix.normalize(posix.join(posix.dirname(part), attr(relation, "Target") ?? "")),
+		type: attr(relation, "Type") ?? ""
+	}]));
+};
+const relatedPart = (relations, type) => Object.values(relations).find((relation) => relation.type.endsWith(`/${type}`))?.target ?? null;
+//#endregion
+export { all, attr, first, kid, kids, num, relatedPart, relationsOf, tags, textOf, xml };

package/dist/import/pptx.d.ts

@@ -0,0 +1,9 @@
+import { SaveImage } from "./images.js";
+import { DeckContent } from "@pollium/vyva-core/content";
+//#region src/import/pptx.d.ts
+export interface ImportedDeck {
+  title: string;
+  content: DeckContent;
+}
+export declare const importPptx: (buffer: Buffer, filename: string, saveImage: SaveImage) => Promise<ImportedDeck>;
+//#endregion

package/dist/import/pptx.js

@@ -0,0 +1,112 @@
+import { ConvertError } from "../errors.js";
+import { titleOf } from "./titles.js";
+import { imageSaver } from "./images.js";
+import { all, attr, first, num } from "./pptx-xml.js";
+import PptxPackage from "./pptx-package.js";
+import SlideReader from "./pptx-slide.js";
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { unzipSync } from "fflate";
+import { posix } from "node:path";
+//#region src/import/pptx.ts
+const EMU_PER_INCH = 914400;
+const PX_PER_INCH = 144;
+const DEFAULT_WIDTH = 12192e3;
+const DEFAULT_HEIGHT = 6858e3;
+const MAX_SLIDES = 300;
+const MAX_IMAGES = 80;
+const MAX_UNZIPPED_BYTES = 125829120;
+const IMAGE_TYPES = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp"
+};
+const FORMATS = [
+	{
+		format: "16:9",
+		ratio: 16 / 9
+	},
+	{
+		format: "4:3",
+		ratio: 4 / 3
+	},
+	{
+		format: "1:1",
+		ratio: 1
+	},
+	{
+		format: "a4-landscape",
+		ratio: 1527 / 1080
+	},
+	{
+		format: "a4-portrait",
+		ratio: 1080 / 1527
+	}
+];
+const formatFor = (cx, cy) => {
+	const ratio = cx / Math.max(cy, 1);
+	return FORMATS.reduce((best, candidate) => Math.abs(candidate.ratio - ratio) < Math.abs(best.ratio - ratio) ? candidate : best).format;
+};
+const plainText = (html) => html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+const deckTitle = (titles, slides, filename) => {
+	const biggest = slides[0]?.elements.filter((element) => element.type === "text" && !element.isLocked).sort((a, b) => b.style.fontSize - a.style.fontSize)[0];
+	const title = titles.find((candidate) => candidate !== "") ?? (biggest === void 0 ? "" : plainText(biggest.html));
+	return titleOf(title, filename);
+};
+const unzipped = (buffer) => {
+	let total = 0;
+	return unzipSync(buffer, { filter: (file) => {
+		total += file.originalSize;
+		if (total > MAX_UNZIPPED_BYTES) throw new ConvertError("too-large", `The presentation unzips to more than ${MAX_UNZIPPED_BYTES} bytes`);
+		return file.name.startsWith("ppt/") || file.name === "[Content_Types].xml" || file.name.startsWith("docProps/");
+	} });
+};
+const importPptx = async (buffer, filename, saveImage) => {
+	const files = unzipped(buffer);
+	const pptx = new PptxPackage(files);
+	const presentation = pptx.document("ppt/presentation.xml");
+	if (presentation === void 0) throw new ConvertError("unsupported", `${filename} has no presentation in it`);
+	const size = first(presentation, "p:sldSz");
+	const cx = num(attr(size, "cx"), DEFAULT_WIDTH);
+	const cy = num(attr(size, "cy"), DEFAULT_HEIGHT);
+	const format = formatFor(cx, cy);
+	const relations = pptx.relationsOf("ppt/presentation.xml");
+	const allParts = all(presentation, "p:sldId").map((slide) => relations[attr(slide, "r:id") ?? ""]?.target).filter((path) => path !== void 0).slice(0, MAX_SLIDES).map((path) => pptx.parts(path)).filter((parts) => parts !== null);
+	const theme = allParts[0]?.slide.palette.deckTheme();
+	if (theme === void 0) throw new ConvertError("empty", `${filename} has no slides`);
+	const save = imageSaver(saveImage, filename, MAX_IMAGES);
+	const saved = /* @__PURE__ */ new Map();
+	const reader = new SlideReader({
+		scale: DECK_SIZES[format].width / cx,
+		fontScale: DECK_SIZES[format].width / (cx / EMU_PER_INCH * PX_PER_INCH),
+		theme,
+		image: (path) => {
+			const known = saved.get(path);
+			if (known !== void 0) return known;
+			const data = files[path];
+			const contentType = IMAGE_TYPES[posix.extname(path).slice(1).toLowerCase()];
+			const fileId = data === void 0 || contentType === void 0 ? Promise.resolve(null) : save(data, contentType);
+			saved.set(path, fileId);
+			return fileId;
+		}
+	});
+	const slides = [];
+	const titles = [];
+	for (const parts of allParts) {
+		const read = await reader.read(parts);
+		slides.push(read.slide);
+		titles.push(read.title);
+	}
+	return {
+		title: deckTitle(titles, slides, filename),
+		content: {
+			kind: "deck",
+			format,
+			theme,
+			slides
+		}
+	};
+};
+//#endregion
+export { importPptx };

package/dist/import/titles.d.ts

@@ -0,0 +1,3 @@
+//#region src/import/titles.d.ts
+export declare const titleOf: (text: string, filename: string) => string;
+//#endregion