@pollium/vyva-convert 0.2.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,22 +67,32 @@ 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 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 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, 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 +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 |
-| `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/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.js

@@ -179,7 +179,7 @@ const joinSlide = (slide, font, slideWidth, slideHeight) => {
 	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;
+		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));

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

@@ -1,7 +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 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>;
+export declare const importPdfSlides: (buffer: Buffer, filename: string, saveImage: SaveImage, officeEngine: OfficeEngine) => Promise<ImportedDeck>;
 //#endregion

package/dist/import/pdf-slides.js

@@ -1,21 +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 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);
+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, isLandscapePdf };
+export { importPdfSlides };

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,6 +1,7 @@
 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";
@@ -23,32 +24,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];
@@ -82,7 +57,7 @@ const importPptx = async (buffer, filename, saveImage) => {
 	const cy = num(attr(size, "cy"), DEFAULT_HEIGHT);
 	const format = formatFor(cx, cy);
 	const relations = pptx.relationsOf("ppt/presentation.xml");
-	const allParts = all(presentation, "p:sldId").map((slide) => relations[attr(slide, "r:id") ?? ""]?.target).filter((path) => path !== void 0).slice(0, MAX_SLIDES).map((path) => pptx.parts(path)).filter((parts) => parts !== null);
+	const allParts = all(presentation, "p:sldId").map((slide) => relations[attr(slide, "r:id") ?? ""]?.target).filter((path) => path !== void 0).slice(0, 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 = {
@@ -123,4 +98,4 @@ const importPptx = async (buffer, filename, saveImage) => {
 	};
 };
 //#endregion
-export { importPptx };
+export { MAX_SLIDES, importPptx };

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 { imageTypeOf, importImage } from "./import/image.js";
+import { runOffice } from "./import/office.js";
 import { importPptx } from "./import/pptx.js";
-import { importPdfSlides, isLandscapePdf } from "./import/pdf-slides.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;
 	}
@@ -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 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, 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,25 @@ 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",
+			...from === "pdf" ? ["--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.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": {