js.documents 14.4.56 → 14.4.57

package/dist/composition-plan-DU9nPPN7.d.cts

@@ -0,0 +1,102 @@
+import { t as ClockPort } from "./clock-Cewekmhw.cjs";
+import { DocumentFormat } from "./convert/port.cjs";
+import { t as ContentVariant } from "./capability-WJWAE-5Z.cjs";
+import { i as SvgDiagnosticSink } from "./diagnostics-DVAXKgcf.cjs";
+import { i as CellTypeInferenceSink } from "./cell-typing-BQ-xQ5X5.cjs";
+import { a as ReconstructOptions } from "./reconstruct-D4TEteZ6.cjs";
+import { t as OmmlDiagnostic } from "./shared-c0Lp3_iY.cjs";
+import { ContentDocument, DocumentTree, FontSubstitution, ProvidedFont } from "document-schema.js";
+import { LayoutDocument, PdfDiagnosticSink, WinAnsiSubstitution } from "pdf-codec";
+import { MarkdownImageResolver } from "markdown-codec";
+import { Package } from "ooxml.js";
+//#region src/convert/composition.d.ts
+declare const THROUGH_PDF_EDGE_COST = 3;
+declare const MAX_CONVERSION_PATH_NODES = 4;
+declare const FORMAT_NODES: Readonly<Record<ContentFormat, FormatNode>>;
+type SourcePackage = Package;
+interface UnifiedConversionOptions {
+  readonly signal?: AbortSignal;
+  readonly onDocument?: (pkg: DocumentTree) => void;
+  readonly fonts?: readonly ProvidedFont[];
+  readonly onFontSubstitution?: (substitution: FontSubstitution) => void;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly sink?: PdfDiagnosticSink;
+  readonly onMathDiagnostic?: (diagnostic: OmmlDiagnostic, context: {
+    readonly sourcePath?: string;
+  }) => void;
+  readonly images?: MarkdownImageResolver;
+  readonly delimiter?: string;
+  readonly sheet?: string;
+  readonly onCellTypeInference?: CellTypeInferenceSink;
+  readonly page?: number;
+  readonly onSvgDiagnostic?: SvgDiagnosticSink;
+  readonly clock?: ClockPort;
+}
+type ContentFormat = "docx" | "pptx" | "xlsx" | "odt" | "odp" | "ods" | "odg" | "svg" | "csv" | "markdown" | "rtf" | "doc" | "xls" | "ppt" | "epub";
+declare const CONTENT_FORMATS: readonly ContentFormat[];
+type LayoutVariant = Exclude<ContentVariant, "formula">;
+interface PackageFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: "ooxml" | "odf";
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => SourcePackage;
+  readonly read: (pkg: SourcePackage, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument, options?: UnifiedConversionOptions) => SourcePackage;
+  readonly encode: (pkg: SourcePackage) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: true;
+}
+interface TextFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: "markdown" | "csv" | "svg" | "rtf" | "doc" | "xls" | "ppt" | "epub";
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => string;
+  readonly read: (text: string, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument, options?: UnifiedConversionOptions) => string;
+  readonly encode: (text: string) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: false;
+}
+type FormatNode = PackageFormatNode | TextFormatNode;
+declare function isTextFormatNode(node: FormatNode): node is TextFormatNode;
+type ReadOnlyContentFormat = "wpd";
+declare const READ_ONLY_CONTENT_FORMATS: readonly ReadOnlyContentFormat[];
+interface ReadOnlyFormatNode {
+  readonly variant: LayoutVariant;
+  readonly read: (bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions) => ContentDocument;
+}
+declare const READ_ONLY_FORMAT_NODES: Readonly<Record<ReadOnlyContentFormat, ReadOnlyFormatNode>>;
+type SourceContentFormat = ContentFormat | ReadOnlyContentFormat;
+declare function isReadOnlyContentFormat(format: DocumentFormat): format is ReadOnlyContentFormat;
+declare const LAYOUT_CAPABLE: ReadonlySet<SourceContentFormat>;
+declare const TRANSFORMS: Readonly<Record<string, (doc: ContentDocument) => ContentDocument>>;
+declare const RECONSTRUCTORS: Readonly<Record<LayoutVariant, (doc: LayoutDocument, options?: ReconstructOptions) => ContentDocument>>;
+declare function executeBridge(source: SourceContentFormat, target: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+declare function executeFromPdf(target: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+interface CompositionExecutorBinding {
+  readonly bridge: (source: SourceContentFormat, target: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions) => Uint8Array<ArrayBuffer>;
+  readonly fromPdf: (target: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions) => Uint8Array<ArrayBuffer>;
+  readonly toPdf?: (source: SourceContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions) => Uint8Array<ArrayBuffer>;
+}
+declare function runCompositionPlan(plan: ConversionPlan, bytes: Uint8Array<ArrayBuffer>, options: UnifiedConversionOptions | undefined, executors: CompositionExecutorBinding): Uint8Array<ArrayBuffer>;
+declare function convertDocumentFromPdf(target: ContentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/convert/composition-plan.d.ts
+type HopExecutor = "bridge" | "toPdf" | "fromPdf";
+interface CompositionHop {
+  readonly executor: HopExecutor;
+  readonly from: DocumentFormat;
+  readonly to: DocumentFormat;
+}
+interface ConversionPlan {
+  readonly hops: readonly CompositionHop[];
+}
+interface GraphEdge {
+  readonly to: DocumentFormat;
+  readonly cost: number;
+}
+declare function buildCompositionGraph(): ReadonlyMap<DocumentFormat, readonly GraphEdge[]>;
+declare function shortestPath(source: DocumentFormat, target: DocumentFormat): readonly DocumentFormat[] | undefined;
+declare function resolveCompositionPlan(source: DocumentFormat, target: DocumentFormat): ConversionPlan | undefined;
+declare function isContentFormat(format: DocumentFormat): format is ContentFormat;
+declare function isSourceContentFormat(format: DocumentFormat): format is SourceContentFormat;
+//#endregion
+export { isTextFormatNode as A, THROUGH_PDF_EDGE_COST as C, executeBridge as D, convertDocumentFromPdf as E, executeFromPdf as O, SourceContentFormat as S, UnifiedConversionOptions as T, READ_ONLY_CONTENT_FORMATS as _, buildCompositionGraph as a, ReadOnlyContentFormat as b, resolveCompositionPlan as c, CompositionExecutorBinding as d, ContentFormat as f, MAX_CONVERSION_PATH_NODES as g, LAYOUT_CAPABLE as h, HopExecutor as i, runCompositionPlan as j, isReadOnlyContentFormat as k, shortestPath as l, FormatNode as m, ConversionPlan as n, isContentFormat as o, FORMAT_NODES as p, GraphEdge as r, isSourceContentFormat as s, CompositionHop as t, CONTENT_FORMATS as u, READ_ONLY_FORMAT_NODES as v, TRANSFORMS as w, ReadOnlyFormatNode as x, RECONSTRUCTORS as y };

package/dist/composition-plan-f0zaExUW.js

@@ -0,0 +1,508 @@
+import { decodeSvgText, encodeSvgText } from "./svg/text.js";
+import { requireArrayBufferBytes } from "./model/bytes.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 { buildMarkdownText } from "./markdown/write.js";
+import { readMarkdownContent as readMarkdownContent$1 } from "./markdown/read.js";
+import { t as readPptContent } from "./read--7mUJ4w7.js";
+import { writePptContent } from "./ppt/write.js";
+import { readDocxContent as readDocxContent$1 } from "./ooxml/docx/read.js";
+import { readPptxContent as readPptxContent$1 } from "./ooxml/pptx/read.js";
+import { readOdtContent as readOdtContent$1 } from "./odf/odt/read.js";
+import { readOdpContent as readOdpContent$1 } from "./odf/odp/read.js";
+import { readOdsContent as readOdsContent$1 } from "./odf/ods/read.js";
+import { readOdgContent as readOdgContent$1 } 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 { buildCsvText } from "./csv/write.js";
+import { i as readSvgContent } from "./read-BSH--XB4.js";
+import { buildSvgText } from "./svg/write.js";
+import { throwIfAborted } from "./ports/abort.js";
+import { _ as reconstructWordprocessing, g as reconstructSpreadsheet, i as reconstructPresentation, r as reconstructDrawing } from "./reconstruct-presentations-prod-B5fkPiRZ.js";
+import { stampPdfPackageTables } from "./convert/pdf-package-tables.js";
+import { drawingToPresentation, presentationToDrawing, presentationToWordprocessing, spreadsheetToWordprocessing, wordprocessingToPresentation } from "./convert/variant-bridges.js";
+import { UnsupportedConversionError } from "./convert/capability.js";
+import { buildXlsxPackageFromContent, decodePackage, encodePackage, readXlsxContent } from "ooxml.js";
+import { assembleTree } from "document-schema.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
+import { readDocContent, writeDocContent } from "doc-codec";
+import { readXlsContent, writeXlsContent } from "xls-codec";
+import { readRtfContent, rtfBytesFromLatin1, writeRtfContent } from "rtf-codec";
+import { readEpubContent, writeEpubContent } from "epub-codec";
+import "markdown-codec";
+import { readWpdContent } from "wpd-codec";
+import { readPdf } from "pdf-codec/read";
+//#region src/convert/composition.ts
+const LATIN1_MAX_CODE = 255;
+const HEX_RADIX = 16;
+const UNICODE_HEX_DIGITS = 4;
+const THROUGH_PDF_EDGE_COST = 3;
+const MAX_CONVERSION_PATH_NODES = 4;
+const FORMAT_NODES = {
+	docx: {
+		variant: "wordprocessing",
+		family: "ooxml",
+		decode: (bytes) => decodePackage(bytes),
+		read: (pkg, options) => readDocxContent$1(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, options) => readPptxContent$1(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
+		build: (content, options) => buildPptxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
+		encode: (pkg) => encodePackage(pkg),
+		hasSourcePackage: true
+	},
+	xlsx: {
+		variant: "spreadsheet",
+		family: "ooxml",
+		decode: (bytes) => decodePackage(bytes),
+		read: (pkg) => readXlsxContent(pkg),
+		build: (content) => buildXlsxPackageFromContent(content),
+		encode: (pkg) => encodePackage(pkg),
+		hasSourcePackage: true
+	},
+	odt: {
+		variant: "wordprocessing",
+		family: "odf",
+		decode: (bytes) => decodePackage$1(bytes),
+		read: (pkg) => readOdtContent$1(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$1(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$1(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$1(pkg),
+		build: (content) => buildOdgPackage(content),
+		encode: (pkg) => encodePackage$1(pkg),
+		hasSourcePackage: true
+	},
+	svg: {
+		variant: "drawing",
+		family: "svg",
+		decode: (bytes) => decodeSvgText(bytes),
+		read: (text, options) => readSvgContent(text, { onSvgDiagnostic: options?.onSvgDiagnostic }),
+		build: (content, options) => buildSvgText(content, {
+			page: options?.page,
+			onSvgDiagnostic: options?.onSvgDiagnostic
+		}),
+		encode: (text) => encodeSvgText(text),
+		hasSourcePackage: false
+	},
+	markdown: {
+		variant: "wordprocessing",
+		family: "markdown",
+		decode: (bytes) => decodeMarkdownText(bytes),
+		read: (text, options) => readMarkdownContent$1(text, {
+			signal: options?.signal,
+			images: options?.images
+		}),
+		build: (content) => buildMarkdownText(content),
+		encode: (text) => encodeMarkdownText(text),
+		hasSourcePackage: false
+	},
+	csv: {
+		variant: "spreadsheet",
+		family: "csv",
+		decode: (bytes) => decodeCsvText(bytes),
+		read: (text, options) => readCsvContent(text, {
+			delimiter: options?.delimiter,
+			onCellTypeInference: options?.onCellTypeInference
+		}),
+		build: (content, options) => buildCsvText(content, {
+			delimiter: options?.delimiter,
+			sheet: options?.sheet
+		}),
+		encode: (text) => encodeCsvText(text),
+		hasSourcePackage: false
+	},
+	rtf: {
+		variant: "wordprocessing",
+		family: "rtf",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => readRtfContent(text, { signal: options?.signal }).document,
+		build: (content) => bytesToLatin1(writeRtfContent(content)),
+		encode: (text) => requireArrayBufferBytes(rtfBytesFromLatin1(text)),
+		hasSourcePackage: false
+	},
+	doc: {
+		variant: "wordprocessing",
+		family: "doc",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			throwIfAborted(options?.signal);
+			return readDocContent(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1(writeDocContent(content)),
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	epub: {
+		variant: "wordprocessing",
+		family: "epub",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			throwIfAborted(options?.signal);
+			return readEpubContent(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1(writeEpubContent(content)),
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	xls: {
+		variant: "spreadsheet",
+		family: "xls",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			throwIfAborted(options?.signal);
+			return readXlsContent(latin1ToBytes(text));
+		},
+		build: (content) => {
+			if (content.kind !== "spreadsheet") throw new Error("FORMAT_NODES.xls.build: expected a spreadsheet ContentDocument");
+			return bytesToLatin1(writeXlsContent(content));
+		},
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	ppt: {
+		variant: "presentation",
+		family: "ppt",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			throwIfAborted(options?.signal);
+			return readPptContent(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1(writePptContent(content)),
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	}
+};
+const CONTENT_FORMATS = [
+	"docx",
+	"pptx",
+	"xlsx",
+	"odt",
+	"odp",
+	"ods",
+	"odg",
+	"svg",
+	"csv",
+	"markdown",
+	"rtf",
+	"doc",
+	"xls",
+	"ppt",
+	"epub"
+];
+function isTextFormatNode(node) {
+	return !node.hasSourcePackage;
+}
+const READ_ONLY_CONTENT_FORMATS = ["wpd"];
+const READ_ONLY_FORMAT_NODES = { wpd: {
+	variant: "wordprocessing",
+	read: (bytes) => readWpdContent(bytes)
+} };
+function isReadOnlyContentFormat(format) {
+	return READ_ONLY_CONTENT_FORMATS.includes(format);
+}
+function readSourceContent(format, bytes, options) {
+	if (isReadOnlyContentFormat(format)) {
+		const node = READ_ONLY_FORMAT_NODES[format];
+		return {
+			content: node.read(bytes, options),
+			variant: node.variant
+		};
+	}
+	const node = FORMAT_NODES[format];
+	if (isTextFormatNode(node)) {
+		const text = node.decode(bytes);
+		return {
+			content: node.read(text, options),
+			variant: node.variant
+		};
+	}
+	const pkg = node.decode(bytes);
+	return {
+		content: node.read(pkg, options),
+		variant: node.variant
+	};
+}
+const LATIN1_CHUNK_SIZE = 8192;
+function bytesToLatin1(bytes) {
+	let text = "";
+	for (let start = 0; start < bytes.length; start += LATIN1_CHUNK_SIZE) text += String.fromCharCode(...bytes.subarray(start, start + LATIN1_CHUNK_SIZE));
+	return text;
+}
+function latin1ToBytes(text) {
+	const bytes = new Uint8Array(text.length);
+	for (let index = 0; index < text.length; index += 1) {
+		const code = text.charCodeAt(index);
+		if (code > LATIN1_MAX_CODE) throw new TypeError(`latin1ToBytes: character at index ${String(index)} is U+${code.toString(HEX_RADIX).toUpperCase().padStart(UNICODE_HEX_DIGITS, "0")}, above U+00FF — this string no longer holds the file's original bytes`);
+		bytes[index] = code;
+	}
+	return bytes;
+}
+const LAYOUT_CAPABLE = /* @__PURE__ */ new Set([
+	"docx",
+	"pptx",
+	"odt",
+	"odp",
+	"ods",
+	"odg",
+	"svg",
+	"markdown",
+	"wpd"
+]);
+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);
+	},
+	"drawing->presentation": (doc) => {
+		if (doc.kind !== "drawing") throw new Error("drawingToPresentation: expected a drawing ContentDocument");
+		return drawingToPresentation(doc);
+	},
+	"presentation->drawing": (doc) => {
+		if (doc.kind !== "presentation") throw new Error("presentationToDrawing: expected a presentation ContentDocument");
+		return presentationToDrawing(doc);
+	},
+	"spreadsheet->wordprocessing": (doc) => {
+		if (doc.kind !== "spreadsheet") throw new Error("spreadsheetToWordprocessing: expected a spreadsheet ContentDocument");
+		return spreadsheetToWordprocessing(doc);
+	}
+};
+const RECONSTRUCTORS = {
+	wordprocessing: reconstructWordprocessing,
+	presentation: reconstructPresentation,
+	drawing: reconstructDrawing,
+	spreadsheet: reconstructSpreadsheet
+};
+function executeBridge(source, target, bytes, options) {
+	throwIfAborted(options?.signal);
+	const targetNode = FORMAT_NODES[target];
+	const { content, variant: sourceVariant } = readSourceContent(source, bytes, options);
+	if (content.kind !== sourceVariant) throw new Error(`executeBridge: ${source} read returned a non-${sourceVariant} ContentDocument`);
+	let buildContent = content;
+	if (sourceVariant !== targetNode.variant) {
+		const key = `${sourceVariant}->${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);
+	let out;
+	if (isTextFormatNode(targetNode)) {
+		const text = targetNode.build(buildContent, options);
+		out = targetNode.encode(text);
+	} else {
+		const pkg = targetNode.build(buildContent, options);
+		out = targetNode.encode(pkg);
+	}
+	options?.onDocument?.(assembleTree(buildContent));
+	return out;
+}
+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,
+		onCellTypeInference: options?.onCellTypeInference
+	});
+	const pages = layout.pages.map((page) => ({
+		widthPt: page.widthPt,
+		heightPt: page.heightPt
+	}));
+	let out;
+	if (isTextFormatNode(node)) {
+		const text = node.build(content, options);
+		out = node.encode(text);
+	} else {
+		const pkg = node.build(content);
+		out = node.encode(pkg);
+	}
+	const reported = assembleTree(content, pages);
+	stampPdfPackageTables(reported, layout);
+	options?.onDocument?.(reported);
+	return out;
+}
+function runCompositionPlan(plan, bytes, options, executors) {
+	let current = bytes;
+	for (let i = 0; i < plan.hops.length; i++) {
+		const hop = plan.hops[i];
+		if (hop === void 0) throw new Error("runCompositionPlan: 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 (!isSourceContentFormat(hop.from)) throw new Error(`runCompositionPlan: toPdf source '${hop.from}' is not a content format`);
+			const toPdf = executors.toPdf;
+			if (toPdf === void 0) throw new Error(`runCompositionPlan: the plan's ${hop.from} -> ${hop.to} hop needs a toPdf executor, but this binding carries none (the read-only entry cannot render PDFs)`);
+			current = toPdf(hop.from, current, hopOptions);
+		} else if (hop.executor === "fromPdf") {
+			if (!isContentFormat(hop.to)) throw new Error(`runCompositionPlan: fromPdf target '${hop.to}' is not a content format`);
+			current = executors.fromPdf(hop.to, current, hopOptions);
+		} else {
+			if (!isSourceContentFormat(hop.from) || !isContentFormat(hop.to)) throw new Error(`runCompositionPlan: bridge endpoints '${hop.from}' -> '${hop.to}' are not both content formats`);
+			current = executors.bridge(hop.from, hop.to, current, hopOptions);
+		}
+	}
+	return current;
+}
+function convertDocumentFromPdf(target, bytes, options) {
+	const plan = resolveCompositionPlan("pdf", target);
+	if (plan === void 0) throw new UnsupportedConversionError("pdf", target);
+	return runCompositionPlan(plan, bytes, options, {
+		bridge: executeBridge,
+		fromPdf: executeFromPdf
+	});
+}
+//#endregion
+//#region src/convert/composition-plan.ts
+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;
+				addDirected(a, b, 2);
+			}
+		}
+	}
+	for (const format of CONTENT_FORMATS) if (LAYOUT_CAPABLE.has(format)) addEdge(format, "pdf", 3);
+	for (const source of READ_ONLY_CONTENT_FORMATS) {
+		const variant = READ_ONLY_FORMAT_NODES[source].variant;
+		for (const target of CONTENT_FORMATS) {
+			const targetVariant = FORMAT_NODES[target].variant;
+			if (targetVariant === variant) addDirected(source, target, 1);
+			else if (TRANSFORMS[`${variant}->${targetVariant}`] !== void 0) addDirected(source, target, 2);
+		}
+		if (LAYOUT_CAPABLE.has(source)) addDirected(source, "pdf", 3);
+	}
+	return adj;
+}
+let compositionGraphCache;
+function compositionGraph() {
+	compositionGraphCache ??= buildCompositionGraph();
+	return compositionGraphCache;
+}
+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 compositionGraph().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" && !isReadOnlyContentFormat(format);
+}
+function isSourceContentFormat(format) {
+	return isContentFormat(format) || isReadOnlyContentFormat(format);
+}
+//#endregion
+export { executeFromPdf as _, shortestPath as a, runCompositionPlan as b, LAYOUT_CAPABLE as c, READ_ONLY_FORMAT_NODES as d, RECONSTRUCTORS as f, executeBridge as g, convertDocumentFromPdf as h, resolveCompositionPlan as i, MAX_CONVERSION_PATH_NODES as l, TRANSFORMS as m, isContentFormat as n, CONTENT_FORMATS as o, THROUGH_PDF_EDGE_COST as p, isSourceContentFormat as r, FORMAT_NODES as s, buildCompositionGraph as t, READ_ONLY_CONTENT_FORMATS as u, isReadOnlyContentFormat as v, isTextFormatNode as y };