documents.js 1.97.11 → 1.98.0

package/dist/convert-ULGgwmSb.js

@@ -1,975 +0,0 @@
-import { flipY } from "./model/geometry.js";
-import { resolveMetadataTimestamps } from "./model/metadata.js";
-import { buildDocxPackage } from "./edit/docx/content.js";
-import { buildPptxPackage } from "./edit/pptx/content.js";
-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 { createDocumentFontRegistry, extractSourceFonts } from "./fonts/registry.js";
-import { layoutFormula } from "./mathml/layout.js";
-import { readDocxContent } from "./ooxml/docx/read.js";
-import { readPptxContent } 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 { 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 { reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing } from "./layout/reconstruct.js";
-import { buildOdbTableCsv } from "./odb/csv.js";
-import { readOdbTables } from "./odb/read.js";
-import { odbTablesToSpreadsheetDocument } from "./odb/spreadsheet.js";
-import { presentationToWordprocessing, wordprocessingToPresentation } from "./convert/variant-bridges.js";
-import { buildXlsxPackage, decodePackage, encodePackage, readXlsxContent } from "ooxml.js";
-import { COLOR_BLACK, CONTENT_FORMAT_VERSION, DOCUMENT_PACKAGE_FORMAT_VERSION, LAYOUT_FORMAT_VERSION, PAGE_SIZE_A4 } from "document-schema.js";
-import { decodePackage as decodePackage$1, encodePackage as encodePackage$1, readOdfMetadata, readOdfParagraph, readOdfTable, readOdm } from "odf.js";
-import "markdown-codec";
-import { createFontMeasurer, createFontRegistry, loadMathFont, readPdf, writePdf } from "pdf-codec";
-//#region src/convert/capability.ts
-const FORMAT_CAPABILITIES = {
-	docx: {
-		format: "docx",
-		variant: "wordprocessing",
-		hasLayoutPath: true
-	},
-	odt: {
-		format: "odt",
-		variant: "wordprocessing",
-		hasLayoutPath: true
-	},
-	pptx: {
-		format: "pptx",
-		variant: "presentation",
-		hasLayoutPath: true
-	},
-	odp: {
-		format: "odp",
-		variant: "presentation",
-		hasLayoutPath: true
-	},
-	ods: {
-		format: "ods",
-		variant: "spreadsheet",
-		hasLayoutPath: true
-	},
-	xlsx: {
-		format: "xlsx",
-		variant: "spreadsheet",
-		hasLayoutPath: false
-	},
-	odg: {
-		format: "odg",
-		variant: "drawing",
-		hasLayoutPath: true
-	},
-	odf: {
-		format: "odf",
-		variant: "formula",
-		hasLayoutPath: false
-	},
-	markdown: {
-		format: "markdown",
-		variant: "wordprocessing",
-		hasLayoutPath: true
-	},
-	pdf: {
-		format: "pdf",
-		hasLayoutPath: false
-	}
-};
-const DIRECT_EDGES = [
-	{
-		kind: "toPdf",
-		source: "docx",
-		target: "pdf",
-		convert: docxToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "pptx",
-		target: "pdf",
-		convert: pptxToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "odt",
-		target: "pdf",
-		convert: odtToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "odp",
-		target: "pdf",
-		convert: odpToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "ods",
-		target: "pdf",
-		convert: odsToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "odg",
-		target: "pdf",
-		convert: odgToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "odf",
-		target: "pdf",
-		convert: odfToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "xlsx",
-		target: "pdf",
-		convert: xlsxToPdf
-	},
-	{
-		kind: "toPdf",
-		source: "markdown",
-		target: "pdf",
-		convert: markdownToPdf
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "docx",
-		convert: pdfToDocx
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "pptx",
-		convert: pdfToPptx
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "odt",
-		convert: pdfToOdt
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "odp",
-		convert: pdfToOdp
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "ods",
-		convert: pdfToOds
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "odg",
-		convert: pdfToOdg
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "xlsx",
-		convert: pdfToXlsx
-	},
-	{
-		kind: "fromPdf",
-		source: "pdf",
-		target: "markdown",
-		convert: pdfToMarkdown
-	},
-	{
-		kind: "bridge",
-		source: "odt",
-		target: "docx",
-		convert: odtToDocx
-	},
-	{
-		kind: "bridge",
-		source: "docx",
-		target: "odt",
-		convert: docxToOdt
-	},
-	{
-		kind: "bridge",
-		source: "odp",
-		target: "pptx",
-		convert: odpToPptx
-	},
-	{
-		kind: "bridge",
-		source: "pptx",
-		target: "odp",
-		convert: pptxToOdp
-	},
-	{
-		kind: "bridge",
-		source: "ods",
-		target: "xlsx",
-		convert: odsToXlsx
-	},
-	{
-		kind: "bridge",
-		source: "xlsx",
-		target: "ods",
-		convert: xlsxToOds
-	},
-	{
-		kind: "bridge",
-		source: "markdown",
-		target: "docx",
-		convert: markdownToDocx
-	},
-	{
-		kind: "bridge",
-		source: "docx",
-		target: "markdown",
-		convert: docxToMarkdown
-	},
-	{
-		kind: "bridge",
-		source: "markdown",
-		target: "odt",
-		convert: markdownToOdt
-	},
-	{
-		kind: "bridge",
-		source: "odt",
-		target: "markdown",
-		convert: odtToMarkdown
-	},
-	{
-		kind: "bridge",
-		source: "docx",
-		target: "pptx",
-		convert: docxToPptx
-	},
-	{
-		kind: "bridge",
-		source: "pptx",
-		target: "docx",
-		convert: pptxToDocx
-	},
-	{
-		kind: "bridge",
-		source: "odt",
-		target: "odp",
-		convert: odtToOdp
-	},
-	{
-		kind: "bridge",
-		source: "odp",
-		target: "odt",
-		convert: odpToOdt
-	},
-	{
-		kind: "bridge",
-		source: "xlsx",
-		target: "markdown",
-		convert: xlsxToMarkdown
-	},
-	{
-		kind: "bridge",
-		source: "markdown",
-		target: "xlsx",
-		convert: markdownToXlsx
-	}
-];
-var UnsupportedConversionError = class extends Error {
-	source;
-	target;
-	constructor(source, target) {
-		super(`unsupported conversion: ${source} -> ${target}`);
-		this.name = "UnsupportedConversionError";
-		this.source = source;
-		this.target = target;
-	}
-};
-function resolveConversionPath(source, target, edges = DIRECT_EDGES) {
-	if (source === target) return;
-	return edges.find((edge) => edge.source === source && edge.target === target);
-}
-//#endregion
-//#region src/convert/composition.ts
-const mathMetricsAt$1 = (sizePt) => loadMathFont().metricsAt(sizePt);
-const CONTENT_FORMATS = [
-	"docx",
-	"pptx",
-	"xlsx",
-	"odt",
-	"odp",
-	"ods",
-	"odg",
-	"markdown"
-];
-const FORMAT_NODES = {
-	docx: {
-		variant: "wordprocessing",
-		family: "ooxml",
-		decode: (bytes) => decodePackage(bytes),
-		read: (pkg, options) => readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
-		build: (content, options) => buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
-		encode: (pkg) => encodePackage(pkg),
-		hasSourcePackage: true
-	},
-	pptx: {
-		variant: "presentation",
-		family: "ooxml",
-		decode: (bytes) => decodePackage(bytes),
-		read: (pkg) => readPptxContent(pkg),
-		build: (content) => buildPptxPackage(content),
-		encode: (pkg) => encodePackage(pkg),
-		hasSourcePackage: true
-	},
-	xlsx: {
-		variant: "spreadsheet",
-		family: "ooxml",
-		decode: (bytes) => decodePackage(bytes),
-		read: (pkg) => readXlsxContent(pkg),
-		build: (content) => buildXlsxPackage(content),
-		encode: (pkg) => encodePackage(pkg),
-		hasSourcePackage: true
-	},
-	odt: {
-		variant: "wordprocessing",
-		family: "odf",
-		decode: (bytes) => decodePackage$1(bytes),
-		read: (pkg) => readOdtContent(pkg),
-		build: (content) => buildOdtPackage(content),
-		encode: (pkg) => encodePackage$1(pkg),
-		hasSourcePackage: true
-	},
-	odp: {
-		variant: "presentation",
-		family: "odf",
-		decode: (bytes) => decodePackage$1(bytes),
-		read: (pkg) => readOdpContent(pkg),
-		build: (content) => buildOdpPackage(content),
-		encode: (pkg) => encodePackage$1(pkg),
-		hasSourcePackage: true
-	},
-	ods: {
-		variant: "spreadsheet",
-		family: "odf",
-		decode: (bytes) => decodePackage$1(bytes),
-		read: (pkg) => readOdsContent(pkg),
-		build: (content) => buildOdsPackage(content),
-		encode: (pkg) => encodePackage$1(pkg),
-		hasSourcePackage: true
-	},
-	odg: {
-		variant: "drawing",
-		family: "odf",
-		decode: (bytes) => decodePackage$1(bytes),
-		read: (pkg) => readOdgContent(pkg),
-		build: (content) => buildOdgPackage(content),
-		encode: (pkg) => encodePackage$1(pkg),
-		hasSourcePackage: true
-	},
-	markdown: {
-		variant: "wordprocessing",
-		family: "markdown",
-		decode: (bytes) => decodeMarkdownText(bytes),
-		read: (text, options) => readMarkdownContent(text, {
-			signal: options?.signal,
-			images: options?.images
-		}),
-		build: (content) => buildMarkdownText(content),
-		encode: (text) => encodeMarkdownText(text),
-		hasSourcePackage: false
-	}
-};
-const LAYOUT_CAPABLE = /* @__PURE__ */ new Set([
-	"docx",
-	"pptx",
-	"odt",
-	"odp",
-	"ods",
-	"odg",
-	"markdown"
-]);
-const TRANSFORMS = {
-	"wordprocessing->presentation": (doc) => {
-		if (doc.kind !== "wordprocessing") throw new Error("wordprocessingToPresentation: expected a wordprocessing ContentDocument");
-		return wordprocessingToPresentation(doc);
-	},
-	"presentation->wordprocessing": (doc) => {
-		if (doc.kind !== "presentation") throw new Error("presentationToWordprocessing: expected a presentation ContentDocument");
-		return presentationToWordprocessing(doc);
-	}
-};
-const LAYOUT_ENGINES = {
-	wordprocessing: convertWordprocessingToLayout,
-	presentation: convertPresentationToLayout,
-	spreadsheet: convertSpreadsheetToLayout,
-	drawing: convertDrawingToLayout
-};
-const RECONSTRUCTORS = {
-	wordprocessing: reconstructWordprocessing,
-	presentation: reconstructPresentation,
-	drawing: reconstructDrawing,
-	spreadsheet: reconstructSpreadsheet
-};
-function executeBridge(source, target, bytes, options) {
-	throwIfAborted(options?.signal);
-	const sourceNode = FORMAT_NODES[source];
-	const targetNode = FORMAT_NODES[target];
-	let content;
-	if (sourceNode.family === "markdown") {
-		const text = sourceNode.decode(bytes);
-		content = sourceNode.read(text, options);
-	} else {
-		const pkg = sourceNode.decode(bytes);
-		content = sourceNode.read(pkg, options);
-	}
-	if (content.kind !== sourceNode.variant) throw new Error(`executeBridge: ${source} read returned a non-${sourceNode.variant} ContentDocument`);
-	let buildContent = content;
-	if (sourceNode.variant !== targetNode.variant) {
-		const key = `${sourceNode.variant}->${targetNode.variant}`;
-		const transform = TRANSFORMS[key];
-		if (transform === void 0) throw new Error(`executeBridge: no transform registered for ${key}`);
-		buildContent = transform(content);
-	}
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content: buildContent
-	});
-	if (targetNode.family === "markdown") {
-		const text = targetNode.build(buildContent);
-		return targetNode.encode(text);
-	}
-	const pkg = targetNode.build(buildContent, options);
-	return targetNode.encode(pkg);
-}
-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 (node.family === "markdown") {
-		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 formulas;
-	switch (content.kind) {
-		case "wordprocessing": {
-			const result = LAYOUT_ENGINES.wordprocessing(content, {
-				measurer,
-				mathMetricsAt: mathMetricsAt$1
-			});
-			layout = result.document;
-			formulas = result.formulas;
-			break;
-		}
-		case "presentation": {
-			const result = LAYOUT_ENGINES.presentation(content, {
-				measurer,
-				mathMetricsAt: mathMetricsAt$1
-			});
-			layout = result.document;
-			formulas = result.formulas;
-			break;
-		}
-		case "spreadsheet": {
-			const result = LAYOUT_ENGINES.spreadsheet(content, {
-				measurer,
-				mathMetricsAt: mathMetricsAt$1,
-				signal: options?.signal
-			});
-			layout = result.document;
-			formulas = result.formulas;
-			break;
-		}
-		case "drawing":
-			layout = LAYOUT_ENGINES.drawing(content, { measurer });
-			break;
-		default: throw new Error(`executeToPdf: cannot lay out a '${content.kind}' document`);
-	}
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	if (formulas === void 0) return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		fonts
-	});
-	return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		formulas,
-		fonts
-	});
-}
-function executeFromPdf(target, bytes, options) {
-	const node = FORMAT_NODES[target];
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = RECONSTRUCTORS[node.variant](layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	if (node.family === "markdown") {
-		const text = node.build(content);
-		return node.encode(text);
-	}
-	const pkg = node.build(content);
-	return node.encode(pkg);
-}
-function buildCompositionGraph() {
-	const adj = /* @__PURE__ */ new Map();
-	const addDirected = (from, to, cost) => {
-		const list = adj.get(from);
-		if (list === void 0) adj.set(from, [{
-			to,
-			cost
-		}]);
-		else list.push({
-			to,
-			cost
-		});
-	};
-	const addEdge = (from, to, cost) => {
-		addDirected(from, to, cost);
-		addDirected(to, from, cost);
-	};
-	for (const a of CONTENT_FORMATS) for (const b of CONTENT_FORMATS) {
-		if (a === b) continue;
-		if (FORMAT_NODES[a].variant === FORMAT_NODES[b].variant) addEdge(a, b, 1);
-	}
-	for (const key of Object.keys(TRANSFORMS)) {
-		const parts = key.split("->");
-		const fromVariant = parts[0];
-		const toVariant = parts[1];
-		if (fromVariant === void 0 || toVariant === void 0) continue;
-		for (const a of CONTENT_FORMATS) {
-			if (FORMAT_NODES[a].variant !== fromVariant) continue;
-			for (const b of CONTENT_FORMATS) {
-				if (FORMAT_NODES[b].variant !== toVariant) continue;
-				addEdge(a, b, 2);
-			}
-		}
-	}
-	for (const format of CONTENT_FORMATS) if (LAYOUT_CAPABLE.has(format)) addEdge(format, "pdf", 3);
-	return adj;
-}
-const COMPOSITION_GRAPH = buildCompositionGraph();
-function shortestPath(source, target) {
-	if (source === target) return;
-	const distances = /* @__PURE__ */ new Map([[source, 0]]);
-	const previous = /* @__PURE__ */ new Map();
-	const visited = /* @__PURE__ */ new Set();
-	while (true) {
-		let current = void 0;
-		let currentDist = Infinity;
-		for (const [node, dist] of distances) if (!visited.has(node) && dist < currentDist) {
-			current = node;
-			currentDist = dist;
-		}
-		if (current === void 0 || current === target) break;
-		visited.add(current);
-		for (const edge of COMPOSITION_GRAPH.get(current) ?? []) {
-			if (visited.has(edge.to)) continue;
-			const alt = currentDist + edge.cost;
-			const known = distances.get(edge.to);
-			if (known === void 0 || alt < known) {
-				distances.set(edge.to, alt);
-				previous.set(edge.to, current);
-			}
-		}
-	}
-	if (distances.get(target) === void 0) return;
-	const path = [];
-	let cursor = target;
-	while (cursor !== void 0) {
-		path.unshift(cursor);
-		cursor = previous.get(cursor);
-	}
-	return path;
-}
-function resolveCompositionPlan(source, target) {
-	const path = shortestPath(source, target);
-	if (path === void 0) return;
-	if (path.length > 4) return;
-	const hops = [];
-	for (let i = 0; i + 1 < path.length; i++) {
-		const from = path[i];
-		const to = path[i + 1];
-		if (from === void 0 || to === void 0) return;
-		const executor = to === "pdf" ? "toPdf" : from === "pdf" ? "fromPdf" : "bridge";
-		hops.push({
-			executor,
-			from,
-			to
-		});
-	}
-	return { hops };
-}
-function isContentFormat(format) {
-	return format !== "pdf" && format !== "odf";
-}
-function convertDocument(source, target, bytes, options) {
-	const plan = resolveCompositionPlan(source, target);
-	if (plan === void 0) throw new UnsupportedConversionError(source, target);
-	let current = bytes;
-	for (let i = 0; i < plan.hops.length; i++) {
-		const hop = plan.hops[i];
-		if (hop === void 0) throw new Error("convertDocument: resolveCompositionPlan returned a malformed hop");
-		const hopOptions = i === plan.hops.length - 1 ? options : options === void 0 ? void 0 : {
-			...options,
-			onDocument: void 0
-		};
-		if (hop.executor === "toPdf") {
-			if (!isContentFormat(hop.from)) throw new Error(`convertDocument: toPdf source '${hop.from}' is not a content format`);
-			current = executeToPdf(hop.from, current, hopOptions);
-		} else if (hop.executor === "fromPdf") {
-			if (!isContentFormat(hop.to)) throw new Error(`convertDocument: fromPdf target '${hop.to}' is not a content format`);
-			current = executeFromPdf(hop.to, current, hopOptions);
-		} else {
-			if (!isContentFormat(hop.from) || !isContentFormat(hop.to)) throw new Error(`convertDocument: bridge endpoints '${hop.from}' -> '${hop.to}' are not both content formats`);
-			current = executeBridge(hop.from, hop.to, current, hopOptions);
-		}
-	}
-	return current;
-}
-//#endregion
-//#region src/convert/convert.ts
-const mathMetricsAt = (sizePt) => loadMathFont().metricsAt(sizePt);
-function docxToPdf(bytes, options) {
-	return convertDocument("docx", "pdf", bytes, options);
-}
-function odtToPdf(bytes, options) {
-	return convertDocument("odt", "pdf", bytes, options);
-}
-function pptxToPdf(bytes, options) {
-	return convertDocument("pptx", "pdf", bytes, options);
-}
-function odpToPdf(bytes, options) {
-	return convertDocument("odp", "pdf", bytes, options);
-}
-function odsToPdf(bytes, options) {
-	return convertDocument("ods", "pdf", bytes, options);
-}
-function odgToPdf(bytes, options) {
-	return convertDocument("odg", "pdf", bytes, options);
-}
-function markdownToPdf(bytes, options) {
-	return convertDocument("markdown", "pdf", bytes, options);
-}
-const STANDALONE_FORMULA_SIZE_PT = 18;
-const STANDALONE_FORMULA_MARGIN_PT = 72;
-function odfToPdf(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const read = readOdfFormulaContent(pkg);
-	if (read.kind !== "formula") throw new Error("readOdfFormulaContent returned a non-formula ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const metrics = loadMathFont().metricsAt(STANDALONE_FORMULA_SIZE_PT);
-	const { box } = layoutFormula(content.formula.mathml, {
-		metrics,
-		sizePt: STANDALONE_FORMULA_SIZE_PT,
-		color: COLOR_BLACK
-	});
-	const flipped = flipY({
-		xPt: STANDALONE_FORMULA_MARGIN_PT,
-		yPt: STANDALONE_FORMULA_MARGIN_PT,
-		widthPt: box.widthPt,
-		heightPt: box.heightPt
-	}, PAGE_SIZE_A4.heightPt);
-	const layout = {
-		formatVersion: LAYOUT_FORMAT_VERSION,
-		metadata: content.metadata,
-		pages: [{
-			widthPt: PAGE_SIZE_A4.widthPt,
-			heightPt: PAGE_SIZE_A4.heightPt,
-			items: []
-		}],
-		images: {}
-	};
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	throwIfAborted(options?.signal);
-	return writePdf(layout, {
-		signal: options?.signal,
-		formulas: [{
-			pageIndex: 0,
-			xPt: flipped.xPt,
-			yPt: flipped.yPt,
-			box
-		}]
-	});
-}
-function pdfToDocx(bytes, options) {
-	return convertDocument("pdf", "docx", bytes, options);
-}
-function pdfToPptx(bytes, options) {
-	return convertDocument("pdf", "pptx", bytes, options);
-}
-function pdfToOdt(bytes, options) {
-	return convertDocument("pdf", "odt", bytes, options);
-}
-function pdfToOdp(bytes, options) {
-	return convertDocument("pdf", "odp", bytes, options);
-}
-function pdfToOdg(bytes, options) {
-	return convertDocument("pdf", "odg", bytes, options);
-}
-function pdfToOds(bytes, options) {
-	return convertDocument("pdf", "ods", bytes, options);
-}
-function pdfToMarkdown(bytes, options) {
-	return convertDocument("pdf", "markdown", bytes, options);
-}
-function odtToDocx(bytes, options) {
-	return convertDocument("odt", "docx", bytes, options);
-}
-function docxToOdt(bytes, options) {
-	return convertDocument("docx", "odt", bytes, options);
-}
-function odpToPptx(bytes, options) {
-	return convertDocument("odp", "pptx", bytes, options);
-}
-function pptxToOdp(bytes, options) {
-	return convertDocument("pptx", "odp", bytes, options);
-}
-function odsToXlsx(bytes, options) {
-	return convertDocument("ods", "xlsx", bytes, options);
-}
-function xlsxToOds(bytes, options) {
-	return convertDocument("xlsx", "ods", bytes, options);
-}
-function markdownToDocx(bytes, options) {
-	return convertDocument("markdown", "docx", bytes, options);
-}
-function docxToMarkdown(bytes, options) {
-	return convertDocument("docx", "markdown", bytes, options);
-}
-function markdownToOdt(bytes, options) {
-	return convertDocument("markdown", "odt", bytes, options);
-}
-function odtToMarkdown(bytes, options) {
-	return convertDocument("odt", "markdown", bytes, options);
-}
-function docxToPptx(bytes, options) {
-	return convertDocument("docx", "pptx", bytes, options);
-}
-function pptxToDocx(bytes, options) {
-	return convertDocument("pptx", "docx", bytes, options);
-}
-function odtToOdp(bytes, options) {
-	return convertDocument("odt", "odp", bytes, options);
-}
-function odpToOdt(bytes, options) {
-	return convertDocument("odp", "odt", bytes, options);
-}
-function xlsxToPdf(bytes, options) {
-	return convertDocument("xlsx", "pdf", bytes, options);
-}
-function pdfToXlsx(bytes, options) {
-	return convertDocument("pdf", "xlsx", bytes, options);
-}
-function xlsxToMarkdown(bytes, options) {
-	return convertDocument("xlsx", "markdown", bytes, options);
-}
-function markdownToXlsx(bytes, options) {
-	return convertDocument("markdown", "xlsx", bytes, options);
-}
-var OdmUnresolvedSectionError = class extends Error {
-	hrefs;
-	constructor(hrefs) {
-		super(`odmToPdf: ${hrefs.length} chapter section(s) could not be resolved -- no inline content and no resolveSubDocument result for: ${hrefs.join(", ")}`);
-		this.name = "OdmUnresolvedSectionError";
-		this.hrefs = hrefs;
-	}
-};
-const INLINE_SECTION_MARGIN_PT = 56.69291338582677;
-const INLINE_SECTION_MARGINS = {
-	topPt: INLINE_SECTION_MARGIN_PT,
-	rightPt: INLINE_SECTION_MARGIN_PT,
-	bottomPt: INLINE_SECTION_MARGIN_PT,
-	leftPt: INLINE_SECTION_MARGIN_PT
-};
-function inlineOdmSectionToContentSection(section, pkg) {
-	const blocks = [];
-	for (const node of section.inlineContent ?? []) {
-		if (node.type !== "element") continue;
-		if (node.tag === "text:p" || node.tag === "text:h") blocks.push(readOdfParagraph(node, pkg));
-		else if (node.tag === "table:table") blocks.push(readOdfTable(node, pkg));
-	}
-	return {
-		pageSize: PAGE_SIZE_A4,
-		margins: INLINE_SECTION_MARGINS,
-		blocks
-	};
-}
-function withLeadingChapterBreak(section) {
-	const pageBreak = { kind: "pageBreak" };
-	return {
-		...section,
-		blocks: [pageBreak, ...section.blocks]
-	};
-}
-function odmToPdf(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const odm = readOdm(pkg);
-	const unresolvedHrefs = [];
-	const chapterSections = [];
-	const sourceFonts = extractSourceFonts({
-		kind: "odf",
-		package: pkg
-	});
-	for (const section of odm.sections) {
-		throwIfAborted(options?.signal);
-		if (section.inlineContent !== void 0) {
-			chapterSections.push([inlineOdmSectionToContentSection(section, pkg)]);
-			continue;
-		}
-		const chapterBytes = options?.resolveSubDocument?.(section.href);
-		if (chapterBytes === void 0) {
-			unresolvedHrefs.push(section.href);
-			continue;
-		}
-		const chapterPkg = decodePackage$1(chapterBytes);
-		sourceFonts.push(...extractSourceFonts({
-			kind: "odf",
-			package: chapterPkg
-		}));
-		const chapterContent = readOdtContent(chapterPkg);
-		if (chapterContent.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
-		chapterSections.push(chapterContent.sections);
-	}
-	if (unresolvedHrefs.length > 0) throw new OdmUnresolvedSectionError(unresolvedHrefs);
-	const combinedSections = [];
-	chapterSections.forEach((sections, chapterIndex) => {
-		if (chapterIndex === 0) {
-			combinedSections.push(...sections);
-			return;
-		}
-		combinedSections.push(...sections.map((section, sectionIndex) => sectionIndex === 0 ? withLeadingChapterBreak(section) : section));
-	});
-	throwIfAborted(options?.signal);
-	const content = {
-		kind: "wordprocessing",
-		formatVersion: CONTENT_FORMAT_VERSION,
-		metadata: resolveMetadataTimestamps(readOdfMetadata(pkg), options?.clock),
-		sections: combinedSections
-	};
-	const fonts = createFontRegistry({
-		sourceFonts,
-		fonts: options?.fonts,
-		onSubstitution: options?.onFontSubstitution
-	});
-	const { document: layout, formulas } = convertWordprocessingToLayout(content, {
-		measurer: createFontMeasurer(fonts),
-		mathMetricsAt
-	});
-	return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		formulas,
-		fonts
-	});
-}
-function odbToXlsx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const tables = readOdbTables(pkg, { timeZone: options?.timeZone });
-	throwIfAborted(options?.signal);
-	const content = odbTablesToSpreadsheetDocument(tables);
-	return encodePackage(buildXlsxPackage(content));
-}
-function odbToCsv(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const tables = readOdbTables(pkg, { timeZone: options?.timeZone });
-	throwIfAborted(options?.signal);
-	return buildOdbTableCsv(tables, options?.table);
-}
-function odbReportToDocx(content, options) {
-	throwIfAborted(options?.signal);
-	return encodePackage(buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }));
-}
-function odbReportToOdt(content, options) {
-	throwIfAborted(options?.signal);
-	return encodePackage$1(buildOdtPackage(content));
-}
-function odbReportToPdf(content, options) {
-	throwIfAborted(options?.signal);
-	if (content.kind !== "wordprocessing") throw new Error("odbReportToPdf requires a wordprocessing ContentDocument");
-	const fonts = createFontRegistry({
-		fonts: options?.fonts,
-		onSubstitution: options?.onFontSubstitution
-	});
-	const { document: layout, formulas } = convertWordprocessingToLayout(content, {
-		measurer: createFontMeasurer(fonts),
-		mathMetricsAt
-	});
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		formulas,
-		fonts
-	});
-}
-//#endregion
-export { pdfToOdg as A, xlsxToOds as B, odsToXlsx as C, odtToPdf as D, odtToOdp as E, pdfToXlsx as F, DIRECT_EDGES as G, FORMAT_NODES as H, pptxToDocx as I, resolveConversionPath as J, FORMAT_CAPABILITIES as K, pptxToOdp as L, pdfToOds as M, pdfToOdt as N, pdfToDocx as O, pdfToPptx as P, pptxToPdf as R, odsToPdf as S, odtToMarkdown as T, convertDocument as U, xlsxToPdf as V, resolveCompositionPlan as W, odgToPdf as _, docxToPptx as a, odpToPdf as b, markdownToOdt as c, odbReportToDocx as d, odbReportToOdt as f, odfToPdf as g, odbToXlsx as h, docxToPdf as i, pdfToOdp as j, pdfToMarkdown as k, markdownToPdf as l, odbToCsv as m, docxToMarkdown as n, inlineOdmSectionToContentSection as o, odbReportToPdf as p, UnsupportedConversionError as q, docxToOdt as r, markdownToDocx as s, OdmUnresolvedSectionError as t, markdownToXlsx as u, odmToPdf as v, odtToDocx as w, odpToPptx as x, odpToOdt as y, xlsxToMarkdown as z };