js.documents 14.4.56 → 14.4.57

package/dist/codecs/read.cjs

@@ -13,7 +13,7 @@ const require_odf_odg_read = require("../odf/odg/read.cjs");
 const require_markdown_text = require("../markdown/text.cjs");
 const require_csv_text = require("../csv/text.cjs");
 const require_csv_read = require("../csv/read.cjs");
-const require_svg_read = require("../svg/read.cjs");
+const require_read$1 = require("../read-CahCZMwG.cjs");
 const require_ports_abort = require("../ports/abort.cjs");
 const require_package_codec = require("../package-codec.cjs");
 let ooxml_js = require("ooxml.js");
@@ -58,7 +58,7 @@ const CONTENT_READERS = {
 		images: options?.images
 	}),
 	csv: (bytes) => require_csv_read.readCsvContent(require_csv_text.decodeCsvText(bytes)),
-	svg: (bytes) => require_svg_read.readSvgContent(require_svg_text.decodeSvgText(bytes)),
+	svg: (bytes) => require_read$1.readSvgContent(require_svg_text.decodeSvgText(bytes)),
 	rtf: (bytes, options) => (0, rtf_codec.readRtfContent)(bytes, { signal: options?.signal }).document,
 	doc: (bytes, options) => {
 		require_ports_abort.throwIfAborted(options?.signal);

package/dist/codecs/read.js

@@ -12,7 +12,7 @@ import { readOdgContent } from "../odf/odg/read.js";
 import { decodeMarkdownText } from "../markdown/text.js";
 import { decodeCsvText } from "../csv/text.js";
 import { readCsvContent } from "../csv/read.js";
-import { readSvgContent } from "../svg/read.js";
+import { i as readSvgContent } from "../read-BSH--XB4.js";
 import { throwIfAborted } from "../ports/abort.js";
 import { decodeDocumentPackage } from "../package-codec.js";
 import { readXlsxContent } from "ooxml.js";

package/dist/composition-plan-CfvhXeOC.cjs

@@ -0,0 +1,627 @@
+const require_svg_text = require("./svg/text.cjs");
+const require_model_bytes = require("./model/bytes.cjs");
+const require_edit_docx_content = require("./edit/docx/content.cjs");
+const require_edit_pptx_content = require("./edit/pptx/content.cjs");
+const require_edit_odt_content = require("./edit/odt/content.cjs");
+const require_edit_odp_content = require("./edit/odp/content.cjs");
+const require_edit_ods_content = require("./edit/ods/content.cjs");
+const require_edit_odg_content = require("./edit/odg/content.cjs");
+const require_markdown_write = require("./markdown/write.cjs");
+const require_markdown_read = require("./markdown/read.cjs");
+const require_read = require("./read-pPa9I8MO.cjs");
+const require_ppt_write = require("./ppt/write.cjs");
+const require_ooxml_docx_read = require("./ooxml/docx/read.cjs");
+const require_ooxml_pptx_read = require("./ooxml/pptx/read.cjs");
+const require_odf_odt_read = require("./odf/odt/read.cjs");
+const require_odf_odp_read = require("./odf/odp/read.cjs");
+const require_odf_ods_read = require("./odf/ods/read.cjs");
+const require_odf_odg_read = require("./odf/odg/read.cjs");
+const require_markdown_text = require("./markdown/text.cjs");
+const require_csv_text = require("./csv/text.cjs");
+const require_csv_read = require("./csv/read.cjs");
+const require_csv_write = require("./csv/write.cjs");
+const require_read$1 = require("./read-CahCZMwG.cjs");
+const require_svg_write = require("./svg/write.cjs");
+const require_ports_abort = require("./ports/abort.cjs");
+const require_reconstruct_presentations_prod = require("./reconstruct-presentations-prod-X315aBmI.cjs");
+const require_convert_pdf_package_tables = require("./convert/pdf-package-tables.cjs");
+const require_convert_variant_bridges = require("./convert/variant-bridges.cjs");
+const require_convert_capability = require("./convert/capability.cjs");
+let ooxml_js = require("ooxml.js");
+let document_schema_js = require("document-schema.js");
+let odf_js = require("odf.js");
+let doc_codec = require("doc-codec");
+let xls_codec = require("xls-codec");
+let rtf_codec = require("rtf-codec");
+let epub_codec = require("epub-codec");
+require("markdown-codec");
+let wpd_codec = require("wpd-codec");
+let pdf_codec_read = require("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) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg, options) => require_ooxml_docx_read.readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
+		build: (content, options) => require_edit_docx_content.buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	pptx: {
+		variant: "presentation",
+		family: "ooxml",
+		decode: (bytes) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg, options) => require_ooxml_pptx_read.readPptxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
+		build: (content, options) => require_edit_pptx_content.buildPptxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	xlsx: {
+		variant: "spreadsheet",
+		family: "ooxml",
+		decode: (bytes) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg) => (0, ooxml_js.readXlsxContent)(pkg),
+		build: (content) => (0, ooxml_js.buildXlsxPackageFromContent)(content),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odt: {
+		variant: "wordprocessing",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odt_read.readOdtContent(pkg),
+		build: (content) => require_edit_odt_content.buildOdtPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odp: {
+		variant: "presentation",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odp_read.readOdpContent(pkg),
+		build: (content) => require_edit_odp_content.buildOdpPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	ods: {
+		variant: "spreadsheet",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_ods_read.readOdsContent(pkg),
+		build: (content) => require_edit_ods_content.buildOdsPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odg: {
+		variant: "drawing",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odg_read.readOdgContent(pkg),
+		build: (content) => require_edit_odg_content.buildOdgPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	svg: {
+		variant: "drawing",
+		family: "svg",
+		decode: (bytes) => require_svg_text.decodeSvgText(bytes),
+		read: (text, options) => require_read$1.readSvgContent(text, { onSvgDiagnostic: options?.onSvgDiagnostic }),
+		build: (content, options) => require_svg_write.buildSvgText(content, {
+			page: options?.page,
+			onSvgDiagnostic: options?.onSvgDiagnostic
+		}),
+		encode: (text) => require_svg_text.encodeSvgText(text),
+		hasSourcePackage: false
+	},
+	markdown: {
+		variant: "wordprocessing",
+		family: "markdown",
+		decode: (bytes) => require_markdown_text.decodeMarkdownText(bytes),
+		read: (text, options) => require_markdown_read.readMarkdownContent(text, {
+			signal: options?.signal,
+			images: options?.images
+		}),
+		build: (content) => require_markdown_write.buildMarkdownText(content),
+		encode: (text) => require_markdown_text.encodeMarkdownText(text),
+		hasSourcePackage: false
+	},
+	csv: {
+		variant: "spreadsheet",
+		family: "csv",
+		decode: (bytes) => require_csv_text.decodeCsvText(bytes),
+		read: (text, options) => require_csv_read.readCsvContent(text, {
+			delimiter: options?.delimiter,
+			onCellTypeInference: options?.onCellTypeInference
+		}),
+		build: (content, options) => require_csv_write.buildCsvText(content, {
+			delimiter: options?.delimiter,
+			sheet: options?.sheet
+		}),
+		encode: (text) => require_csv_text.encodeCsvText(text),
+		hasSourcePackage: false
+	},
+	rtf: {
+		variant: "wordprocessing",
+		family: "rtf",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => (0, rtf_codec.readRtfContent)(text, { signal: options?.signal }).document,
+		build: (content) => bytesToLatin1((0, rtf_codec.writeRtfContent)(content)),
+		encode: (text) => require_model_bytes.requireArrayBufferBytes((0, rtf_codec.rtfBytesFromLatin1)(text)),
+		hasSourcePackage: false
+	},
+	doc: {
+		variant: "wordprocessing",
+		family: "doc",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			require_ports_abort.throwIfAborted(options?.signal);
+			return (0, doc_codec.readDocContent)(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1((0, doc_codec.writeDocContent)(content)),
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	epub: {
+		variant: "wordprocessing",
+		family: "epub",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			require_ports_abort.throwIfAborted(options?.signal);
+			return (0, epub_codec.readEpubContent)(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1((0, epub_codec.writeEpubContent)(content)),
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	xls: {
+		variant: "spreadsheet",
+		family: "xls",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			require_ports_abort.throwIfAborted(options?.signal);
+			return (0, xls_codec.readXlsContent)(latin1ToBytes(text));
+		},
+		build: (content) => {
+			if (content.kind !== "spreadsheet") throw new Error("FORMAT_NODES.xls.build: expected a spreadsheet ContentDocument");
+			return bytesToLatin1((0, xls_codec.writeXlsContent)(content));
+		},
+		encode: (text) => latin1ToBytes(text),
+		hasSourcePackage: false
+	},
+	ppt: {
+		variant: "presentation",
+		family: "ppt",
+		decode: (bytes) => bytesToLatin1(bytes),
+		read: (text, options) => {
+			require_ports_abort.throwIfAborted(options?.signal);
+			return require_read.readPptContent(latin1ToBytes(text));
+		},
+		build: (content) => bytesToLatin1(require_ppt_write.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) => (0, wpd_codec.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 require_convert_variant_bridges.wordprocessingToPresentation(doc);
+	},
+	"presentation->wordprocessing": (doc) => {
+		if (doc.kind !== "presentation") throw new Error("presentationToWordprocessing: expected a presentation ContentDocument");
+		return require_convert_variant_bridges.presentationToWordprocessing(doc);
+	},
+	"drawing->presentation": (doc) => {
+		if (doc.kind !== "drawing") throw new Error("drawingToPresentation: expected a drawing ContentDocument");
+		return require_convert_variant_bridges.drawingToPresentation(doc);
+	},
+	"presentation->drawing": (doc) => {
+		if (doc.kind !== "presentation") throw new Error("presentationToDrawing: expected a presentation ContentDocument");
+		return require_convert_variant_bridges.presentationToDrawing(doc);
+	},
+	"spreadsheet->wordprocessing": (doc) => {
+		if (doc.kind !== "spreadsheet") throw new Error("spreadsheetToWordprocessing: expected a spreadsheet ContentDocument");
+		return require_convert_variant_bridges.spreadsheetToWordprocessing(doc);
+	}
+};
+const RECONSTRUCTORS = {
+	wordprocessing: require_reconstruct_presentations_prod.reconstructWordprocessing,
+	presentation: require_reconstruct_presentations_prod.reconstructPresentation,
+	drawing: require_reconstruct_presentations_prod.reconstructDrawing,
+	spreadsheet: require_reconstruct_presentations_prod.reconstructSpreadsheet
+};
+function executeBridge(source, target, bytes, options) {
+	require_ports_abort.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);
+	}
+	require_ports_abort.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?.((0, document_schema_js.assembleTree)(buildContent));
+	return out;
+}
+function executeFromPdf(target, bytes, options) {
+	const node = FORMAT_NODES[target];
+	const layout = (0, pdf_codec_read.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 = (0, document_schema_js.assembleTree)(content, pages);
+	require_convert_pdf_package_tables.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 require_convert_capability.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
+Object.defineProperty(exports, "CONTENT_FORMATS", {
+	enumerable: true,
+	get: function() {
+		return CONTENT_FORMATS;
+	}
+});
+Object.defineProperty(exports, "FORMAT_NODES", {
+	enumerable: true,
+	get: function() {
+		return FORMAT_NODES;
+	}
+});
+Object.defineProperty(exports, "LAYOUT_CAPABLE", {
+	enumerable: true,
+	get: function() {
+		return LAYOUT_CAPABLE;
+	}
+});
+Object.defineProperty(exports, "MAX_CONVERSION_PATH_NODES", {
+	enumerable: true,
+	get: function() {
+		return MAX_CONVERSION_PATH_NODES;
+	}
+});
+Object.defineProperty(exports, "READ_ONLY_CONTENT_FORMATS", {
+	enumerable: true,
+	get: function() {
+		return READ_ONLY_CONTENT_FORMATS;
+	}
+});
+Object.defineProperty(exports, "READ_ONLY_FORMAT_NODES", {
+	enumerable: true,
+	get: function() {
+		return READ_ONLY_FORMAT_NODES;
+	}
+});
+Object.defineProperty(exports, "RECONSTRUCTORS", {
+	enumerable: true,
+	get: function() {
+		return RECONSTRUCTORS;
+	}
+});
+Object.defineProperty(exports, "THROUGH_PDF_EDGE_COST", {
+	enumerable: true,
+	get: function() {
+		return THROUGH_PDF_EDGE_COST;
+	}
+});
+Object.defineProperty(exports, "TRANSFORMS", {
+	enumerable: true,
+	get: function() {
+		return TRANSFORMS;
+	}
+});
+Object.defineProperty(exports, "buildCompositionGraph", {
+	enumerable: true,
+	get: function() {
+		return buildCompositionGraph;
+	}
+});
+Object.defineProperty(exports, "convertDocumentFromPdf", {
+	enumerable: true,
+	get: function() {
+		return convertDocumentFromPdf;
+	}
+});
+Object.defineProperty(exports, "executeBridge", {
+	enumerable: true,
+	get: function() {
+		return executeBridge;
+	}
+});
+Object.defineProperty(exports, "executeFromPdf", {
+	enumerable: true,
+	get: function() {
+		return executeFromPdf;
+	}
+});
+Object.defineProperty(exports, "isContentFormat", {
+	enumerable: true,
+	get: function() {
+		return isContentFormat;
+	}
+});
+Object.defineProperty(exports, "isReadOnlyContentFormat", {
+	enumerable: true,
+	get: function() {
+		return isReadOnlyContentFormat;
+	}
+});
+Object.defineProperty(exports, "isSourceContentFormat", {
+	enumerable: true,
+	get: function() {
+		return isSourceContentFormat;
+	}
+});
+Object.defineProperty(exports, "isTextFormatNode", {
+	enumerable: true,
+	get: function() {
+		return isTextFormatNode;
+	}
+});
+Object.defineProperty(exports, "resolveCompositionPlan", {
+	enumerable: true,
+	get: function() {
+		return resolveCompositionPlan;
+	}
+});
+Object.defineProperty(exports, "runCompositionPlan", {
+	enumerable: true,
+	get: function() {
+		return runCompositionPlan;
+	}
+});
+Object.defineProperty(exports, "shortestPath", {
+	enumerable: true,
+	get: function() {
+		return shortestPath;
+	}
+});