js.documents 14.4.56 → 14.4.58

package/dist/convert/composition.d.ts

@@ -1,85 +1,2 @@
-import { t as ClockPort } from "../clock-Cewekmhw.js";
-import { DocumentFormat } from "./port.js";
-import { t as ContentVariant } from "../capability-BmRwrPL9.js";
-import { i as SvgDiagnosticSink } from "../diagnostics-DVAXKgcf.js";
-import { i as CellTypeInferenceSink } from "../cell-typing-BQ-xQ5X5.js";
-import { t as OmmlDiagnostic } from "../shared-DHu5jDJf.js";
-import { Package } from "ooxml.js";
-import { ContentDocument, DocumentTree, FontSubstitution, ProvidedFont } from "document-schema.js";
-import { PdfDiagnosticSink, WinAnsiSubstitution } from "pdf-codec";
-import { MarkdownImageResolver } from "markdown-codec";
-//#region src/convert/composition.d.ts
-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";
-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";
-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 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>;
-type HopExecutor = "bridge" | "toPdf" | "fromPdf";
-interface CompositionHop {
-  readonly executor: HopExecutor;
-  readonly from: DocumentFormat;
-  readonly to: DocumentFormat;
-}
-interface ConversionPlan {
-  readonly hops: readonly CompositionHop[];
-}
-declare function resolveCompositionPlan(source: DocumentFormat, target: DocumentFormat): ConversionPlan | undefined;
-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
-export { CompositionExecutorBinding, CompositionHop, ContentFormat, ConversionPlan, FORMAT_NODES, FormatNode, HopExecutor, LAYOUT_CAPABLE, READ_ONLY_FORMAT_NODES, ReadOnlyContentFormat, ReadOnlyFormatNode, SourceContentFormat, UnifiedConversionOptions, convertDocumentFromPdf, executeBridge, executeFromPdf, isReadOnlyContentFormat, isTextFormatNode, resolveCompositionPlan, runCompositionPlan };
+import { A as isTextFormatNode, C as THROUGH_PDF_EDGE_COST, D as executeBridge, E as convertDocumentFromPdf, O as executeFromPdf, S as SourceContentFormat, T as UnifiedConversionOptions, _ as READ_ONLY_CONTENT_FORMATS, b as ReadOnlyContentFormat, d as CompositionExecutorBinding, f as ContentFormat, g as MAX_CONVERSION_PATH_NODES, h as LAYOUT_CAPABLE, j as runCompositionPlan, k as isReadOnlyContentFormat, m as FormatNode, p as FORMAT_NODES, u as CONTENT_FORMATS, v as READ_ONLY_FORMAT_NODES, w as TRANSFORMS, x as ReadOnlyFormatNode, y as RECONSTRUCTORS } from "../composition-plan-l6QPO4FX.js";
+export { CONTENT_FORMATS, CompositionExecutorBinding, ContentFormat, FORMAT_NODES, FormatNode, LAYOUT_CAPABLE, MAX_CONVERSION_PATH_NODES, READ_ONLY_CONTENT_FORMATS, READ_ONLY_FORMAT_NODES, RECONSTRUCTORS, ReadOnlyContentFormat, ReadOnlyFormatNode, SourceContentFormat, THROUGH_PDF_EDGE_COST, TRANSFORMS, UnifiedConversionOptions, convertDocumentFromPdf, executeBridge, executeFromPdf, isReadOnlyContentFormat, isTextFormatNode, runCompositionPlan };

package/dist/convert/composition.js

@@ -1,502 +1,2 @@
-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 { readSvgContent } from "../svg/read.js";
-import { buildSvgText } from "../svg/write.js";
-import { throwIfAborted } from "../ports/abort.js";
-import { reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing } from "../layout/reconstruct.js";
-import { stampPdfPackageTables } from "./pdf-package-tables.js";
-import { drawingToPresentation, presentationToDrawing, presentationToWordprocessing, spreadsheetToWordprocessing, wordprocessingToPresentation } from "./variant-bridges.js";
-import { UnsupportedConversionError } from "./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 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", THROUGH_PDF_EDGE_COST);
-	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", THROUGH_PDF_EDGE_COST);
-	}
-	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 > MAX_CONVERSION_PATH_NODES) 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);
-}
-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
-export { FORMAT_NODES, LAYOUT_CAPABLE, READ_ONLY_FORMAT_NODES, convertDocumentFromPdf, executeBridge, executeFromPdf, isReadOnlyContentFormat, isTextFormatNode, resolveCompositionPlan, runCompositionPlan };
+import { _ as executeFromPdf, b as runCompositionPlan, c as LAYOUT_CAPABLE, d as READ_ONLY_FORMAT_NODES, f as RECONSTRUCTORS, g as executeBridge, h as convertDocumentFromPdf, l as MAX_CONVERSION_PATH_NODES, m as TRANSFORMS, o as CONTENT_FORMATS, p as THROUGH_PDF_EDGE_COST, s as FORMAT_NODES, u as READ_ONLY_CONTENT_FORMATS, v as isReadOnlyContentFormat, y as isTextFormatNode } from "../composition-plan-f0zaExUW.js";
+export { CONTENT_FORMATS, FORMAT_NODES, LAYOUT_CAPABLE, MAX_CONVERSION_PATH_NODES, READ_ONLY_CONTENT_FORMATS, READ_ONLY_FORMAT_NODES, RECONSTRUCTORS, THROUGH_PDF_EDGE_COST, TRANSFORMS, convertDocumentFromPdf, executeBridge, executeFromPdf, isReadOnlyContentFormat, isTextFormatNode, runCompositionPlan };

package/dist/convert/convert.cjs

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_geometry = require("../model/geometry.cjs");
 const require_model_metadata = require("../model/metadata.cjs");
 const require_edit_docx_content = require("../edit/docx/content.cjs");
-const require_mathml_layout = require("../mathml/layout.cjs");
+const require_layout = require("../layout-iuiyl_Fk.cjs");
 const require_edit_odt_content = require("../edit/odt/content.cjs");
 const require_fonts_registry = require("../fonts/registry.cjs");
 const require_odf_formula_read = require("../odf/formula/read.cjs");
@@ -58,7 +58,7 @@ function odfToPdf(bytes, options) {
 		metadata: require_model_metadata.resolveMetadataTimestamps(read.metadata, options?.clock)
 	};
 	const metrics = (0, pdf_codec.loadMathFont)().metricsAt(STANDALONE_FORMULA_SIZE_PT);
-	const { box } = require_mathml_layout.layoutFormula(content.formula.mathml, {
+	const { box } = require_layout.layoutFormula(content.formula.mathml, {
 		metrics,
 		sizePt: STANDALONE_FORMULA_SIZE_PT,
 		color: document_schema_js.COLOR_BLACK

package/dist/convert/convert.js

@@ -1,7 +1,7 @@
 import { flipY } from "../model/geometry.js";
 import { resolveMetadataTimestamps } from "../model/metadata.js";
 import { buildDocxPackage } from "../edit/docx/content.js";
-import { layoutFormula } from "../mathml/layout.js";
+import { t as layoutFormula } from "../layout-DIJzJk4x.js";
 import { buildOdtPackage } from "../edit/odt/content.js";
 import { extractSourceFonts } from "../fonts/registry.js";
 import { readOdfFormulaContent as readOdfFormulaContent$1 } from "../odf/formula/read.js";

package/dist/convert/from-package.cjs

@@ -2,10 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_geometry = require("../model/geometry.cjs");
 const require_model_bytes = require("../model/bytes.cjs");
 const require_model_formula = require("../model/formula.cjs");
-const require_mathml_layout = require("../mathml/layout.cjs");
+const require_layout = require("../layout-iuiyl_Fk.cjs");
 const require_layout_text_layout = require("../layout/text-layout.cjs");
 const require_layout_shared = require("../layout/shared.cjs");
-require("../layout/sheets.cjs");
+require("../sheets-BQCpNXsE.cjs");
 const require_layout_drawing = require("../layout/drawing.cjs");
 const require_convert_capability = require("./capability.cjs");
 const require_codecs_registry = require("../codecs/registry.cjs");
@@ -210,7 +210,7 @@ function emitEmbeddedObjectBlock(state, block) {
 	for (const frame of block.frames ?? []) {
 		if (pageOfFrame(state, frame) === void 0) continue;
 		const sizePt = require_layout_shared.formulaSizePtForFrame(formula.mathml, frame, metricsAt);
-		const { box } = require_mathml_layout.layoutFormula(formula.mathml, {
+		const { box } = require_layout.layoutFormula(formula.mathml, {
 			metrics: metricsAt(sizePt),
 			sizePt,
 			color: document_schema_js.COLOR_BLACK

package/dist/convert/from-package.js

@@ -1,10 +1,10 @@
 import { flipY } from "../model/geometry.js";
 import { requireArrayBufferBytes } from "../model/bytes.js";
 import { formulaOfBlock } from "../model/formula.js";
-import { layoutFormula } from "../mathml/layout.js";
+import { t as layoutFormula } from "../layout-DIJzJk4x.js";
 import { atomizeForWrap, firstWrappedLineOf } from "../layout/text-layout.js";
 import { formulaSizePtForFrame, pushCellBorderLines, registerImage, runFont } from "../layout/shared.js";
-import "../layout/sheets.js";
+import "../sheets-DWDvGN-g.js";
 import { convertVector } from "../layout/drawing.js";
 import { READ_ONLY_FORMATS } from "./capability.js";
 import { DOCUMENT_FORMAT_CODECS } from "../codecs/registry.js";