@pollium/vyva-convert 0.0.0-stage → 0.2.0

package/dist/gotenberg.d.ts

@@ -0,0 +1,8 @@
+import { PdfEngine } from "./export/pdf.js";
+//#region src/gotenberg.d.ts
+export interface GotenbergOptions {
+  url: string;
+  timeoutMs?: number;
+}
+export declare const gotenberg: ({ url, timeoutMs }: GotenbergOptions) => PdfEngine;
+//#endregion

package/dist/gotenberg.js

@@ -0,0 +1,39 @@
+import { ConvertError } from "./errors.js";
+//#region src/gotenberg.ts
+const DEFAULT_TIMEOUT_MS = 6e4;
+const CONVERT_PATH = "/forms/chromium/convert/html";
+const inches = (value) => String(Number(value.toFixed(3)));
+const formOf = ({ html, files, footerHtml, page }) => {
+	const form = new FormData();
+	form.append("files", new Blob([html], { type: "text/html" }), "index.html");
+	for (const file of files) form.append("files", new Blob([new Uint8Array(file.data)], { type: file.contentType }), file.name);
+	if (footerHtml !== null) form.append("files", new Blob([footerHtml], { type: "text/html" }), "footer.html");
+	const { margins } = page;
+	const sizes = {
+		paperWidth: page.width,
+		paperHeight: page.height,
+		marginTop: margins.top,
+		marginBottom: margins.bottom,
+		marginLeft: margins.left,
+		marginRight: margins.right
+	};
+	for (const [field, value] of Object.entries(sizes)) form.append(field, inches(value));
+	form.append("printBackground", "true");
+	form.append("preferCssPageSize", "false");
+	form.append("waitDelay", "0.5s");
+	return form;
+};
+const gotenberg = ({ url, timeoutMs = DEFAULT_TIMEOUT_MS }) => async (job) => {
+	const endpoint = `${url.replace(/\/+$/, "")}${CONVERT_PATH}`;
+	const response = await fetch(endpoint, {
+		method: "POST",
+		body: formOf(job),
+		signal: AbortSignal.timeout(timeoutMs)
+	}).catch((error) => {
+		throw new ConvertError("pdf-failed", `Gotenberg at ${url} could not be reached`, { cause: error });
+	});
+	if (!response.ok) throw new ConvertError("pdf-failed", `Gotenberg answered ${response.status}: ${await response.text().catch(() => "")}`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+//#endregion
+export { gotenberg };

package/dist/import/documents.d.ts

@@ -0,0 +1,12 @@
+import { SaveImage } from "./images.js";
+import { DocumentContent } from "@pollium/vyva-core/content";
+//#region src/import/documents.d.ts
+export interface ImportedDocument {
+  title: string;
+  content: DocumentContent;
+}
+export declare const importDocx: (buffer: Buffer, filename: string, saveImage: SaveImage) => Promise<ImportedDocument>;
+export declare const importMarkdown: (text: string, filename: string) => ImportedDocument;
+export declare const importPlainText: (text: string, filename: string) => ImportedDocument;
+export declare const importPdf: (buffer: Buffer, filename: string) => Promise<ImportedDocument>;
+//#endregion

package/dist/import/documents.js

@@ -0,0 +1,44 @@
+import { htmlToBlocks, paragraphsHtml, titleFrom } from "./html-to-blocks.js";
+import { imageSaver } from "./images.js";
+import { markdownToBlocks } from "@pollium/vyva-core/markdown-blocks";
+import { DEFAULT_DOCUMENT_DESIGN } from "@pollium/vyva-core/themes";
+import mammoth from "mammoth";
+import { extractText, getDocumentProxy } from "unpdf";
+//#region src/import/documents.ts
+const MAX_IMAGES = 60;
+const PAGE_BREAK = "<div data-type=\"page-break\"></div>";
+const documentOf = (blocks, filename) => ({
+	title: titleFrom(blocks, filename),
+	content: {
+		kind: "document",
+		design: DEFAULT_DOCUMENT_DESIGN,
+		blocks
+	}
+});
+const importDocx = async (buffer, filename, saveImage) => {
+	const save = imageSaver(saveImage, filename, MAX_IMAGES);
+	const failures = [];
+	const result = await mammoth.convertToHtml({ buffer }, { convertImage: mammoth.images.imgElement(async (image) => {
+		const data = await image.readAsBuffer();
+		const fileId = await save(data, image.contentType).catch((error) => {
+			failures.push(error);
+			return null;
+		});
+		return fileId === null ? { src: "" } : {
+			src: "",
+			"data-file-id": fileId,
+			alt: ""
+		};
+	}) });
+	if (failures.length > 0) throw failures[0];
+	return documentOf(htmlToBlocks(result.value), filename);
+};
+const importMarkdown = (text, filename) => documentOf(markdownToBlocks(text), filename);
+const importPlainText = (text, filename) => documentOf(htmlToBlocks(paragraphsHtml(text)), filename);
+const importPdf = async (buffer, filename) => {
+	const { text } = await extractText(await getDocumentProxy(new Uint8Array(buffer)), { mergePages: false });
+	const html = text.map((page) => paragraphsHtml(page)).filter((page) => page !== "").join(PAGE_BREAK);
+	return documentOf(htmlToBlocks(html), filename);
+};
+//#endregion
+export { importDocx, importMarkdown, importPdf, importPlainText };

package/dist/import/html-to-blocks.d.ts

@@ -0,0 +1,6 @@
+import { DocumentBlock } from "@pollium/vyva-core/content";
+//#region src/import/html-to-blocks.d.ts
+export declare const htmlToBlocks: (html: string) => DocumentBlock[];
+export declare const titleFrom: (blocks: DocumentBlock[], filename: string) => string;
+export declare const paragraphsHtml: (text: string) => string;
+//#endregion

package/dist/import/html-to-blocks.js

@@ -0,0 +1,58 @@
+import { cleanHtml } from "../clean-html.js";
+import { titleOf } from "./titles.js";
+import { newId } from "@pollium/vyva-core/ids";
+import { DomUtils, parseDocument } from "htmlparser2";
+//#region src/import/html-to-blocks.ts
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"p",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"ul",
+	"ol",
+	"table",
+	"pre",
+	"blockquote",
+	"hr",
+	"div",
+	"img"
+]);
+const HEADINGS = /* @__PURE__ */ new Set(["h5", "h6"]);
+const ENTITIES = {
+	"&": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": "'"
+};
+const htmlToBlocks = (html) => {
+	const blocks = [];
+	let loose = [];
+	const push = (outer) => {
+		const cleaned = cleanHtml(outer);
+		if (cleaned !== "" && cleaned !== "<p></p>") blocks.push({
+			id: newId(),
+			html: cleaned
+		});
+	};
+	const flush = () => {
+		const inner = loose.map((node) => DomUtils.getOuterHTML(node)).join("").trim();
+		loose = [];
+		if (inner !== "") push(`<p>${inner}</p>`);
+	};
+	for (const node of parseDocument(html).children) if (DomUtils.isTag(node) && (BLOCK_TAGS.has(node.name) || HEADINGS.has(node.name))) {
+		flush();
+		push(HEADINGS.has(node.name) ? `<h4>${DomUtils.getInnerHTML(node)}</h4>` : DomUtils.getOuterHTML(node));
+	} else loose.push(node);
+	flush();
+	return blocks;
+};
+const titleFrom = (blocks, filename) => {
+	const heading = blocks.find((block) => /^<h[1-3]/.test(block.html));
+	const text = heading === void 0 ? "" : heading.html.replace(/<[^>]+>/g, "").replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => ENTITIES[entity] ?? entity);
+	return titleOf(text, filename);
+};
+const paragraphsHtml = (text) => text.replace(/\r\n?/g, "\n").split(/\n{2,}/).map((part) => part.trim()).filter((part) => part !== "").map((part) => `<p>${part.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\n/g, "<br>")}</p>`).join("");
+//#endregion
+export { htmlToBlocks, paragraphsHtml, titleFrom };

package/dist/import/images.d.ts

@@ -0,0 +1,10 @@
+//#region src/import/images.d.ts
+export interface NewImage {
+  name: string;
+  data: Uint8Array;
+  contentType: string;
+}
+export type SaveImage = (image: NewImage) => Promise<string | null>;
+export type ImageSaver = (data: Uint8Array, contentType: string) => Promise<string | null>;
+export declare const imageSaver: (saveImage: SaveImage, filename: string, limit: number) => ImageSaver;
+//#endregion

package/dist/import/images.js

@@ -0,0 +1,23 @@
+//#region src/import/images.ts
+const EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp"
+};
+const imageSaver = (saveImage, filename, limit) => {
+	const base = filename.replace(/\.[a-z0-9]+$/i, "");
+	let taken = 0;
+	return async (data, contentType) => {
+		const extension = EXTENSIONS[contentType];
+		if (extension === void 0 || taken >= limit) return null;
+		taken += 1;
+		return saveImage({
+			name: `${base} (image ${taken}).${extension}`,
+			data,
+			contentType
+		});
+	};
+};
+//#endregion
+export { imageSaver };

package/dist/import/pdf-lines.d.ts

@@ -0,0 +1,4 @@
+import { DeckContent } from "@pollium/vyva-core/content";
+//#region src/import/pdf-lines.d.ts
+export declare const joinLines: (deck: DeckContent) => DeckContent;
+//#endregion

package/dist/import/pdf-lines.js

@@ -0,0 +1,206 @@
+import { textHeight, unwrappedWidth } from "../text-measure.js";
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { newId } from "@pollium/vyva-core/ids";
+//#region src/import/pdf-lines.ts
+const BULLET = /^[•▪◦●○■□➢►▸✓✔\-–*]$/;
+const NUMBER = /^(\d{1,3}|[a-zA-Z])[.)]$/;
+const LEADING_BULLET = /^((?:<[^>]+>)*)\s*[•▪◦●○■□➢►▸✓✔\-–*]\s+(?=\S)/u;
+const LEADING_NUMBER = /^((?:<[^>]+>)*)\s*(?:\d{1,3}|[a-z])[.)]\s+(?=\S)/u;
+const MAX_CONTAINER_SHARE = .5;
+const CONTAINER_SLACK = 2;
+const PARAGRAPH = /^<p(?: style="[^"]*")?>([\s\S]*)<\/p>$/;
+const MARKER_REACH_EMS = 3;
+const SAME_EDGE_EMS = .5;
+const SAME_SIZE = .1;
+const MAX_LINE_GAP = 1;
+const PARAGRAPH_GAP = .3;
+const LIST_INDENT_EMS = 1.15;
+const SLIDE_MARGIN = 16;
+const SIDE_SHARE = .3;
+const SPACED_END = /\s(?:<\/[^>]+>)*$/;
+const plain = (html) => html.replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").trim();
+const middle = (element) => element.y + element.h / 2;
+const right = (element) => element.x + element.w;
+const center = (element) => element.x + element.w / 2;
+const area = (element) => element.w * element.h;
+const containerOf = (element, boxes) => boxes.filter((box) => box.x - CONTAINER_SLACK <= element.x && box.y - CONTAINER_SLACK <= element.y && box.x + box.w + CONTAINER_SLACK >= right(element) && box.y + box.h + CONTAINER_SLACK >= element.y + element.h).sort((a, b) => area(a) - area(b))[0] ?? null;
+const lineOf = (element, boxes) => {
+	if (element.type !== "text" || element.isLocked || element.rotation !== 0 || element.fill !== null) return null;
+	const html = PARAGRAPH.exec(element.html)?.[1];
+	if (html === void 0 || html.includes("<p")) return null;
+	const marker = LEADING_BULLET.test(html) ? "bullet" : LEADING_NUMBER.test(html) ? "number" : null;
+	const inner = marker === null ? html : html.replace(marker === "bullet" ? LEADING_BULLET : LEADING_NUMBER, "$1");
+	return {
+		element,
+		inner,
+		text: plain(inner),
+		marker,
+		left: element.x,
+		container: containerOf(element, boxes)
+	};
+};
+const markerOf = (line) => BULLET.test(line.text) ? "bullet" : NUMBER.test(line.text) ? "number" : null;
+const ownerOf = (marker, lines) => lines.find((line) => {
+	const { element } = line;
+	const reach = MARKER_REACH_EMS * element.style.fontSize;
+	const gap = element.x - right(marker.element);
+	return line.marker === null && markerOf(line) === null && gap > -element.style.fontSize && gap < reach && Math.abs(middle(element) - middle(marker.element)) < element.h * .6;
+});
+const isSameSize = (a, b) => Math.abs(a.fontSize - b.fontSize) <= Math.max(a.fontSize, b.fontSize) * SAME_SIZE;
+const alignWith = (block, line) => {
+	const last = block.lines.at(-1)?.element;
+	if (last === void 0) return null;
+	const { element } = line;
+	const edge = SAME_EDGE_EMS * element.style.fontSize;
+	const gap = element.y - (last.y + last.h);
+	if (line.container !== block.lines[0].container) return null;
+	if (!isSameSize(last.style, element.style) || element.y <= last.y || gap > last.h * MAX_LINE_GAP || gap < -last.h * .5) return null;
+	if (gap > last.h * PARAGRAPH_GAP && line.marker === null !== (block.lines[0].marker === null)) return null;
+	if (Math.abs(element.x - block.lines[0].element.x) < edge) return block.lines.length === 1 || block.align === "left" ? "left" : null;
+	if (line.marker === null && Math.abs(center(element) - center(last)) < edge) return block.lines.length === 1 || block.align === "center" ? "center" : null;
+	return null;
+};
+const joined = (lines) => lines.reduce((html, line, index) => {
+	if (index === 0) return line.inner;
+	const previous = lines[index - 1].text;
+	if (/\p{L}-$/u.test(previous) && /^\p{Ll}/u.test(line.text)) return `${html.replace(/-((?:<\/[^>]+>)*)$/, "$1")}${line.inner}`;
+	return SPACED_END.test(html) || /^\s/.test(line.inner) ? `${html}${line.inner}` : `${html} ${line.inner}`;
+}, "");
+const styled = (line, base) => {
+	const { style } = line.element;
+	return style.color.toLowerCase() === base.color.toLowerCase() ? line : {
+		...line,
+		inner: `<span style="color:${style.color}">${line.inner}</span>`
+	};
+};
+const paragraphsOf = (lines) => lines.reduce((paragraphs, line, index) => {
+	const previous = lines[index - 1]?.element;
+	const current = paragraphs.at(-1);
+	if (current === void 0 || previous === void 0 || line.marker !== null || line.element.y - (previous.y + previous.h) > previous.h * PARAGRAPH_GAP || current === void 0) paragraphs.push([line]);
+	else current.push(line);
+	return paragraphs;
+}, []);
+const listTag = (marker) => marker === "bullet" ? "ul" : "ol";
+const htmlOf = (paragraphs) => {
+	let html = "";
+	let open = null;
+	for (const paragraph of paragraphs) {
+		const marker = paragraph[0].marker;
+		if (open !== null && open !== marker) {
+			html += `</${listTag(open)}>`;
+			open = null;
+		}
+		if (marker === null) {
+			html += `<p>${joined(paragraph)}</p>`;
+			continue;
+		}
+		if (open === null) html += `<${listTag(marker)}>`;
+		open = marker;
+		html += `<li>${joined(paragraph)}</li>`;
+	}
+	return open === null ? html : `${html}</${listTag(open)}>`;
+};
+const lineHeightOf = (lines, fontSize, fallback) => {
+	const pitches = lines.slice(1).map((line, index) => line.element.y - lines[index].element.y).filter((pitch) => pitch < fontSize * 3);
+	if (pitches.length === 0) return fallback;
+	const sorted = pitches.sort((a, b) => a - b);
+	return Math.min(3, Math.max(.8, Number((sorted[Math.floor(sorted.length / 2)] / fontSize).toFixed(2))));
+};
+const merged = (block, neighbours, font, slideWidth) => {
+	const [first] = block.lines;
+	const base = {
+		...first.element.style,
+		isBold: block.lines.every((line) => line.element.style.isBold),
+		align: block.align,
+		verticalAlign: "top"
+	};
+	const lines = block.lines.map((line) => styled(line, base));
+	const paragraphs = paragraphsOf(lines);
+	const html = htmlOf(paragraphs);
+	const indent = LIST_INDENT_EMS * base.fontSize;
+	const left = Math.max(0, Math.min(...block.lines.map((line) => line.left)));
+	const last = block.lines[block.lines.length - 1].element;
+	const wanted = Math.max(...block.lines.map((line) => Math.max(right(line.element), left + (line.marker === null ? 0 : indent) + unwrappedWidth(`<p>${line.inner}</p>`, base, font)))) - left;
+	const limit = Math.min(slideWidth - SLIDE_MARGIN, ...neighbours.filter((element) => isInTheWay(element, left, wanted, first.element.y, last.y + last.h)).map((element) => element.x - SLIDE_MARGIN));
+	const w = Math.max(1, Math.round(Math.min(wanted, limit - left)));
+	const style = {
+		...base,
+		lineHeight: lineHeightOf(block.lines, base.fontSize, base.lineHeight)
+	};
+	const height = textHeight(html, style, font, w);
+	return {
+		id: newId(),
+		type: "text",
+		x: Math.round(left),
+		y: first.element.y,
+		w,
+		h: Math.max(1, Math.round(Number.isFinite(height) ? height : first.element.h * block.lines.length)),
+		rotation: 0,
+		opacity: first.element.opacity,
+		isLocked: false,
+		fill: null,
+		html,
+		style
+	};
+};
+const isInTheWay = (element, left, width, top, bottom) => element.x > left + width * SIDE_SHARE && element.x < left + width && element.y < bottom && element.y + element.h > top;
+const blocksOf = (lines) => {
+	const blocks = [];
+	const ordered = [...lines].sort((a, b) => a.element.y - b.element.y || a.element.x - b.element.x);
+	for (const line of ordered) {
+		const match = blocks.map((block) => ({
+			block,
+			align: alignWith(block, line)
+		})).find(({ align }) => align !== null);
+		if (match === void 0 || match.align === null) {
+			blocks.push({
+				lines: [line],
+				align: "left"
+			});
+			continue;
+		}
+		match.block.lines.push(line);
+		match.block.align = match.align;
+	}
+	return blocks;
+};
+const joinSlide = (slide, font, slideWidth, slideHeight) => {
+	const boxes = slide.elements.filter((element) => element.type === "shape" && element.fill !== null && element.shape !== "line" && area(element) < slideWidth * slideHeight * MAX_CONTAINER_SHARE);
+	const lines = slide.elements.map((element) => lineOf(element, boxes)).filter((line) => line !== null);
+	const markers = lines.filter((line) => markerOf(line) !== null);
+	const owned = /* @__PURE__ */ new Set();
+	for (const marker of markers) {
+		const owner = ownerOf(marker, lines);
+		if (owner === void 0) continue;
+		owner.marker = markerOf(marker);
+		owner.left = marker.element.x;
+		owned.add(marker);
+	}
+	const blocks = blocksOf(lines.filter((line) => !owned.has(line)));
+	const replaced = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		if (block.lines.length === 1 && block.lines[0].marker === null) continue;
+		const [head, ...rest] = block.lines;
+		const own = /* @__PURE__ */ new Set([...block.lines.map((line) => line.element), ...[...owned].map((marker) => marker.element)]);
+		replaced.set(head.element, merged(block, slide.elements.filter((element) => !own.has(element)), font, slideWidth));
+		for (const line of rest) replaced.set(line.element, null);
+	}
+	for (const marker of owned) replaced.set(marker.element, null);
+	const elements = slide.elements.flatMap((element) => {
+		const replacement = replaced.get(element);
+		return replacement === void 0 ? [element] : replacement === null ? [] : [replacement];
+	});
+	return {
+		...slide,
+		elements
+	};
+};
+const joinLines = (deck) => {
+	const { width, height } = DECK_SIZES[deck.format];
+	return {
+		...deck,
+		slides: deck.slides.map((slide) => joinSlide(slide, deck.theme.font, width, height))
+	};
+};
+//#endregion
+export { joinLines };

package/dist/import/pdf-slides.d.ts

@@ -0,0 +1,7 @@
+import { SaveImage } from "./images.js";
+import { ImportedDeck } from "./pptx.js";
+//#region src/import/pdf-slides.d.ts
+export type PdfSlides = (pdf: Uint8Array) => Promise<Uint8Array>;
+export declare const isLandscapePdf: (buffer: Buffer) => Promise<boolean>;
+export declare const importPdfSlides: (buffer: Buffer, filename: string, saveImage: SaveImage, pdfSlides: PdfSlides) => Promise<ImportedDeck>;
+//#endregion

package/dist/import/pdf-slides.js

@@ -0,0 +1,21 @@
+import { ConvertError } from "../errors.js";
+import { joinLines } from "./pdf-lines.js";
+import { importPptx } from "./pptx.js";
+import { getDocumentProxy } from "unpdf";
+//#region src/import/pdf-slides.ts
+const isLandscapePdf = async (buffer) => {
+	const { width, height } = (await (await getDocumentProxy(new Uint8Array(buffer))).getPage(1)).getViewport({ scale: 1 });
+	return width > height;
+};
+const importPdfSlides = async (buffer, filename, saveImage, pdfSlides) => {
+	const pptx = await pdfSlides(new Uint8Array(buffer)).catch((error) => {
+		throw error instanceof ConvertError ? error : new ConvertError("slides-failed", `${filename} could not be turned into slides`, { cause: error });
+	});
+	const { title, content } = await importPptx(Buffer.from(pptx), filename, saveImage);
+	return {
+		title,
+		content: joinLines(content)
+	};
+};
+//#endregion
+export { importPdfSlides, isLandscapePdf };

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

@@ -0,0 +1,11 @@
+import { XmlElement } from "./pptx-xml.js";
+import { ShapePoint } from "@pollium/vyva-core/content";
+//#region src/import/pptx-geometry.d.ts
+export type Outline = {
+  kind: 'rect';
+} | {
+  kind: 'polygon';
+  points: ShapePoint[];
+};
+export declare const outlineOf: (geometry: XmlElement, xfrm: XmlElement | undefined) => Outline | null;
+//#endregion

package/dist/import/pptx-geometry.js

@@ -0,0 +1,74 @@
+import { all, attr, num, tags } from "./pptx-xml.js";
+import { MAX_SHAPE_POINTS } from "@pollium/vyva-core/content";
+//#region src/import/pptx-geometry.ts
+const CURVE_STEPS = [
+	.25,
+	.5,
+	.75,
+	1
+];
+const SAME = .001;
+const cubic = (from, [c1, c2, to], t) => {
+	const u = 1 - t;
+	const at = (axis) => u * u * u * from[axis] + 3 * u * u * t * c1[axis] + 3 * u * t * t * c2[axis] + t * t * t * to[axis];
+	return [at(0), at(1)];
+};
+const quadratic = (from, [control, to], t) => {
+	const u = 1 - t;
+	const at = (axis) => u * u * from[axis] + 2 * u * t * control[axis] + t * t * to[axis];
+	return [at(0), at(1)];
+};
+const pointsOf = (step) => all(step, "a:pt").map((point) => [num(attr(point, "x")), num(attr(point, "y"))]);
+const traced = (path) => {
+	const points = [];
+	let moves = 0;
+	for (const step of tags(path)) {
+		const given = pointsOf(step);
+		const from = points.at(-1) ?? [0, 0];
+		if (step.name === "a:moveTo") moves += 1;
+		if (step.name === "a:moveTo" || step.name === "a:lnTo") points.push(...given.slice(-1));
+		else if (step.name === "a:cubicBezTo" && given.length === 3) points.push(...CURVE_STEPS.map((t) => cubic(from, given, t)));
+		else if (step.name === "a:quadBezTo" && given.length === 2) points.push(...CURVE_STEPS.map((t) => quadratic(from, given, t)));
+		else if (step.name !== "a:close") return null;
+	}
+	return moves === 1 ? points : null;
+};
+const isBox = (points) => points.length === 4 && points.every((point) => [point.x, point.y].every((value) => value < SAME || value > .999));
+const thinned = (points) => {
+	const distinct = points.filter((point, index) => {
+		const previous = points[index - 1];
+		return previous === void 0 || Math.abs(point.x - previous.x) > SAME || Math.abs(point.y - previous.y) > SAME;
+	});
+	const [head] = distinct;
+	const tail = distinct.at(-1);
+	const open = distinct.length > 1 && head !== void 0 && tail !== void 0 && Math.abs(head.x - tail.x) < SAME && Math.abs(head.y - tail.y) < SAME ? distinct.slice(0, -1) : distinct;
+	if (open.length <= MAX_SHAPE_POINTS) return open;
+	const stride = open.length / MAX_SHAPE_POINTS;
+	return Array.from({ length: MAX_SHAPE_POINTS }, (_, index) => open[Math.floor(index * stride)]);
+};
+const outlineOf = (geometry, xfrm) => {
+	const paths = all(geometry, "a:path");
+	const [path] = paths;
+	if (paths.length !== 1 || path === void 0) return null;
+	const w = num(attr(path, "w"));
+	const h = num(attr(path, "h"));
+	const steps = traced(path);
+	if (w <= 0 || h <= 0 || steps === null) return null;
+	const flipX = attr(xfrm, "flipH") === "1";
+	const flipY = attr(xfrm, "flipV") === "1";
+	const unit = (value, extent, isFlipped) => {
+		const share = Math.min(1, Math.max(0, value / extent));
+		return Number((isFlipped ? 1 - share : share).toFixed(4));
+	};
+	const points = thinned(steps.map(([x, y]) => ({
+		x: unit(x, w, flipX),
+		y: unit(y, h, flipY)
+	})));
+	if (points.length < 3) return null;
+	return isBox(points) ? { kind: "rect" } : {
+		kind: "polygon",
+		points
+	};
+};
+//#endregion
+export { outlineOf };

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

@@ -0,0 +1,22 @@
+import { PackageFiles, Relations, XmlDocument, XmlElement } from "./pptx-xml.js";
+import Palette from "./pptx-theme.js";
+//#region src/import/pptx-package.d.ts
+export interface SlidePart {
+  root: XmlElement;
+  tree: XmlElement | undefined;
+  relations: Relations;
+  palette: Palette;
+}
+export interface SlideParts {
+  slide: SlidePart;
+  layout: SlidePart | null;
+  master: SlidePart | null;
+}
+export default class PptxPackage {
+  #private;
+  constructor(files: PackageFiles);
+  document(path: string): XmlDocument | undefined;
+  relationsOf(path: string): Relations;
+  parts(slidePath: string): SlideParts | null;
+}
+//#endregion

package/dist/import/pptx-package.js

@@ -0,0 +1,61 @@
+import { first, relatedPart, relationsOf, xml } from "./pptx-xml.js";
+import Palette, { colorMapOf, themeOf } from "./pptx-theme.js";
+import { DomUtils } from "htmlparser2";
+import { strFromU8 } from "fflate";
+//#region src/import/pptx-package.ts
+var PptxPackage = class {
+	#files;
+	#documents = /* @__PURE__ */ new Map();
+	#palettes = /* @__PURE__ */ new Map();
+	constructor(files) {
+		this.#files = files;
+	}
+	document(path) {
+		const known = this.#documents.get(path);
+		if (known !== void 0) return known;
+		const data = this.#files[path];
+		if (data === void 0) return void 0;
+		const document = xml(strFromU8(data));
+		this.#documents.set(path, document);
+		return document;
+	}
+	relationsOf(path) {
+		return relationsOf(this.#files, path);
+	}
+	parts(slidePath) {
+		const slideRelations = relationsOf(this.#files, slidePath);
+		const layoutPath = relatedPart(slideRelations, "slideLayout");
+		const layoutRelations = layoutPath === null ? {} : relationsOf(this.#files, layoutPath);
+		const masterPath = layoutPath === null ? null : relatedPart(layoutRelations, "slideMaster");
+		const palette = this.#palette(masterPath);
+		const slide = this.#part(slidePath, slideRelations, palette);
+		if (slide === null) return null;
+		return {
+			slide,
+			layout: layoutPath === null ? null : this.#part(layoutPath, layoutRelations, palette),
+			master: masterPath === null ? null : this.#part(masterPath, relationsOf(this.#files, masterPath), palette)
+		};
+	}
+	#part(path, relations, palette) {
+		const root = this.document(path)?.children.find((node) => DomUtils.isTag(node));
+		if (root === void 0) return null;
+		return {
+			root,
+			tree: first(root, "p:spTree"),
+			relations,
+			palette
+		};
+	}
+	#palette(masterPath) {
+		const key = masterPath ?? "";
+		const known = this.#palettes.get(key);
+		if (known !== void 0) return known;
+		const masterRoot = (masterPath === null ? void 0 : this.document(masterPath))?.children.find((node) => DomUtils.isTag(node));
+		const themePath = masterPath === null ? null : relatedPart(relationsOf(this.#files, masterPath), "theme");
+		const palette = new Palette(themeOf(themePath === null ? void 0 : this.document(themePath)), colorMapOf(masterRoot));
+		this.#palettes.set(key, palette);
+		return palette;
+	}
+};
+//#endregion
+export { PptxPackage as default };

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

@@ -0,0 +1,11 @@
+import { XmlElement } from "./pptx-xml.js";
+import { SlidePart, SlideParts } from "./pptx-package.js";
+//#region src/import/pptx-placeholders.d.ts
+export declare const TITLE_TYPES: string[];
+export declare const isDefined: <T>(value: T | undefined) => value is T;
+export declare const placeholderChain: (shape: XmlElement, placeholder: XmlElement, parts: SlideParts) => XmlElement[];
+export declare const levelOf: (shape: XmlElement) => XmlElement | undefined;
+export declare const masterLevel: (parts: SlideParts, type: string | null) => XmlElement | undefined;
+export declare const bulletsByDefault: (levels: XmlElement[]) => boolean;
+export declare const decorOf: (parts: SlideParts) => SlidePart[];
+//#endregion