js.documents 4.0.19 → 4.4.5

package/dist/codecs/registry.d.ts

@@ -1,14 +1,8 @@
 import { DocumentFormat } from "../convert/port.js";
+import { DocumentCodecOptions } from "./read.js";
 import { ContentCodec } from "document-schema.js";
 import { LayoutDocument } from "pdf-codec";
-import { MarkdownImageResolver } from "markdown-codec";
 //#region src/codecs/registry.d.ts
-declare function isArrayBufferBacked(bytes: Uint8Array): bytes is Uint8Array<ArrayBuffer>;
-declare function requireArrayBufferBytes(bytes: Uint8Array): Uint8Array<ArrayBuffer>;
-interface DocumentCodecOptions {
-  readonly signal?: AbortSignal;
-  readonly images?: MarkdownImageResolver;
-}
 interface LayoutEntryCodec {
   read(bytes: Uint8Array, options?: DocumentCodecOptions): LayoutDocument;
   write(layout: LayoutDocument, options?: DocumentCodecOptions): Uint8Array;
@@ -19,4 +13,4 @@ interface DocumentFormatCodecs {
 }
 declare const DOCUMENT_FORMAT_CODECS: Readonly<Record<DocumentFormat, DocumentFormatCodecs>>;
 //#endregion
-export { DOCUMENT_FORMAT_CODECS, DocumentCodecOptions, DocumentFormatCodecs, LayoutEntryCodec, isArrayBufferBacked, requireArrayBufferBytes };
+export { DOCUMENT_FORMAT_CODECS, DocumentFormatCodecs, LayoutEntryCodec };

package/dist/codecs/registry.js

@@ -4,107 +4,63 @@ import { buildOdtPackage } from "../edit/odt/content.js";
 import { buildOdpPackage } from "../edit/odp/content.js";
 import { buildOdsPackage } from "../edit/ods/content.js";
 import { buildOdgPackage } from "../edit/odg/content.js";
-import { readMarkdownContent } from "../markdown/read.js";
 import { buildMarkdownText } from "../markdown/write.js";
-import { readDocxContent as readDocxContent$1 } from "../ooxml/docx/read.js";
-import { readPptxContent as readPptxContent$1 } from "../ooxml/pptx/read.js";
-import { readOdfFormulaContent } from "../odf/formula/read.js";
-import { readOdtContent } from "../odf/odt/read.js";
-import { readOdpContent } from "../odf/odp/read.js";
-import { readOdsContent } from "../odf/ods/read.js";
-import { readOdgContent } from "../odf/odg/read.js";
-import { decodeMarkdownText, encodeMarkdownText } from "../markdown/text.js";
-import { decodeCsvText, encodeCsvText } from "../csv/text.js";
-import { readCsvContent } from "../csv/read.js";
+import { encodeMarkdownText } from "../markdown/text.js";
+import { encodeCsvText } from "../csv/text.js";
 import { buildCsvText } from "../csv/write.js";
-import { decodeSvgText, encodeSvgText } from "../svg/text.js";
-import { readSvgContent } from "../svg/read.js";
+import { encodeSvgText } from "../svg/text.js";
 import { buildSvgText } from "../svg/write.js";
-import { throwIfAborted } from "../ports/abort.js";
-import { decodeDocumentPackage, encodeDocumentPackage } from "../package-codec.js";
-import { buildXlsxPackageFromContent, readXlsxContent } from "ooxml.js";
-import { readPdf, writePdf } from "pdf-codec";
+import { encodeDocumentPackage } from "../package-codec.js";
+import { CONTENT_READERS, readDocumentLayout } from "./read.js";
+import { buildXlsxPackageFromContent } from "ooxml.js";
+import { writePdf } from "pdf-codec";
 //#region src/codecs/registry.ts
-function isArrayBufferBacked(bytes) {
-	return bytes.buffer instanceof ArrayBuffer;
-}
-function requireArrayBufferBytes(bytes) {
-	if (!isArrayBufferBacked(bytes)) throw new TypeError("expected an ArrayBuffer-backed Uint8Array, received one backed by a SharedArrayBuffer");
-	return bytes;
-}
 const DOCUMENT_FORMAT_CODECS = {
 	docx: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readDocxContent$1(decodeDocumentPackage("docx", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.docx,
 		write: (content) => encodeDocumentPackage("docx", buildDocxPackage(content))
 	} },
 	pptx: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readPptxContent$1(decodeDocumentPackage("pptx", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.pptx,
 		write: (content) => encodeDocumentPackage("pptx", buildPptxPackage(content))
 	} },
 	odt: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readOdtContent(decodeDocumentPackage("odt", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.odt,
 		write: (content) => encodeDocumentPackage("odt", buildOdtPackage(content))
 	} },
 	odp: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readOdpContent(decodeDocumentPackage("odp", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.odp,
 		write: (content) => encodeDocumentPackage("odp", buildOdpPackage(content))
 	} },
 	ods: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readOdsContent(decodeDocumentPackage("ods", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.ods,
 		write: (content) => encodeDocumentPackage("ods", buildOdsPackage(content))
 	} },
 	odg: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readOdgContent(decodeDocumentPackage("odg", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.odg,
 		write: (content) => encodeDocumentPackage("odg", buildOdgPackage(content))
 	} },
-	odf: { content: { read: (bytes, options) => {
-		throwIfAborted(options?.signal);
-		return readOdfFormulaContent(decodeDocumentPackage("odf", requireArrayBufferBytes(bytes)));
-	} } },
+	odf: { content: { read: CONTENT_READERS.odf } },
 	markdown: { content: {
-		read: (bytes, options) => readMarkdownContent(decodeMarkdownText(bytes), {
-			signal: options?.signal,
-			images: options?.images
-		}),
+		read: CONTENT_READERS.markdown,
 		write: (content) => encodeMarkdownText(buildMarkdownText(content))
 	} },
 	csv: { content: {
-		read: (bytes) => readCsvContent(decodeCsvText(bytes)),
+		read: CONTENT_READERS.csv,
 		write: (content) => encodeCsvText(buildCsvText(content))
 	} },
 	svg: { content: {
-		read: (bytes) => readSvgContent(decodeSvgText(bytes)),
+		read: CONTENT_READERS.svg,
 		write: (content) => encodeSvgText(buildSvgText(content))
 	} },
 	pdf: { layout: {
-		read: (bytes, options) => readPdf(requireArrayBufferBytes(bytes), { signal: options?.signal }),
+		read: readDocumentLayout,
 		write: (layout, options) => writePdf(layout, { signal: options?.signal })
 	} },
 	xlsx: { content: {
-		read: (bytes, options) => {
-			throwIfAborted(options?.signal);
-			return readXlsxContent(decodeDocumentPackage("xlsx", requireArrayBufferBytes(bytes)));
-		},
+		read: CONTENT_READERS.xlsx,
 		write: (content) => encodeDocumentPackage("xlsx", buildXlsxPackageFromContent(content))
 	} }
 };
 //#endregion
-export { DOCUMENT_FORMAT_CODECS, isArrayBufferBacked, requireArrayBufferBytes };
+export { DOCUMENT_FORMAT_CODECS };

package/dist/convert/codec.cjs

@@ -1,43 +1,44 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_bytes = require("../model/bytes.cjs");
 const require_convert_convert = require("./convert.cjs");
+const require_convert_from_pdf = require("./from-pdf.cjs");
 let zod = require("zod");
 //#region src/convert/codec.ts
 const docxPdfCodec = zod.z.codec(require_model_bytes.DocxBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (docxBytes) => require_convert_convert.docxToPdf(docxBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToDocx(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToDocx(pdfBytes)
 });
 const pptxPdfCodec = zod.z.codec(require_model_bytes.PptxBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (pptxBytes) => require_convert_convert.pptxToPdf(pptxBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToPptx(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToPptx(pdfBytes)
 });
 const odtPdfCodec = zod.z.codec(require_model_bytes.OdtBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (odtBytes) => require_convert_convert.odtToPdf(odtBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToOdt(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToOdt(pdfBytes)
 });
 const odpPdfCodec = zod.z.codec(require_model_bytes.OdpBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (odpBytes) => require_convert_convert.odpToPdf(odpBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToOdp(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToOdp(pdfBytes)
 });
 const odsPdfCodec = zod.z.codec(require_model_bytes.OdsBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (odsBytes) => require_convert_convert.odsToPdf(odsBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToOds(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToOds(pdfBytes)
 });
 const odgPdfCodec = zod.z.codec(require_model_bytes.OdgBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (odgBytes) => require_convert_convert.odgToPdf(odgBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToOdg(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToOdg(pdfBytes)
 });
 const xlsxPdfCodec = zod.z.codec(require_model_bytes.XlsxBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (xlsxBytes) => require_convert_convert.xlsxToPdf(xlsxBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToXlsx(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToXlsx(pdfBytes)
 });
 const markdownPdfCodec = zod.z.codec(require_model_bytes.MarkdownBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (markdownBytes) => require_convert_convert.markdownToPdf(markdownBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToMarkdown(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToMarkdown(pdfBytes)
 });
 const svgPdfCodec = zod.z.codec(require_model_bytes.SvgBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (svgBytes) => require_convert_convert.svgToPdf(svgBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToSvg(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToSvg(pdfBytes)
 });
 const odtDocxCodec = zod.z.codec(require_model_bytes.OdtBytesSchema, require_model_bytes.DocxBytesSchema, {
 	decode: (odtBytes) => require_convert_convert.odtToDocx(odtBytes),
@@ -65,7 +66,7 @@ const xlsxMarkdownCodec = zod.z.codec(require_model_bytes.XlsxBytesSchema, requi
 });
 const csvPdfCodec = zod.z.codec(require_model_bytes.CsvBytesSchema, require_model_bytes.PdfBytesSchema, {
 	decode: (csvBytes) => require_convert_convert.csvToPdf(csvBytes),
-	encode: (pdfBytes) => require_convert_convert.pdfToCsv(pdfBytes)
+	encode: (pdfBytes) => require_convert_from_pdf.pdfToCsv(pdfBytes)
 });
 const odsCsvCodec = zod.z.codec(require_model_bytes.OdsBytesSchema, require_model_bytes.CsvBytesSchema, {
 	decode: (odsBytes) => require_convert_convert.odsToCsv(odsBytes),

package/dist/convert/codec.js

@@ -1,5 +1,6 @@
 import { CsvBytesSchema, DocxBytesSchema, MarkdownBytesSchema, OdgBytesSchema, OdpBytesSchema, OdsBytesSchema, OdtBytesSchema, PdfBytesSchema, PptxBytesSchema, SvgBytesSchema, XlsxBytesSchema } from "../model/bytes.js";
-import { csvToMarkdown, csvToOds, csvToPdf, csvToXlsx, docxToMarkdown, docxToOdt, docxToPdf, markdownToCsv, markdownToDocx, markdownToOdt, markdownToPdf, markdownToXlsx, odgToPdf, odgToSvg, odpToPdf, odpToPptx, odsToCsv, odsToPdf, odsToXlsx, odtToDocx, odtToMarkdown, odtToPdf, pdfToCsv, pdfToDocx, pdfToMarkdown, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pdfToSvg, pdfToXlsx, pptxToOdp, pptxToPdf, svgToOdg, svgToPdf, xlsxToCsv, xlsxToMarkdown, xlsxToOds, xlsxToPdf } from "./convert.js";
+import { csvToMarkdown, csvToOds, csvToPdf, csvToXlsx, docxToMarkdown, docxToOdt, docxToPdf, markdownToCsv, markdownToDocx, markdownToOdt, markdownToPdf, markdownToXlsx, odgToPdf, odgToSvg, odpToPdf, odpToPptx, odsToCsv, odsToPdf, odsToXlsx, odtToDocx, odtToMarkdown, odtToPdf, pptxToOdp, pptxToPdf, svgToOdg, svgToPdf, xlsxToCsv, xlsxToMarkdown, xlsxToOds, xlsxToPdf } from "./convert.js";
+import { pdfToCsv, pdfToDocx, pdfToMarkdown, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pdfToSvg, pdfToXlsx } from "./from-pdf.js";
 import { z } from "zod";
 //#region src/convert/codec.ts
 const docxPdfCodec = z.codec(DocxBytesSchema, PdfBytesSchema, {

package/dist/convert/composition-to-pdf.cjs

@@ -0,0 +1,133 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_metadata = require("../model/metadata.cjs");
+const require_fonts_registry = require("../fonts/registry.cjs");
+const require_layout_engine = require("../layout/engine.cjs");
+const require_layout_slides = require("../layout/slides.cjs");
+const require_ports_abort = require("../ports/abort.cjs");
+const require_layout_sheets = require("../layout/sheets.cjs");
+const require_layout_drawing = require("../layout/drawing.cjs");
+const require_convert_capability = require("./capability.cjs");
+const require_convert_composition = require("./composition.cjs");
+let document_schema_js = require("document-schema.js");
+let pdf_codec = require("pdf-codec");
+//#region src/convert/composition-to-pdf.ts
+const mathMetricsAt = (sizePt) => (0, pdf_codec.loadMathFont)().metricsAt(sizePt);
+const LAYOUT_ENGINES = {
+	wordprocessing: require_layout_engine.convertWordprocessingToLayout,
+	presentation: require_layout_slides.convertPresentationToLayout,
+	spreadsheet: require_layout_sheets.convertSpreadsheetToLayout,
+	drawing: require_layout_drawing.convertDrawingToLayout
+};
+function executeToPdf(format, bytes, options) {
+	if (!require_convert_composition.LAYOUT_CAPABLE.has(format)) throw new Error(`executeToPdf: '${format}' has no layout engine of its own`);
+	const node = require_convert_composition.FORMAT_NODES[format];
+	let content;
+	let fonts;
+	if (require_convert_composition.isTextFormatNode(node)) {
+		require_ports_abort.throwIfAborted(options?.signal);
+		const text = node.decode(bytes);
+		const read = node.read(text, options);
+		content = {
+			...read,
+			metadata: require_model_metadata.resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		fonts = (0, pdf_codec.createFontRegistry)({
+			fonts: options?.fonts,
+			onSubstitution: options?.onFontSubstitution
+		});
+	} else {
+		const pkg = node.decode(bytes);
+		const read = node.read(pkg, options);
+		content = {
+			...read,
+			metadata: require_model_metadata.resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		const fontSource = node.family === "odf" ? {
+			kind: "odf",
+			package: pkg
+		} : format === "pptx" ? {
+			kind: "pptx",
+			package: pkg
+		} : {
+			kind: "docx",
+			package: pkg
+		};
+		fonts = require_fonts_registry.createDocumentFontRegistry(fontSource, {
+			fonts: options?.fonts,
+			onFontSubstitution: options?.onFontSubstitution
+		});
+	}
+	const measurer = (0, pdf_codec.createFontMeasurer)(fonts);
+	let layout;
+	let pages;
+	let formulas;
+	switch (content.kind) {
+		case "wordprocessing": {
+			const result = LAYOUT_ENGINES.wordprocessing(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "presentation": {
+			const result = LAYOUT_ENGINES.presentation(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "spreadsheet": {
+			const result = LAYOUT_ENGINES.spreadsheet(content, {
+				measurer,
+				mathMetricsAt,
+				signal: options?.signal
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "drawing": {
+			const result = LAYOUT_ENGINES.drawing(content, { measurer });
+			layout = result.document;
+			pages = result.pages;
+			break;
+		}
+		default: throw new Error(`executeToPdf: cannot lay out a '${content.kind}' document`);
+	}
+	if (formulas === void 0) {
+		const out = (0, pdf_codec.writePdf)(layout, {
+			signal: options?.signal,
+			onSubstitution: options?.onSubstitution,
+			fonts
+		});
+		options?.onDocument?.((0, document_schema_js.assemblePackage)(content, pages));
+		return out;
+	}
+	const out = (0, pdf_codec.writePdf)(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+	options?.onDocument?.((0, document_schema_js.assemblePackage)(content, pages));
+	return out;
+}
+function convertDocument(source, target, bytes, options) {
+	const plan = require_convert_composition.resolveCompositionPlan(source, target);
+	if (plan === void 0) throw new require_convert_capability.UnsupportedConversionError(source, target);
+	return require_convert_composition.runCompositionPlan(plan, bytes, options, {
+		bridge: require_convert_composition.executeBridge,
+		fromPdf: require_convert_composition.executeFromPdf,
+		toPdf: executeToPdf
+	});
+}
+//#endregion
+exports.convertDocument = convertDocument;
+exports.executeToPdf = executeToPdf;

package/dist/convert/composition-to-pdf.d.cts

@@ -0,0 +1,7 @@
+import { DocumentFormat } from "./port.cjs";
+import { ContentFormat, UnifiedConversionOptions } from "./composition.cjs";
+//#region src/convert/composition-to-pdf.d.ts
+declare function executeToPdf(format: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+declare function convertDocument(source: DocumentFormat, target: DocumentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { convertDocument, executeToPdf };

package/dist/convert/composition-to-pdf.d.ts

@@ -0,0 +1,7 @@
+import { DocumentFormat } from "./port.js";
+import { ContentFormat, UnifiedConversionOptions } from "./composition.js";
+//#region src/convert/composition-to-pdf.d.ts
+declare function executeToPdf(format: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+declare function convertDocument(source: DocumentFormat, target: DocumentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { convertDocument, executeToPdf };

package/dist/convert/composition-to-pdf.js

@@ -0,0 +1,131 @@
+import { resolveMetadataTimestamps } from "../model/metadata.js";
+import { createDocumentFontRegistry } from "../fonts/registry.js";
+import { convertWordprocessingToLayout } from "../layout/engine.js";
+import { convertPresentationToLayout } from "../layout/slides.js";
+import { throwIfAborted } from "../ports/abort.js";
+import { convertSpreadsheetToLayout } from "../layout/sheets.js";
+import { convertDrawingToLayout } from "../layout/drawing.js";
+import { UnsupportedConversionError } from "./capability.js";
+import { FORMAT_NODES, LAYOUT_CAPABLE, executeBridge, executeFromPdf, isTextFormatNode, resolveCompositionPlan, runCompositionPlan } from "./composition.js";
+import { assemblePackage } from "document-schema.js";
+import { createFontMeasurer, createFontRegistry, loadMathFont, writePdf } from "pdf-codec";
+//#region src/convert/composition-to-pdf.ts
+const mathMetricsAt = (sizePt) => loadMathFont().metricsAt(sizePt);
+const LAYOUT_ENGINES = {
+	wordprocessing: convertWordprocessingToLayout,
+	presentation: convertPresentationToLayout,
+	spreadsheet: convertSpreadsheetToLayout,
+	drawing: convertDrawingToLayout
+};
+function executeToPdf(format, bytes, options) {
+	if (!LAYOUT_CAPABLE.has(format)) throw new Error(`executeToPdf: '${format}' has no layout engine of its own`);
+	const node = FORMAT_NODES[format];
+	let content;
+	let fonts;
+	if (isTextFormatNode(node)) {
+		throwIfAborted(options?.signal);
+		const text = node.decode(bytes);
+		const read = node.read(text, options);
+		content = {
+			...read,
+			metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		fonts = createFontRegistry({
+			fonts: options?.fonts,
+			onSubstitution: options?.onFontSubstitution
+		});
+	} else {
+		const pkg = node.decode(bytes);
+		const read = node.read(pkg, options);
+		content = {
+			...read,
+			metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		const fontSource = node.family === "odf" ? {
+			kind: "odf",
+			package: pkg
+		} : format === "pptx" ? {
+			kind: "pptx",
+			package: pkg
+		} : {
+			kind: "docx",
+			package: pkg
+		};
+		fonts = createDocumentFontRegistry(fontSource, {
+			fonts: options?.fonts,
+			onFontSubstitution: options?.onFontSubstitution
+		});
+	}
+	const measurer = createFontMeasurer(fonts);
+	let layout;
+	let pages;
+	let formulas;
+	switch (content.kind) {
+		case "wordprocessing": {
+			const result = LAYOUT_ENGINES.wordprocessing(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "presentation": {
+			const result = LAYOUT_ENGINES.presentation(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "spreadsheet": {
+			const result = LAYOUT_ENGINES.spreadsheet(content, {
+				measurer,
+				mathMetricsAt,
+				signal: options?.signal
+			});
+			layout = result.document;
+			pages = result.pages;
+			formulas = result.formulas;
+			break;
+		}
+		case "drawing": {
+			const result = LAYOUT_ENGINES.drawing(content, { measurer });
+			layout = result.document;
+			pages = result.pages;
+			break;
+		}
+		default: throw new Error(`executeToPdf: cannot lay out a '${content.kind}' document`);
+	}
+	if (formulas === void 0) {
+		const out = writePdf(layout, {
+			signal: options?.signal,
+			onSubstitution: options?.onSubstitution,
+			fonts
+		});
+		options?.onDocument?.(assemblePackage(content, pages));
+		return out;
+	}
+	const out = writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+	options?.onDocument?.(assemblePackage(content, pages));
+	return out;
+}
+function convertDocument(source, target, bytes, options) {
+	const plan = resolveCompositionPlan(source, target);
+	if (plan === void 0) throw new UnsupportedConversionError(source, target);
+	return runCompositionPlan(plan, bytes, options, {
+		bridge: executeBridge,
+		fromPdf: executeFromPdf,
+		toPdf: executeToPdf
+	});
+}
+//#endregion
+export { convertDocument, executeToPdf };