@pollium/vyva-convert 0.1.0 → 0.3.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
@@ -66,12 +67,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.
+- 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, PDF, Markdown and text files become documents, and PowerPoint files become decks. A deck
-  keeps its theme colors and font. What its slide master draws comes in locked, behind the slide's
-  own elements.
+  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 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`.
+
+  `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, 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.
 - Files over 25 MB (`maxBytes` changes the limit) and files it cannot read are refused.
@@ -87,3 +109,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 |
+| `office-failed` | `officeEngine` could not convert the file, or answered with something else |

package/dist/clean-content.js

@@ -28,7 +28,12 @@ const cleanElement = (element, font) => {
 			html
 		};
 	}
-	if (element.type !== "shape" || element.text === void 0) return element;
+	if (element.type !== "shape") return element;
+	if (element.points !== void 0 && element.shape !== "polygon") {
+		const { points: _points, ...plain } = element;
+		return cleanElement(plain, font);
+	}
+	if (element.text === void 0) return element;
 	const { text, ...bare } = element;
 	const html = TEXT_SHAPES.includes(element.shape) ? cleanHtml(text.html) : "";
 	return html === "" ? bare : {

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 //#region src/errors.d.ts
-export type ConvertErrorCode = 'too-large' | 'unsupported' | 'empty' | 'pdf-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/pptx.js

@@ -110,8 +110,31 @@ const SHAPES = {
 	ellipse: "ellipse",
 	triangle: "triangle",
 	line: "line",
-	arrow: "line"
+	arrow: "line",
+	polygon: "custGeom"
 };
+const BOX_CORNERS = [
+	{
+		x: 0,
+		y: 0
+	},
+	{
+		x: 1,
+		y: 0
+	},
+	{
+		x: 1,
+		y: 1
+	},
+	{
+		x: 0,
+		y: 1
+	}
+];
+const outline = (element) => [...(element.points ?? BOX_CORNERS).map((point) => ({
+	x: inch(point.x * element.w),
+	y: inch(point.y * element.h)
+})), { close: true }];
 const addShape = (slide, element, deck) => {
 	const isLine = element.shape === "line" || element.shape === "arrow";
 	const lineColor = element.stroke ?? element.fill;
@@ -132,7 +155,8 @@ const addShape = (slide, element, deck) => {
 			width: Math.max(.5, element.strokeWidth * PT_PER_PX),
 			...element.shape === "arrow" ? { endArrowType: "triangle" } : {}
 		} },
-		...element.shape === "rounded" ? { rectRadius: .18 } : {}
+		...element.shape === "rounded" ? { rectRadius: .18 } : {},
+		...element.shape === "polygon" ? { points: outline(element) } : {}
 	};
 	if (element.text !== void 0 && TEXT_SHAPES.includes(element.shape) && element.text.html.trim() !== "") {
 		slide.addText(textRuns(element.text.html, element.text.style), {

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

@@ -0,0 +1,4 @@
+import { DeckFormat } from "@pollium/vyva-core/content";
+//#region src/import/deck-format.d.ts
+export declare const formatFor: (width: number, height: number) => DeckFormat;
+//#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/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,59 @@
+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 { 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");
+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);
+	const { frame: _frame, ...theme } = DECK_THEME;
+	return {
+		title: titleOf("", filename),
+		content: {
+			kind: "deck",
+			format,
+			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: 'pdf' | 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-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 && 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

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

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

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

@@ -1,6 +1,8 @@
 import { cleanHtml } from "../clean-html.js";
+import { unwrappedWidth } from "../text-measure.js";
 import { all, attr, first, kid, kids, num, tags, textOf } from "./pptx-xml.js";
 import { TITLE_TYPES, bulletsByDefault, decorOf, isDefined, levelOf, masterLevel, placeholderChain } from "./pptx-placeholders.js";
+import { outlineOf } from "./pptx-geometry.js";
 import { MAX_CELL_TEXT, MAX_TABLE_COLUMNS, MAX_TABLE_ROWS } from "@pollium/vyva-core/content";
 import { newId } from "@pollium/vyva-core/ids";
 import { escapeHtml } from "@pollium/vyva-core/escape";
@@ -120,6 +122,21 @@ var SlideReader = class {
 			isLocked
 		};
 	}
+	#unwrapped(frame, html, style) {
+		const w = unwrappedWidth(html, style, this.#options.theme.font);
+		if (w <= frame.w) return frame;
+		const shift = {
+			left: 0,
+			justify: 0,
+			center: (w - frame.w) / 2,
+			right: w - frame.w
+		}[style.align];
+		return {
+			...frame,
+			x: Math.round(frame.x - shift),
+			w
+		};
+	}
 	#pixels(size) {
 		const hundredths = num(size);
 		return hundredths > 0 ? Math.round(hundredths / 100 * PX_PER_POINT * this.#options.fontScale) : null;
@@ -174,11 +191,7 @@ var SlideReader = class {
 		const palette = visit.part.palette;
 		const firstRun = all(body, "a:r").map((run) => kid(run, "a:rPr")).find(isDefined);
 		const firstAlign = ALIGNS[attr(kid(kids(body, "a:p")[0], "a:pPr"), "algn") ?? ""] ?? null;
-		const look = mergeLooks([
-			{
-				...this.#runLook(firstRun, palette),
-				align: firstAlign
-			},
+		const inherited = mergeLooks([
 			...chain.map((shape) => this.#levelLook(levelOf(shape), palette)),
 			this.#levelLook(masterLevel(visit.parts, type), palette),
 			{
@@ -186,6 +199,14 @@ var SlideReader = class {
 				color: styleColor(chain[0], "a:fontRef", palette)
 			}
 		]);
+		const look = mergeLooks([{
+			...this.#runLook(firstRun, palette),
+			align: firstAlign
+		}, inherited]);
+		const isBold = all(body, "a:r").every((run) => {
+			const bold = attr(kid(run, "a:rPr"), "b");
+			return bold === void 0 ? inherited.isBold === true : bold === "1";
+		});
 		const isTitle = TITLE_TYPES.includes(type ?? "");
 		const anchor = chain.map((shape) => attr(kid(kid(shape, "p:txBody"), "a:bodyPr"), "anchor")).find(isDefined);
 		const { theme } = this.#options;
@@ -195,7 +216,7 @@ var SlideReader = class {
 			align: look.align ?? "left",
 			verticalAlign: anchor === "ctr" ? "middle" : anchor === "b" ? "bottom" : "top",
 			lineHeight: 1.2,
-			isBold: look.isBold ?? false
+			isBold
 		};
 	}
 	#shapeInto(visit, shape, group) {
@@ -238,7 +259,7 @@ var SlideReader = class {
 				}
 			};
 			return {
-				...frame,
+				...chain.map((link) => attr(kid(kid(link, "p:txBody"), "a:bodyPr"), "wrap")).find(isDefined) === "none" ? this.#unwrapped(frame, html, style) : frame,
 				type: "text",
 				html,
 				fill,
@@ -246,13 +267,16 @@ var SlideReader = class {
 			};
 		}
 		if (fill === null && stroke === null) return null;
+		const geometry = chain.map((link) => first(link, "a:custGeom")).find(isDefined);
+		const outline = geometry === void 0 ? null : outlineOf(geometry, kid(props[0], "a:xfrm"));
 		return {
 			...frame,
 			type: "shape",
-			shape: line !== void 0 && first(line, "a:tailEnd") !== void 0 && kind === "line" ? "arrow" : kind,
+			shape: line !== void 0 && first(line, "a:tailEnd") !== void 0 && kind === "line" ? "arrow" : outline?.kind ?? kind,
 			fill: kind === "line" ? null : fill,
 			stroke,
-			strokeWidth
+			strokeWidth,
+			...outline?.kind === "polygon" ? { points: outline.points } : {}
 		};
 	}
 	async #pictureInto(visit, node, group) {

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

@@ -1,6 +1,7 @@
 import { XmlDocument, XmlElement } from "./pptx-xml.js";
-import { DeckTheme } from "@pollium/vyva-core/content";
+import { DeckTheme, FontFamily } from "@pollium/vyva-core/content";
 //#region src/import/pptx-theme.d.ts
+export declare const familyOf: (name: string | null) => FontFamily | null;
 export interface PptxTheme {
   colors: Record<string, string>;
   bodyFont: string | null;

package/dist/import/pptx-theme.js

@@ -42,6 +42,10 @@ const FONT_SUBSTITUTES = {
 	"courier new": "JetBrains Mono",
 	consolas: "JetBrains Mono"
 };
+const familyOf = (name) => {
+	if (name === null) return null;
+	return FONT_FAMILIES.find((font) => font.toLowerCase() === name.toLowerCase()) ?? FONT_SUBSTITUTES[name.toLowerCase()] ?? null;
+};
 const rgbOf = (hex) => {
 	const channel = (at) => Number.parseInt(hex.slice(at, at + 2), 16) / 255;
 	return [
@@ -133,11 +137,6 @@ var Palette = class {
 		const stop = gradient === void 0 ? void 0 : first(gradient, "a:gs");
 		return stop === void 0 ? null : this.color(stop);
 	}
-	#font() {
-		const name = this.#theme.bodyFont;
-		if (name === null) return null;
-		return FONT_FAMILIES.find((font) => font.toLowerCase() === name.toLowerCase()) ?? FONT_SUBSTITUTES[name.toLowerCase()] ?? null;
-	}
 	deckTheme() {
 		const fallback = DECK_THEME;
 		const slot = (name) => {
@@ -145,7 +144,7 @@ var Palette = class {
 			return value === null ? null : `#${value}`;
 		};
 		return {
-			font: this.#font() ?? fallback.font,
+			font: familyOf(this.#theme.bodyFont) ?? fallback.font,
 			background: slot("bg1") ?? fallback.background,
 			text: slot("tx1") ?? fallback.text,
 			accent: slot("accent1") ?? fallback.accent,
@@ -158,4 +157,4 @@ var Palette = class {
 };
 const colorMapOf = (master) => master === void 0 ? void 0 : kids(master, "p:clrMap")[0];
 //#endregion
-export { colorMapOf, Palette as default, themeOf };
+export { colorMapOf, Palette as default, familyOf, themeOf };

package/dist/import/pptx.d.ts

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

@@ -1,7 +1,9 @@
 import { ConvertError } from "../errors.js";
 import { titleOf } from "./titles.js";
 import { imageSaver } from "./images.js";
-import { all, attr, first, num } from "./pptx-xml.js";
+import { 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";
@@ -22,38 +24,21 @@ 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];
 	const title = titles.find((candidate) => candidate !== "") ?? (biggest === void 0 ? "" : plainText(biggest.html));
 	return titleOf(title, filename);
 };
+const dominantFont = (parts, themeFont) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { slide } of parts) for (const run of all(slide.root, "a:r")) {
+		const typeface = attr(first(run, "a:latin"), "typeface");
+		const family = typeface === void 0 || typeface.startsWith("+") ? themeFont : familyOf(typeface);
+		if (family !== null) counts.set(family, (counts.get(family) ?? 0) + all(run, "a:t").map(textOf).join("").length);
+	}
+	return [...counts].sort((a, b) => b[1] - a[1])[0]?.[0] ?? themeFont;
+};
 const unzipped = (buffer) => {
 	let total = 0;
 	return unzipSync(buffer, { filter: (file) => {
@@ -72,9 +57,13 @@ 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, MAX_SLIDES).map((path) => pptx.parts(path)).filter((parts) => parts !== null);
-	const theme = allParts[0]?.slide.palette.deckTheme();
-	if (theme === void 0) throw new ConvertError("empty", `${filename} has no slides`);
+	const 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 themed = allParts[0]?.slide.palette.deckTheme();
+	if (themed === void 0) throw new ConvertError("empty", `${filename} has no slides`);
+	const theme = {
+		...themed,
+		font: dominantFont(allParts, themed.font)
+	};
 	const save = imageSaver(saveImage, filename, MAX_IMAGES);
 	const saved = /* @__PURE__ */ new Map();
 	const reader = new SlideReader({
@@ -109,4 +98,4 @@ const importPptx = async (buffer, filename, saveImage) => {
 	};
 };
 //#endregion
-export { importPptx };
+export { MAX_SLIDES, importPptx };

package/dist/import.d.ts

@@ -1,14 +1,16 @@
 import { SaveImage } from "./import/images.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;
+  officeEngine?: OfficeEngine;
 }
 export interface ImportedContent {
   title: string;
   content: Content;
 }
-export declare const importFile: (data: Uint8Array, filename: string, { saveImage, maxBytes }: ImportOptions) => Promise<ImportedContent>;
+export declare const importFile: (data: Uint8Array, filename: string, options: ImportOptions) => Promise<ImportedContent>;
 //#endregion

package/dist/import.js

@@ -1,22 +1,44 @@
 import { ConvertError } from "./errors.js";
 import { importDocx, importMarkdown, importPdf, importPlainText } from "./import/documents.js";
+import { imageTypeOf, importImage } from "./import/image.js";
+import { runOffice } from "./import/office.js";
 import { importPptx } from "./import/pptx.js";
-import { unzipSync } from "fflate";
+import { importPdfSlides } from "./import/pdf-slides.js";
+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;
 	}
@@ -32,33 +54,62 @@ 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) => {
-	if (detected === "docx") return importDocx(buffer, filename, saveImage);
-	if (detected === "pptx") return importPptx(buffer, filename, saveImage);
-	if (detected === "pdf") return 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 officeEngine === void 0 ? importPdf(buffer, filename) : importPdfSlides(buffer, filename, saveImage, officeEngine);
+		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, { saveImage, maxBytes = MAX_IMPORT_BYTES }) => {
+const importFile = async (data, filename, options) => {
+	const { maxBytes = MAX_IMPORT_BYTES } = options;
 	if (data.length > maxBytes) throw new ConvertError("too-large", `The file is larger than ${maxBytes} bytes`);
 	const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 	const name = filename.replace(/[\\/]/g, "_").slice(-200);
 	const detected = detect(buffer, name);
 	if (detected === null) throw new ConvertError("unsupported", `${name} is not a file Vyva can import`);
-	const imported = await convert(detected, buffer, name, saveImage);
+	const imported = await convert(detected, buffer, name, options);
 	if (isEmpty(imported.content)) throw new ConvertError("empty", `${name} has nothing to import`);
 	return imported;
 };

package/dist/libreoffice.d.ts

@@ -0,0 +1,8 @@
+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) => OfficeEngine;
+//#endregion

package/dist/libreoffice.js

@@ -0,0 +1,39 @@
+import { ConvertError } from "./errors.js";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+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 ({ file, from, to }) => {
+	const folder = await mkdtemp(join(tmpdir(), "vyva-office-"));
+	const source = join(folder, `source.${from}`);
+	try {
+		await writeFile(source, file);
+		await run(command, [
+			`-env:UserInstallation=${pathToFileURL(join(folder, "profile")).href}`,
+			"--headless",
+			...from === "pdf" ? ["--infilter=impress_pdf_import"] : [],
+			"--convert-to",
+			to,
+			"--outdir",
+			folder,
+			source
+		], { timeout: timeoutMs }).catch((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.${to}`)).catch((error) => {
+			throw new ConvertError("office-failed", `LibreOffice finished without writing the ${to} file`, { cause: error });
+		}));
+	} finally {
+		await rm(folder, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+//#endregion
+export { libreOffice };

package/dist/text-measure.d.ts

@@ -1,4 +1,5 @@
 import { FontFamily, TextStyle } from "@pollium/vyva-core/content";
 //#region src/text-measure.d.ts
 export declare const textHeight: (html: string, style: TextStyle, font: FontFamily, width: number) => number;
+export declare const unwrappedWidth: (html: string, style: TextStyle, font: FontFamily) => number;
 //#endregion

package/dist/text-measure.js

@@ -94,5 +94,9 @@ const textHeight = (html, style, font, width) => {
 		return height + linesOf(block.glyphs, style.fontSize, (width - indent) * WIDTH_SAFETY) * style.fontSize * style.lineHeight + gap;
 	}, 0);
 };
+const unwrappedWidth = (html, style, font) => {
+	const widths = blocksOf(html, font, style.isBold).map((block) => block.glyphs.reduce((width, glyph) => width + widthOf(glyph, style.fontSize), block.isItem ? LIST_INDENT_EMS * style.fontSize : 0));
+	return Math.ceil(Math.max(0, ...widths) / WIDTH_SAFETY) + 1;
+};
 //#endregion
-export { textHeight };
+export { textHeight, unwrappedWidth };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pollium/vyva-convert",
-  "version": "0.1.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.3.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": {
@@ -37,7 +37,7 @@
     "pptxgenjs": "^4.0.1",
     "sanitize-html": "^2.18.0",
     "unpdf": "^1.8.1",
-    "@pollium/vyva-core": "0.1.0"
+    "@pollium/vyva-core": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.6.4",
@@ -47,6 +47,7 @@
     "build": "tsdown",
     "typecheck": "tsc -p tsconfig.json",
     "lint": "oxlint --deny-warnings",
-    "test": "vitest run"
+    "test": "vitest run",
+    "font-widths": "node scripts/font-widths.ts"
   }
 }