@pollium/vyva-convert 0.3.0 → 0.4.0

package/README.md

@@ -47,6 +47,9 @@ reply.header('content-disposition', contentDisposition('Subnetting guide', file.
 |---|---|
 | Document | `pdf`, `docx`, `html` |
 | Deck | `pptx`, `pdf` |
+| Deck of PDF pages | `pdf` |
+
+`exportFormatsOf(content)` lists them, and `canExport(content, format)` checks one.
 
 - `readImage` is called once for every image the content uses. Return `null` and the export goes
   on without that image.
@@ -56,6 +59,9 @@ reply.header('content-disposition', contentDisposition('Subnetting guide', file.
   page size in inches) and returns the PDF. Use `gotenberg` or write your own with Puppeteer or
   Playwright.
 - The `html` export is one self-contained file, with its images and fonts inline.
+- A deck of PDF pages exports as the original PDF, read through `readImage`, with what the slides
+  add printed on top of each page. Pages with nothing added are copied as they are, and a deck
+  nobody drew on never reaches the PDF engine. An encrypted PDF is refused as `unsupported`.
 
 ## Importing
 
@@ -71,19 +77,20 @@ const { title, content } = await importFile(upload.bytes, upload.filename, {
   are told apart by what their zip holds, Word 97 and PowerPoint 97 files by the streams they hold,
   and PDF, RTF, PNG, JPEG, GIF and WebP by their signatures. Only Markdown (`.md`) and text
   (`.txt`) are recognized by their extension, and only when they are valid UTF-8.
-- Word, PDF, Markdown and text files become documents, and PowerPoint files become decks. A deck
+- Word, Markdown and text files become documents, and PowerPoint files become decks. A deck
   keeps its theme colors and the font most of its text uses. What its slide master draws comes in
   locked, behind the slide's own elements, and freeform shapes come in as polygons.
+- A PDF becomes a deck of its own pages: one slide for each page, at the size of the first page,
+  with that page behind it. Nothing is converted, so it looks exactly like the original.
+  `saveImage` stores the PDF once, as `application/pdf`; return `null` and the import is refused as
+  `empty`. A PDF Vyva cannot open is refused as `unsupported`, and one of more than 1000 pages as
+  `too-large`.
 - A picture becomes a deck of one slide, in the format closest to its shape, with the picture
   filling it. `saveImage` stores it like any other image; return `null` and the import is refused
   as `empty`.
-- With `officeEngine`, Vyva reads what it cannot read alone. Every PDF becomes a deck: each page a
-  slide, portrait pages on a portrait slide, with its pictures and shapes where they were, and the
-  loose lines a PDF keeps joined back into paragraphs and lists. A PDF of more than 300 pages is
-  refused as `too-large` before the engine runs. Word 97, OpenDocument text and RTF files are
-  turned into Word, and PowerPoint 97 and OpenDocument presentations into PowerPoint, then imported
-  as those. Without an engine a PDF becomes a document of its text, and the older formats are
-  refused as `unsupported`.
+- With `officeEngine`, Vyva reads what it cannot read alone. Word 97, OpenDocument text and RTF
+  files are turned into Word, and PowerPoint 97 and OpenDocument presentations into PowerPoint,
+  then imported as those. Without an engine those formats are refused as `unsupported`.
 
   `officeEngine` takes `{ file, from, to }` and returns the converted file. `libreOffice()` from
   `@pollium/vyva-convert/libreoffice` does that with the `soffice` on the machine (`command` changes

package/dist/export/bundle.d.ts

@@ -18,6 +18,7 @@ export interface ExportBundle {
   title: string;
   language: string;
   images: Map<string, BundleImage>;
+  pdfs: Map<string, Buffer>;
   fonts: FontFamily[];
 }
 export interface ExportedFile {

package/dist/export/bundle.js

@@ -8,6 +8,7 @@ const EXTENSIONS = {
 	"image/gif": "gif",
 	"image/webp": "webp"
 };
+const PDF_TYPE = "application/pdf";
 const fontsOf = (content) => {
 	if (content.kind === "document") return [content.design.font, CODE_FONT];
 	return content.slides.some((slide) => slide.elements.some((element) => element.type === "code")) ? [content.theme.font, CODE_FONT] : [content.theme.font];
@@ -27,13 +28,18 @@ const bundleImage = (id, stored) => {
 const bundleOf = async (content, { title, language, readImage }) => {
 	const ids = fileIdsOf(content);
 	const stored = await Promise.all(ids.map((id) => readImage(id)));
+	const found = ids.flatMap((id, index) => {
+		const file = stored[index];
+		return file === null ? [] : [{
+			id,
+			file
+		}];
+	});
 	return {
 		title,
 		language,
-		images: new Map(ids.flatMap((id, index) => {
-			const image = stored[index];
-			return image === null ? [] : [[id, bundleImage(id, image)]];
-		})),
+		images: new Map(found.filter(({ file }) => file.contentType !== PDF_TYPE).map(({ id, file }) => [id, bundleImage(id, file)])),
+		pdfs: new Map(found.filter(({ file }) => file.contentType === PDF_TYPE).map(({ id, file }) => [id, Buffer.from(file.data)])),
 		fonts: fontsOf(content)
 	};
 };

package/dist/export/html.js

@@ -1,5 +1,5 @@
 import { fontFaces, fontFilesOf } from "./fonts.js";
-import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { deckSize } from "@pollium/vyva-core/content";
 import { CONTENT_CSS, renderDocument, renderSlide } from "@pollium/vyva-core/render";
 import { escapeHtml } from "@pollium/vyva-core/escape";
 //#region src/export/html.ts
@@ -9,7 +9,7 @@ const SCREEN_CSS = "body{margin:0;background:#f3f4f6;display:flex;justify-conten
 const dataUrl = (contentType, data) => `data:${contentType};base64,${data.toString("base64")}`;
 const bodyOf = (content, fileUrl) => {
 	if (content.kind === "document") return renderDocument(content, fileUrl);
-	const { width, height } = DECK_SIZES[content.format];
+	const { width, height } = deckSize(content.format);
 	const zoom = SCREEN_PX_PER_INCH / SLIDE_PX_PER_INCH;
 	return content.slides.map((slide) => `<div class="vy-print-slide" style="width:${width * zoom}px;height:${height * zoom}px"><div style="width:${width}px;height:${height}px;transform:scale(${zoom});transform-origin:0 0">${renderSlide(slide, content, fileUrl)}</div></div>`).join("");
 };

package/dist/export/pdf-pages.d.ts

@@ -0,0 +1,5 @@
+import { ExportBundle } from "./bundle.js";
+import { DeckContent } from "@pollium/vyva-core/content";
+//#region src/export/pdf-pages.d.ts
+export declare const onPdfPages: (deck: DeckContent, bundle: ExportBundle, print: () => Promise<Uint8Array>) => Promise<Uint8Array>;
+//#endregion

package/dist/export/pdf-pages.js

@@ -0,0 +1,110 @@
+import { ConvertError } from "../errors.js";
+import { frameLayers } from "@pollium/vyva-core/deck-frame";
+import { PDFDocument, concatTransformationMatrix, drawObject, popGraphicsState, pushGraphicsState } from "pdf-lib";
+//#region src/export/pdf-pages.ts
+const pdfPageOf = (slide) => slide.background?.type === "pdf-page" ? slide.background : null;
+const drawsOver = (slide, deck) => {
+	const { under, over } = frameLayers(slide, deck);
+	return slide.elements.length > 0 || under !== "" || over !== "";
+};
+const loaded = (data, what) => PDFDocument.load(data).catch((error) => {
+	throw new ConvertError("unsupported", `${what} cannot be copied into the exported PDF`, { cause: error });
+});
+const placement = (page, overlay) => {
+	const { x, y, width, height } = page.getCropBox();
+	const rotation = (page.getRotation().angle % 360 + 360) % 360;
+	const isTurned = rotation === 90 || rotation === 270;
+	const visibleWidth = isTurned ? height : width;
+	const visibleHeight = isTurned ? width : height;
+	const scale = Math.min(visibleWidth / overlay.width, visibleHeight / overlay.height);
+	const left = (visibleWidth - overlay.width * scale) / 2;
+	const top = (visibleHeight - overlay.height * scale) / 2;
+	const tall = overlay.height * scale;
+	if (rotation === 90) return [
+		0,
+		scale,
+		-scale,
+		0,
+		x + top + tall,
+		y + left
+	];
+	if (rotation === 180) return [
+		-scale,
+		0,
+		0,
+		-scale,
+		x + width - left,
+		y + top + tall
+	];
+	if (rotation === 270) return [
+		0,
+		-scale,
+		scale,
+		0,
+		x + width - top - tall,
+		y + height - left
+	];
+	return [
+		scale,
+		0,
+		0,
+		scale,
+		x + left,
+		y + height - top - tall
+	];
+};
+const stamp = (page, overlay) => {
+	const { context } = page.doc;
+	page.node.normalize();
+	page.node.wrapContentStreams(context.register(context.contentStream([pushGraphicsState()])), context.register(context.contentStream([popGraphicsState()])));
+	const name = page.node.newXObject("VyvaOverlay", overlay.ref);
+	page.pushOperators(pushGraphicsState(), concatTransformationMatrix(...placement(page, overlay)), drawObject(name), popGraphicsState());
+};
+const sourcePagesOf = (deck, pdfs) => deck.slides.flatMap((slide, index) => {
+	const background = pdfPageOf(slide);
+	return background !== null && pdfs.has(background.fileId) ? [{
+		slide: index,
+		fileId: background.fileId,
+		page: background.page
+	}] : [];
+});
+const copySources = async (output, wanted, pdfs) => {
+	const placed = [];
+	for (const [fileId, data] of pdfs) {
+		const pages = wanted.filter((source) => source.fileId === fileId);
+		if (pages.length === 0) continue;
+		const source = await loaded(data, `The PDF ${fileId}`);
+		if (pages.some(({ page }) => page > source.getPageCount())) throw new ConvertError("unsupported", `The PDF ${fileId} has fewer pages than the deck shows`);
+		const copied = await output.copyPages(source, pages.map(({ page }) => page - 1));
+		placed.push(...copied.map((page, at) => ({
+			slide: pages[at].slide,
+			page
+		})));
+	}
+	return placed;
+};
+const copyPrinted = async (output, printed, slides) => {
+	return (await output.copyPages(printed, slides)).map((page, at) => ({
+		slide: slides[at],
+		page
+	}));
+};
+const stampAll = async (output, printed, sources, deck) => {
+	const stamped = sources.filter(({ slide }) => drawsOver(deck.slides[slide], deck));
+	const overlays = await output.embedPages(stamped.map(({ slide }) => printed.getPage(slide)));
+	stamped.forEach(({ page }, index) => stamp(page, overlays[index]));
+};
+const onPdfPages = async (deck, bundle, print) => {
+	const wanted = sourcePagesOf(deck, bundle.pdfs);
+	const fromSource = new Set(wanted.map(({ slide }) => slide));
+	const printed = deck.slides.some((slide, index) => !fromSource.has(index) || drawsOver(slide, deck)) ? await loaded(await print(), "The printed slides") : null;
+	const output = await PDFDocument.create();
+	output.setTitle(bundle.title);
+	const sources = await copySources(output, wanted, bundle.pdfs);
+	const others = printed === null ? [] : await copyPrinted(output, printed, deck.slides.map((_, index) => index).filter((index) => !fromSource.has(index)));
+	if (printed !== null) await stampAll(output, printed, sources, deck);
+	for (const { page } of [...sources, ...others].sort((a, b) => a.slide - b.slide)) output.addPage(page);
+	return output.save();
+};
+//#endregion
+export { onPdfPages };

package/dist/export/pdf.js

@@ -1,6 +1,7 @@
 import { fontFaces, fontFilesOf } from "./fonts.js";
 import { bodyOf, pageHtml } from "./html.js";
-import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { onPdfPages } from "./pdf-pages.js";
+import { deckSize, hasPdfPages } from "@pollium/vyva-core/content";
 import { CONTENT_CSS } from "@pollium/vyva-core/render";
 import { escapeHtml } from "@pollium/vyva-core/escape";
 //#region src/export/pdf.ts
@@ -31,7 +32,7 @@ html,body{margin:0;padding:0;-webkit-print-color-adjust:exact;print-color-adjust
 const inches = (mm) => mm / MM_PER_INCH;
 const pageOf = (content) => {
 	if (content.kind === "deck") {
-		const { width, height } = DECK_SIZES[content.format];
+		const { width, height } = deckSize(content.format);
 		return {
 			width: width / SLIDE_PX_PER_INCH,
 			height: height / SLIDE_PX_PER_INCH,
@@ -58,24 +59,27 @@ const footerOf = (content) => {
 	const side = (mm) => `${inches(mm).toFixed(3)}in`;
 	return `<html><head><style>.vy-page-footer{box-sizing:border-box;display:flex;justify-content:space-between;width:100%;padding:0 ${side(design.margins.right)} 0 ${side(design.margins.left)};font-family:system-ui,-apple-system,'Segoe UI',sans-serif;font-size:8pt;color:#6b7280}</style></head><body><div class="vy-page-footer"><span>${text}</span>${number}</div></body></html>`;
 };
-const buildPdf = async (content, bundle, engine) => {
+const print = async (content, bundle, engine) => {
 	const fonts = await fontFilesOf(bundle.fonts);
 	const css = `${fontFaces(fonts, (file) => file.name)}${CONTENT_CSS}${PRINT_CSS}`;
+	return engine({
+		html: pageHtml(bundle, css, bodyOf(content, (id) => bundle.images.get(id)?.name ?? null)),
+		files: [...[...bundle.images.values()].map(({ name, data, contentType }) => ({
+			name,
+			data,
+			contentType
+		})), ...fonts.map(({ name, data }) => ({
+			name,
+			data,
+			contentType: "font/woff2"
+		}))],
+		footerHtml: footerOf(content),
+		page: pageOf(content)
+	});
+};
+const buildPdf = async (content, bundle, engine) => {
 	return {
-		data: await engine({
-			html: pageHtml(bundle, css, bodyOf(content, (id) => bundle.images.get(id)?.name ?? null)),
-			files: [...[...bundle.images.values()].map(({ name, data, contentType }) => ({
-				name,
-				data,
-				contentType
-			})), ...fonts.map(({ name, data }) => ({
-				name,
-				data,
-				contentType: "font/woff2"
-			}))],
-			footerHtml: footerOf(content),
-			page: pageOf(content)
-		}),
+		data: content.kind === "deck" && hasPdfPages(content) ? await onPdfPages(content, bundle, () => print(content, bundle, engine)) : await print(content, bundle, engine),
 		contentType: "application/pdf",
 		extension: "pdf"
 	};

package/dist/export/pptx.js

@@ -1,6 +1,6 @@
 import { blocksOfHtml } from "./html-blocks.js";
 import { CODE_FONT, CODE_LINE_HEIGHT, CODE_PALETTES, codeLines } from "@pollium/vyva-core/code";
-import { DECK_SIZES, TEXT_SHAPES } from "@pollium/vyva-core/content";
+import { TEXT_SHAPES, deckSize } from "@pollium/vyva-core/content";
 import { bandHeight, footerHeight, footerSegments, hasBand, hasFooter, inkOn } from "@pollium/vyva-core/deck-frame";
 import PptxGenJS from "pptxgenjs";
 //#region src/export/pptx.ts
@@ -250,7 +250,7 @@ const addBackground = (slide, background, deck, bundle) => {
 		if (image !== void 0) {
 			slide.background = { data: dataUrl(image.contentType, image.data) };
 			if (background.dim > 0) {
-				const { width, height } = DECK_SIZES[deck.format];
+				const { width, height } = deckSize(deck.format);
 				slide.addShape("rect", {
 					x: 0,
 					y: 0,
@@ -270,7 +270,7 @@ const addBackground = (slide, background, deck, bundle) => {
 };
 const addBand = (slide, source, deck) => {
 	if (!hasBand(deck.theme, source)) return;
-	const { width } = DECK_SIZES[deck.format];
+	const { width } = deckSize(deck.format);
 	slide.addShape("rect", {
 		x: 0,
 		y: 0,
@@ -282,7 +282,7 @@ const addBand = (slide, source, deck) => {
 };
 const addFooter = (slide, source, deck) => {
 	if (!hasFooter(deck.theme, source)) return;
-	const { width, height } = DECK_SIZES[deck.format];
+	const { width, height } = deckSize(deck.format);
 	const tall = footerHeight(deck.format);
 	const third = width / 3;
 	footerSegments(source, deck).forEach((segment, index) => {
@@ -302,7 +302,7 @@ const addFooter = (slide, source, deck) => {
 	});
 };
 const buildPptx = async (deck, bundle) => {
-	const { width, height } = DECK_SIZES[deck.format];
+	const { width, height } = deckSize(deck.format);
 	const pptx = new PptxGenJS();
 	pptx.defineLayout({
 		name: LAYOUT,

package/dist/export.d.ts

@@ -14,6 +14,7 @@ export interface ExportOptions {
   language?: string;
 }
 export declare const isExportFormat: (value: unknown) => value is ExportFormat;
-export declare const canExport: (kind: ContentKind, format: ExportFormat) => boolean;
+export declare const exportFormatsOf: (content: Content) => readonly ExportFormat[];
+export declare const canExport: (content: Content, format: ExportFormat) => boolean;
 export declare const exportContent: (content: Content, format: ExportFormat, { title, readImage, pdfEngine, language }: ExportOptions) => Promise<ExportedFile>;
 //#endregion

package/dist/export.js

@@ -4,6 +4,7 @@ import { buildDocx } from "./export/docx.js";
 import { buildHtml } from "./export/html.js";
 import { buildPdf } from "./export/pdf.js";
 import { buildPptx } from "./export/pptx.js";
+import { hasPdfPages } from "@pollium/vyva-core/content";
 //#region src/export.ts
 const EXPORT_FORMATS = {
 	document: [
@@ -16,15 +17,14 @@ const EXPORT_FORMATS = {
 const DEFAULT_LANGUAGE = "en";
 const FORMATS = new Set(Object.values(EXPORT_FORMATS).flat());
 const isExportFormat = (value) => typeof value === "string" && FORMATS.has(value);
-const canExport = (kind, format) => {
-	return EXPORT_FORMATS[kind].includes(format);
-};
+const exportFormatsOf = (content) => hasPdfPages(content) ? ["pdf"] : EXPORT_FORMATS[content.kind];
+const canExport = (content, format) => exportFormatsOf(content).includes(format);
 const engineOf = (engine) => {
 	if (engine === void 0) throw new TypeError("Exporting as pdf needs a pdfEngine");
 	return engine;
 };
 const exportContent = async (content, format, { title, readImage, pdfEngine, language = DEFAULT_LANGUAGE }) => {
-	if (!canExport(content.kind, format)) throw new ConvertError("unsupported", `A ${content.kind} cannot be exported as ${format}`);
+	if (!canExport(content, format)) throw new ConvertError("unsupported", `This ${content.kind} cannot be exported as ${format}`);
 	const engine = format === "pdf" ? engineOf(pdfEngine) : null;
 	const bundle = await bundleOf(content, {
 		title,
@@ -36,4 +36,4 @@ const exportContent = async (content, format, { title, readImage, pdfEngine, lan
 	return content.kind === "document" ? buildDocx(content, bundle) : buildPptx(content, bundle);
 };
 //#endregion
-export { EXPORT_FORMATS, canExport, exportContent, isExportFormat };
+export { EXPORT_FORMATS, canExport, exportContent, exportFormatsOf, isExportFormat };

package/dist/import/deck-format.d.ts

@@ -1,4 +1,4 @@
-import { DeckFormat } from "@pollium/vyva-core/content";
+import { DeckPreset } from "@pollium/vyva-core/content";
 //#region src/import/deck-format.d.ts
-export declare const formatFor: (width: number, height: number) => DeckFormat;
+export declare const formatFor: (width: number, height: number) => DeckPreset;
 //#endregion

package/dist/import/documents.d.ts

@@ -8,5 +8,4 @@ export interface ImportedDocument {
 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

@@ -3,10 +3,8 @@ 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: {
@@ -35,10 +33,5 @@ const importDocx = async (buffer, filename, saveImage) => {
 };
 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 };
+export { importDocx, importMarkdown, importPlainText };

package/dist/import/image.js

@@ -3,9 +3,9 @@ import { imageSize } from "../export/image-size.js";
 import { titleOf } from "./titles.js";
 import { imageSaver } from "./images.js";
 import { formatFor } from "./deck-format.js";
+import { PLAIN_THEME } from "./plain-theme.js";
 import { DECK_SIZES } from "@pollium/vyva-core/content";
 import { newId } from "@pollium/vyva-core/ids";
-import { DECK_THEME } from "@pollium/vyva-core/themes";
 //#region src/import/image.ts
 const PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
 const JPEG_SIGNATURE = Buffer.from("ffd8ff", "hex");
@@ -25,13 +25,12 @@ const importImage = async (buffer, filename, contentType, saveImage) => {
 	const scale = Math.min(slide.width / size.width, slide.height / size.height);
 	const w = Math.round(size.width * scale);
 	const h = Math.round(size.height * scale);
-	const { frame: _frame, ...theme } = DECK_THEME;
 	return {
 		title: titleOf("", filename),
 		content: {
 			kind: "deck",
 			format,
-			theme,
+			theme: PLAIN_THEME,
 			slides: [{
 				id: newId(),
 				background: null,

package/dist/import/office.d.ts

@@ -2,7 +2,7 @@
 export type LegacyOffice = 'doc' | 'ppt' | 'odt' | 'odp' | 'rtf';
 export interface OfficeJob {
   file: Uint8Array;
-  from: 'pdf' | LegacyOffice;
+  from: LegacyOffice;
   to: 'docx' | 'pptx';
 }
 export type OfficeEngine = (job: OfficeJob) => Promise<Uint8Array>;

package/dist/import/pdf.d.ts

@@ -0,0 +1,5 @@
+import { SaveImage } from "./images.js";
+import { ImportedDeck } from "./pptx.js";
+//#region src/import/pdf.d.ts
+export declare const importPdf: (buffer: Buffer, filename: string, saveImage: SaveImage) => Promise<ImportedDeck>;
+//#endregion

package/dist/import/pdf.js

@@ -0,0 +1,49 @@
+import { ConvertError } from "../errors.js";
+import { titleOf } from "./titles.js";
+import { PLAIN_THEME } from "./plain-theme.js";
+import { MAX_EXTENT, MAX_SLIDES } from "@pollium/vyva-core/content";
+import { newId } from "@pollium/vyva-core/ids";
+import { getDocumentProxy } from "unpdf";
+//#region src/import/pdf.ts
+const PX_PER_POINT = 2;
+const PDF_TYPE = "application/pdf";
+const slideSizeOf = (width, height) => {
+	const scale = Math.min(PX_PER_POINT, MAX_EXTENT / Math.max(width, height));
+	return {
+		width: Math.max(1, Math.round(width * scale)),
+		height: Math.max(1, Math.round(height * scale))
+	};
+};
+const opened = (buffer, filename) => getDocumentProxy(new Uint8Array(buffer)).catch((error) => {
+	throw new ConvertError("unsupported", `${filename} is a PDF Vyva cannot open`, { cause: error });
+});
+const importPdf = async (buffer, filename, saveImage) => {
+	const pdf = await opened(buffer, filename);
+	if (pdf.numPages > MAX_SLIDES) throw new ConvertError("too-large", `${filename} has ${pdf.numPages} pages, more than the ${MAX_SLIDES} slides a deck holds`);
+	const { width, height } = (await pdf.getPage(1)).getViewport({ scale: 1 });
+	const fileId = await saveImage({
+		name: filename,
+		data: buffer,
+		contentType: PDF_TYPE
+	});
+	if (fileId === null) throw new ConvertError("empty", `${filename} was not stored, so there is nothing to show`);
+	return {
+		title: titleOf("", filename),
+		content: {
+			kind: "deck",
+			format: slideSizeOf(width, height),
+			theme: PLAIN_THEME,
+			slides: Array.from({ length: pdf.numPages }, (_, index) => ({
+				id: newId(),
+				background: {
+					type: "pdf-page",
+					fileId,
+					page: index + 1
+				},
+				elements: []
+			}))
+		}
+	};
+};
+//#endregion
+export { importPdf };

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

@@ -0,0 +1,4 @@
+import { DeckTheme } from "@pollium/vyva-core/content";
+//#region src/import/plain-theme.d.ts
+export declare const PLAIN_THEME: DeckTheme;
+//#endregion

package/dist/import/plain-theme.js

@@ -0,0 +1,6 @@
+import { DECK_THEME } from "@pollium/vyva-core/themes";
+//#region src/import/plain-theme.ts
+const { frame: _frame, ...unframed } = DECK_THEME;
+const PLAIN_THEME = unframed;
+//#endregion
+export { PLAIN_THEME };

package/dist/import/pptx.d.ts

@@ -1,7 +1,6 @@
 import { SaveImage } from "./images.js";
 import { DeckContent } from "@pollium/vyva-core/content";
 //#region src/import/pptx.d.ts
-export declare const MAX_SLIDES = 300;
 export interface ImportedDeck {
   title: string;
   content: DeckContent;

package/dist/import/pptx.js

@@ -6,7 +6,7 @@ import { all, attr, first, num, textOf } from "./pptx-xml.js";
 import { familyOf } from "./pptx-theme.js";
 import PptxPackage from "./pptx-package.js";
 import SlideReader from "./pptx-slide.js";
-import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { DECK_SIZES, MAX_SLIDES } from "@pollium/vyva-core/content";
 import { unzipSync } from "fflate";
 import { posix } from "node:path";
 //#region src/import/pptx.ts
@@ -14,7 +14,6 @@ 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 = {
@@ -57,7 +56,7 @@ const importPptx = async (buffer, filename, saveImage) => {
 	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, 300).map((path) => pptx.parts(path)).filter((parts) => parts !== null);
+	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 themed = allParts[0]?.slide.palette.deckTheme();
 	if (themed === void 0) throw new ConvertError("empty", `${filename} has no slides`);
 	const theme = {
@@ -98,4 +97,4 @@ const importPptx = async (buffer, filename, saveImage) => {
 	};
 };
 //#endregion
-export { MAX_SLIDES, importPptx };
+export { importPptx };

package/dist/import.js

@@ -1,9 +1,9 @@
 import { ConvertError } from "./errors.js";
-import { importDocx, importMarkdown, importPdf, importPlainText } from "./import/documents.js";
+import { importDocx, importMarkdown, importPlainText } from "./import/documents.js";
 import { imageTypeOf, importImage } from "./import/image.js";
 import { runOffice } from "./import/office.js";
+import { importPdf } from "./import/pdf.js";
 import { importPptx } from "./import/pptx.js";
-import { importPdfSlides } from "./import/pdf-slides.js";
 import { strFromU8, unzipSync } from "fflate";
 //#region src/import.ts
 const MAX_IMPORT_BYTES = 26214400;
@@ -87,7 +87,7 @@ const convert = async (detected, buffer, filename, options) => {
 	switch (detected) {
 		case "docx": return importDocx(buffer, filename, saveImage);
 		case "pptx": return importPptx(buffer, filename, saveImage);
-		case "pdf": return officeEngine === void 0 ? importPdf(buffer, filename) : importPdfSlides(buffer, filename, saveImage, officeEngine);
+		case "pdf": return importPdf(buffer, filename, saveImage);
 		case "markdown": return importMarkdown(textOf(buffer), filename);
 		case "text": return importPlainText(textOf(buffer), filename);
 		case "image/png":

package/dist/libreoffice.js

@@ -16,7 +16,6 @@ const libreOffice = ({ command = "soffice", timeoutMs = DEFAULT_TIMEOUT_MS } = {
 		await run(command, [
 			`-env:UserInstallation=${pathToFileURL(join(folder, "profile")).href}`,
 			"--headless",
-			...from === "pdf" ? ["--infilter=impress_pdf_import"] : [],
 			"--convert-to",
 			to,
 			"--outdir",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pollium/vyva-convert",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Server-side tools for Vyva content: clean what clients send, import Word, PowerPoint, PDF, OpenDocument, Markdown and image files, and export to PDF, Word, PowerPoint and HTML.",
   "type": "module",
   "sideEffects": false,
@@ -34,10 +34,11 @@
     "fflate": "^0.8.3",
     "htmlparser2": "^10.1.0",
     "mammoth": "^1.13.0",
+    "pdf-lib": "1.17.1",
     "pptxgenjs": "^4.0.1",
     "sanitize-html": "^2.18.0",
     "unpdf": "^1.8.1",
-    "@pollium/vyva-core": "0.2.0"
+    "@pollium/vyva-core": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.6.4",

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

@@ -1,4 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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 && right(block.lines[0].element) <= slideWidth - SLIDE_MARGIN) 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

@@ -1,6 +0,0 @@
-import { SaveImage } from "./images.js";
-import { OfficeEngine } from "./office.js";
-import { ImportedDeck } from "./pptx.js";
-//#region src/import/pdf-slides.d.ts
-export declare const importPdfSlides: (buffer: Buffer, filename: string, saveImage: SaveImage, officeEngine: OfficeEngine) => Promise<ImportedDeck>;
-//#endregion

package/dist/import/pdf-slides.js

@@ -1,22 +0,0 @@
-import { ConvertError } from "../errors.js";
-import { runOffice } from "./office.js";
-import { joinLines } from "./pdf-lines.js";
-import { importPptx } from "./pptx.js";
-import { getDocumentProxy } from "unpdf";
-//#region src/import/pdf-slides.ts
-const importPdfSlides = async (buffer, filename, saveImage, officeEngine) => {
-	const { numPages } = await getDocumentProxy(new Uint8Array(buffer));
-	if (numPages > 300) throw new ConvertError("too-large", `${filename} has ${numPages} pages, more than the 300 slides a deck holds`);
-	const pptx = await runOffice(officeEngine, {
-		file: buffer,
-		from: "pdf",
-		to: "pptx"
-	}, filename);
-	const { title, content } = await importPptx(pptx, filename, saveImage);
-	return {
-		title,
-		content: joinLines(content)
-	};
-};
-//#endregion
-export { importPdfSlides };