@pollium/vyva-convert 0.2.0 → 0.4.0

package/README.md

@@ -1,7 +1,8 @@
 # @pollium/vyva-convert
 
 Server-side tools for Vyva content. It cleans what clients send, imports Word, PowerPoint, PDF,
-Markdown and text files, and exports to PDF, Word, PowerPoint and HTML. It runs in Node.
+OpenDocument, RTF, Markdown, text and image files, and exports to PDF, Word, PowerPoint and HTML.
+It runs in Node.
 
 ```sh
 npm install @pollium/vyva-convert
@@ -46,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.
@@ -55,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
 
@@ -66,22 +73,33 @@ const { title, content } = await importFile(upload.bytes, upload.filename, {
 });
 ```
 
-- The file is recognized by its content, not its name. Word and PowerPoint files are told apart
-  by what their zip holds, and PDF by its signature. 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
+- The file is recognized by its content, not its name. Word, PowerPoint and OpenDocument files
+  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, 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.
-- With `pdfSlides`, a PDF whose pages are landscape becomes a deck instead: each page a slide, with
-  its pictures and shapes where they were, and the loose lines a PDF keeps joined back into
-  paragraphs and lists. A portrait PDF stays a document. `pdfSlides` takes the PDF and returns it as
-  a PowerPoint file; `libreOffice()` from `@pollium/vyva-convert/libreoffice` does that with the
-  `soffice` on the machine (`command` changes the path), one conversion per call:
+- 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. 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
+  the path), one conversion per call:
 
   ```ts
   import { libreOffice } from '@pollium/vyva-convert/libreoffice';
 
-  await importFile(upload.bytes, upload.filename, { saveImage, pdfSlides: libreOffice() });
+  await importFile(upload.bytes, upload.filename, { saveImage, officeEngine: libreOffice() });
   ```
 - `saveImage` stores each image and returns its file id, which must be a UUID. Return `null` to
   leave the image out. If it throws, the import fails with your error.
@@ -98,4 +116,4 @@ a bug or a broken file, so log it.
 | `too-large` | The file, or what it unzips to, is over the limit |
 | `empty` | The file has nothing to import |
 | `pdf-failed` | The PDF engine could not be reached or answered with an error |
-| `slides-failed` | `pdfSlides` could not turn a PDF into slides |
+| `office-failed` | `officeEngine` could not convert the file, or answered with something else |

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 //#region src/errors.d.ts
-export type ConvertErrorCode = 'too-large' | 'unsupported' | 'empty' | 'pdf-failed' | 'slides-failed';
+export type ConvertErrorCode = 'too-large' | 'unsupported' | 'empty' | 'pdf-failed' | 'office-failed';
 export declare class ConvertError extends Error {
   readonly code: ConvertErrorCode;
   constructor(code: ConvertErrorCode, message: string, options?: ErrorOptions);

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

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

package/dist/import/deck-format.js

@@ -0,0 +1,12 @@
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+//#region src/import/deck-format.ts
+const FORMATS = Object.entries(DECK_SIZES).map(([format, size]) => ({
+	format,
+	ratio: size.width / size.height
+}));
+const formatFor = (width, height) => {
+	const ratio = width / Math.max(height, 1);
+	return FORMATS.reduce((best, candidate) => Math.abs(candidate.ratio - ratio) < Math.abs(best.ratio - ratio) ? candidate : best).format;
+};
+//#endregion
+export { formatFor };

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.d.ts

@@ -0,0 +1,7 @@
+import { SaveImage } from "./images.js";
+import { ImportedDeck } from "./pptx.js";
+//#region src/import/image.d.ts
+export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+export declare const imageTypeOf: (data: Buffer) => ImageType | null;
+export declare const importImage: (buffer: Buffer, filename: string, contentType: ImageType, saveImage: SaveImage) => Promise<ImportedDeck>;
+//#endregion

package/dist/import/image.js

@@ -0,0 +1,58 @@
+import { ConvertError } from "../errors.js";
+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";
+//#region src/import/image.ts
+const PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
+const JPEG_SIGNATURE = Buffer.from("ffd8ff", "hex");
+const imageTypeOf = (data) => {
+	if (data.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) return "image/png";
+	if (data.subarray(0, JPEG_SIGNATURE.length).equals(JPEG_SIGNATURE)) return "image/jpeg";
+	const head = data.toString("latin1", 0, 12);
+	if (head.startsWith("GIF87a") || head.startsWith("GIF89a")) return "image/gif";
+	return head.startsWith("RIFF") && head.slice(8) === "WEBP" ? "image/webp" : null;
+};
+const importImage = async (buffer, filename, contentType, saveImage) => {
+	const fileId = await imageSaver(saveImage, filename, 1)(buffer, contentType);
+	if (fileId === null) throw new ConvertError("empty", `${filename} was not stored, so there is nothing to show`);
+	const size = imageSize(buffer, contentType);
+	const format = formatFor(size.width, size.height);
+	const slide = DECK_SIZES[format];
+	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);
+	return {
+		title: titleOf("", filename),
+		content: {
+			kind: "deck",
+			format,
+			theme: PLAIN_THEME,
+			slides: [{
+				id: newId(),
+				background: null,
+				elements: [{
+					id: newId(),
+					type: "image",
+					x: Math.round((slide.width - w) / 2),
+					y: Math.round((slide.height - h) / 2),
+					w,
+					h,
+					rotation: 0,
+					opacity: 1,
+					isLocked: false,
+					fileId,
+					fit: "contain",
+					radius: 0,
+					alt: "",
+					credit: null
+				}]
+			}]
+		}
+	};
+};
+//#endregion
+export { imageTypeOf, importImage };

package/dist/import/office.d.ts

@@ -0,0 +1,10 @@
+//#region src/import/office.d.ts
+export type LegacyOffice = 'doc' | 'ppt' | 'odt' | 'odp' | 'rtf';
+export interface OfficeJob {
+  file: Uint8Array;
+  from: LegacyOffice;
+  to: 'docx' | 'pptx';
+}
+export type OfficeEngine = (job: OfficeJob) => Promise<Uint8Array>;
+export declare const runOffice: (engine: OfficeEngine, job: OfficeJob, filename: string) => Promise<Buffer>;
+//#endregion

package/dist/import/office.js

@@ -0,0 +1,10 @@
+import { ConvertError } from "../errors.js";
+//#region src/import/office.ts
+const runOffice = async (engine, job, filename) => {
+	const converted = await engine(job).catch((error) => {
+		throw error instanceof ConvertError ? error : new ConvertError("office-failed", `${filename} could not be turned into ${job.to}`, { cause: error });
+	});
+	return Buffer.from(converted);
+};
+//#endregion
+export { runOffice };

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.js

@@ -1,11 +1,12 @@
 import { ConvertError } from "../errors.js";
 import { titleOf } from "./titles.js";
 import { imageSaver } from "./images.js";
+import { formatFor } from "./deck-format.js";
 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
@@ -13,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 = {
@@ -23,32 +23,6 @@ const IMAGE_TYPES = {
 	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];

package/dist/import.d.ts

@@ -1,12 +1,12 @@
 import { SaveImage } from "./import/images.js";
-import { PdfSlides } from "./import/pdf-slides.js";
+import { OfficeEngine } from "./import/office.js";
 import { Content } from "@pollium/vyva-core/content";
 //#region src/import.d.ts
 export declare const MAX_IMPORT_BYTES: number;
 export interface ImportOptions {
   saveImage: SaveImage;
   maxBytes?: number;
-  pdfSlides?: PdfSlides;
+  officeEngine?: OfficeEngine;
 }
 export interface ImportedContent {
   title: string;

package/dist/import.js

@@ -1,23 +1,44 @@
 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, isLandscapePdf } from "./import/pdf-slides.js";
-import { unzipSync } from "fflate";
+import { strFromU8, unzipSync } from "fflate";
 //#region src/import.ts
 const MAX_IMPORT_BYTES = 26214400;
 const ZIP_SIGNATURE = 67324752;
 const PDF_SIGNATURE = "%PDF-";
+const RTF_SIGNATURE = "{\\rtf";
+const OLE_SIGNATURE = Buffer.from("d0cf11e0a1b11ae1", "hex");
 const TEXT_SAMPLE_BYTES = 65536;
+const MAX_MIMETYPE_BYTES = 128;
 const BOM = /^/;
+const OPEN_DOCUMENTS = {
+	"application/vnd.oasis.opendocument.text": "odt",
+	"application/vnd.oasis.opendocument.text-template": "odt",
+	"application/vnd.oasis.opendocument.presentation": "odp",
+	"application/vnd.oasis.opendocument.presentation-template": "odp"
+};
+const OLE_STREAMS = [{
+	stream: Buffer.from("WordDocument", "utf16le"),
+	format: "doc"
+}, {
+	stream: Buffer.from("PowerPoint Document", "utf16le"),
+	format: "ppt"
+}];
 const zipParts = (buffer) => {
 	if (buffer.length < 4 || buffer.readUInt32LE(0) !== ZIP_SIGNATURE) return null;
 	try {
 		const names = /* @__PURE__ */ new Set();
-		unzipSync(buffer, { filter: (file) => {
+		const read = unzipSync(buffer, { filter: (file) => {
 			names.add(file.name);
-			return false;
+			return file.name === "mimetype" && file.originalSize <= MAX_MIMETYPE_BYTES;
 		} });
-		return names;
+		return {
+			names,
+			mimetype: read.mimetype === void 0 ? "" : strFromU8(read.mimetype)
+		};
 	} catch {
 		return null;
 	}
@@ -33,24 +54,52 @@ const isUtf8Text = (buffer) => {
 	}
 };
 const detect = (buffer, filename) => {
-	const parts = zipParts(buffer);
-	if (parts !== null) {
-		if (parts.has("word/document.xml")) return "docx";
-		return parts.has("ppt/presentation.xml") ? "pptx" : null;
+	const zip = zipParts(buffer);
+	if (zip !== null) {
+		if (zip.names.has("word/document.xml")) return "docx";
+		if (zip.names.has("ppt/presentation.xml")) return "pptx";
+		return OPEN_DOCUMENTS[zip.mimetype] ?? null;
 	}
 	if (buffer.subarray(0, 5).toString("latin1") === PDF_SIGNATURE) return "pdf";
+	if (buffer.subarray(0, OLE_SIGNATURE.length).equals(OLE_SIGNATURE)) return OLE_STREAMS.find(({ stream }) => buffer.includes(stream))?.format ?? null;
+	if (buffer.subarray(0, 5).toString("latin1") === RTF_SIGNATURE) return "rtf";
+	const image = imageTypeOf(buffer);
+	if (image !== null) return image;
 	if (!isUtf8Text(buffer)) return null;
 	const extension = filename.toLowerCase().split(".").at(-1) ?? "";
 	if (extension === "md" || extension === "markdown") return "markdown";
 	if (extension === "txt") return "text";
 	return null;
 };
-const convert = async (detected, buffer, filename, { saveImage, pdfSlides }) => {
-	if (detected === "docx") return importDocx(buffer, filename, saveImage);
-	if (detected === "pptx") return importPptx(buffer, filename, saveImage);
-	if (detected === "pdf") return pdfSlides !== void 0 && await isLandscapePdf(buffer) ? importPdfSlides(buffer, filename, saveImage, pdfSlides) : importPdf(buffer, filename);
-	const text = buffer.toString("utf8").replace(BOM, "");
-	return detected === "markdown" ? importMarkdown(text, filename) : importPlainText(text, filename);
+const textOf = (buffer) => buffer.toString("utf8").replace(BOM, "");
+const upgraded = async (from, to, buffer, filename, officeEngine) => {
+	if (officeEngine === void 0) throw new ConvertError("unsupported", `${filename} is a ${from} file, which Vyva imports only through an office engine`);
+	const converted = await runOffice(officeEngine, {
+		file: buffer,
+		from,
+		to
+	}, filename);
+	if (detect(converted, filename) !== to) throw new ConvertError("office-failed", `The office engine did not turn ${filename} into ${to}`);
+	return converted;
+};
+const convert = async (detected, buffer, filename, options) => {
+	const { saveImage, officeEngine } = options;
+	switch (detected) {
+		case "docx": return importDocx(buffer, filename, saveImage);
+		case "pptx": return importPptx(buffer, filename, saveImage);
+		case "pdf": return importPdf(buffer, filename, saveImage);
+		case "markdown": return importMarkdown(textOf(buffer), filename);
+		case "text": return importPlainText(textOf(buffer), filename);
+		case "image/png":
+		case "image/jpeg":
+		case "image/gif":
+		case "image/webp": return importImage(buffer, filename, detected, saveImage);
+		case "doc":
+		case "odt":
+		case "rtf": return convert("docx", await upgraded(detected, "docx", buffer, filename, officeEngine), filename, options);
+		case "ppt":
+		case "odp": return convert("pptx", await upgraded(detected, "pptx", buffer, filename, officeEngine), filename, options);
+	}
 };
 const isEmpty = (content) => content.kind === "document" ? content.blocks.length === 0 : content.slides.length === 0;
 const importFile = async (data, filename, options) => {

package/dist/libreoffice.d.ts

@@ -1,8 +1,8 @@
-import { PdfSlides } from "./import/pdf-slides.js";
+import { OfficeEngine } from "./import/office.js";
 //#region src/libreoffice.d.ts
 export interface LibreOfficeOptions {
   command?: string;
   timeoutMs?: number;
 }
-export declare const libreOffice: ({ command, timeoutMs }?: LibreOfficeOptions) => PdfSlides;
+export declare const libreOffice: ({ command, timeoutMs }?: LibreOfficeOptions) => OfficeEngine;
 //#endregion

package/dist/libreoffice.js

@@ -8,25 +8,24 @@ import { promisify } from "node:util";
 //#region src/libreoffice.ts
 const DEFAULT_TIMEOUT_MS = 12e4;
 const run = promisify(execFile);
-const libreOffice = ({ command = "soffice", timeoutMs = DEFAULT_TIMEOUT_MS } = {}) => async (pdf) => {
-	const folder = await mkdtemp(join(tmpdir(), "vyva-slides-"));
-	const source = join(folder, "source.pdf");
+const libreOffice = ({ command = "soffice", timeoutMs = DEFAULT_TIMEOUT_MS } = {}) => async ({ file, from, to }) => {
+	const folder = await mkdtemp(join(tmpdir(), "vyva-office-"));
+	const source = join(folder, `source.${from}`);
 	try {
-		await writeFile(source, pdf);
+		await writeFile(source, file);
 		await run(command, [
 			`-env:UserInstallation=${pathToFileURL(join(folder, "profile")).href}`,
 			"--headless",
-			"--infilter=impress_pdf_import",
 			"--convert-to",
-			"pptx",
+			to,
 			"--outdir",
 			folder,
 			source
 		], { timeout: timeoutMs }).catch((error) => {
-			throw new ConvertError("slides-failed", `LibreOffice at ${command} could not turn the PDF into slides`, { cause: error });
+			throw new ConvertError("office-failed", `LibreOffice at ${command} could not turn the ${from} file into ${to}`, { cause: error });
 		});
-		return new Uint8Array(await readFile(join(folder, "source.pptx")).catch((error) => {
-			throw new ConvertError("slides-failed", "LibreOffice finished without writing the slides", { cause: error });
+		return new Uint8Array(await readFile(join(folder, `source.${to}`)).catch((error) => {
+			throw new ConvertError("office-failed", `LibreOffice finished without writing the ${to} file`, { cause: error });
 		}));
 	} finally {
 		await rm(folder, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pollium/vyva-convert",
-  "version": "0.2.0",
-  "description": "Server-side tools for Vyva content: clean what clients send, import Word, PowerPoint, PDF and Markdown files, and export to PDF, Word, PowerPoint and HTML.",
+  "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,
   "repository": {
@@ -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) 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,7 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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 };