documents.js 1.97.10 → 1.98.0

package/dist/convert/convert.js

@@ -1,237 +1,43 @@
 import { flipY } from "../model/geometry.js";
 import { resolveMetadataTimestamps } from "../model/metadata.js";
-import { openDocx } from "../edit/docx/editor.js";
 import { buildDocxPackage } from "../edit/docx/content.js";
-import { openPptx } from "../edit/pptx/editor.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 { 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 "./variant-bridges.js";
-import { buildXlsxPackage, decodePackage, encodePackage, readXlsxContent } from "ooxml.js";
+import { convertDocument } from "./composition.js";
+import { buildXlsxPackage, encodePackage } 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 { createFontMeasurer, createFontRegistry, loadMathFont, readPdf, writePdf } from "pdf-codec";
+import { createFontMeasurer, createFontRegistry, loadMathFont, writePdf } from "pdf-codec";
 //#region src/convert/convert.ts
 const mathMetricsAt = (sizePt) => loadMathFont().metricsAt(sizePt);
 function docxToPdf(bytes, options) {
-	const pkg = openDocx(bytes).toPackage();
-	const read = readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic });
-	if (read.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "docx",
-		package: pkg
-	}, options);
-	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
-	});
+	return convertDocument("docx", "pdf", bytes, options);
 }
 function odtToPdf(bytes, options) {
-	const pkg = decodePackage$1(bytes);
-	const read = readOdtContent(pkg);
-	if (read.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "odf",
-		package: pkg
-	}, options);
-	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
-	});
+	return convertDocument("odt", "pdf", bytes, options);
 }
 function pptxToPdf(bytes, options) {
-	const pkg = openPptx(bytes).toPackage();
-	const read = readPptxContent(pkg);
-	if (read.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "pptx",
-		package: pkg
-	}, options);
-	const { document: layout, formulas } = convertPresentationToLayout(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
-	});
+	return convertDocument("pptx", "pdf", bytes, options);
 }
 function odpToPdf(bytes, options) {
-	const pkg = decodePackage$1(bytes);
-	const read = readOdpContent(pkg);
-	if (read.kind !== "presentation") throw new Error("readOdpContent returned a non-presentation ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "odf",
-		package: pkg
-	}, options);
-	const { document: layout, formulas } = convertPresentationToLayout(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
-	});
+	return convertDocument("odp", "pdf", bytes, options);
 }
 function odsToPdf(bytes, options) {
-	const pkg = decodePackage$1(bytes);
-	const read = readOdsContent(pkg);
-	if (read.kind !== "spreadsheet") throw new Error("readOdsContent returned a non-spreadsheet ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "odf",
-		package: pkg
-	}, options);
-	const { document: layout, formulas } = convertSpreadsheetToLayout(content, {
-		measurer: createFontMeasurer(fonts),
-		mathMetricsAt,
-		signal: options?.signal
-	});
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		formulas,
-		fonts
-	});
+	return convertDocument("ods", "pdf", bytes, options);
 }
 function odgToPdf(bytes, options) {
-	const pkg = decodePackage$1(bytes);
-	const read = readOdgContent(pkg);
-	if (read.kind !== "drawing") throw new Error("readOdgContent returned a non-drawing ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	const fonts = createDocumentFontRegistry({
-		kind: "odf",
-		package: pkg
-	}, options);
-	const layout = convertDrawingToLayout(content, { measurer: createFontMeasurer(fonts) });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return writePdf(layout, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		fonts
-	});
+	return convertDocument("odg", "pdf", bytes, options);
 }
 function markdownToPdf(bytes, options) {
-	throwIfAborted(options?.signal);
-	const text = decodeMarkdownText(bytes);
-	const read = readMarkdownContent(text, {
-		signal: options?.signal,
-		images: options?.images
-	});
-	if (read.kind !== "wordprocessing") throw new Error("readMarkdownContent returned a non-wordprocessing ContentDocument");
-	const content = {
-		...read,
-		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
-	};
-	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
-	});
+	return convertDocument("markdown", "pdf", bytes, options);
 }
 const STANDALONE_FORMULA_SIZE_PT = 18;
 const STANDALONE_FORMULA_MARGIN_PT = 72;
@@ -283,332 +89,79 @@ function odfToPdf(bytes, options) {
 	});
 }
 function pdfToDocx(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructWordprocessing(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage(buildDocxPackage(content));
+	return convertDocument("pdf", "docx", bytes, options);
 }
 function pdfToPptx(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructPresentation(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage(buildPptxPackage(content));
+	return convertDocument("pdf", "pptx", bytes, options);
 }
 function pdfToOdt(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructWordprocessing(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage$1(buildOdtPackage(content));
+	return convertDocument("pdf", "odt", bytes, options);
 }
 function pdfToOdp(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructPresentation(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage$1(buildOdpPackage(content));
+	return convertDocument("pdf", "odp", bytes, options);
 }
 function pdfToOdg(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructDrawing(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage$1(buildOdgPackage(content));
+	return convertDocument("pdf", "odg", bytes, options);
 }
 function pdfToOds(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructSpreadsheet(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	return encodePackage$1(buildOdsPackage(content));
+	return convertDocument("pdf", "ods", bytes, options);
 }
 function pdfToMarkdown(bytes, options) {
-	const layout = readPdf(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	const content = reconstructWordprocessing(layout, { signal: options?.signal });
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content,
-		layout
-	});
-	const text = buildMarkdownText(content);
-	return encodeMarkdownText(text);
+	return convertDocument("pdf", "markdown", bytes, options);
 }
 function odtToDocx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdtContent(pkg);
-	if (content.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage(buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }));
+	return convertDocument("odt", "docx", bytes, options);
 }
 function docxToOdt(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage(bytes);
-	const content = readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic });
-	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage$1(buildOdtPackage(content));
+	return convertDocument("docx", "odt", bytes, options);
 }
 function odpToPptx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdpContent(pkg);
-	if (content.kind !== "presentation") throw new Error("readOdpContent returned a non-presentation ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage(buildPptxPackage(content));
+	return convertDocument("odp", "pptx", bytes, options);
 }
 function pptxToOdp(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage(bytes);
-	const content = readPptxContent(pkg);
-	if (content.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage$1(buildOdpPackage(content));
+	return convertDocument("pptx", "odp", bytes, options);
 }
 function odsToXlsx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdsContent(pkg);
-	if (content.kind !== "spreadsheet") throw new Error("readOdsContent returned a non-spreadsheet ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage(buildXlsxPackage(content));
+	return convertDocument("ods", "xlsx", bytes, options);
 }
 function xlsxToOds(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage(bytes);
-	const content = readXlsxContent(pkg);
-	if (content.kind !== "spreadsheet") throw new Error("readXlsxContent returned a non-spreadsheet ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage$1(buildOdsPackage(content));
+	return convertDocument("xlsx", "ods", bytes, options);
 }
 function markdownToDocx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const text = decodeMarkdownText(bytes);
-	const content = readMarkdownContent(text, {
-		signal: options?.signal,
-		images: options?.images
-	});
-	if (content.kind !== "wordprocessing") throw new Error("readMarkdownContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage(buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }));
+	return convertDocument("markdown", "docx", bytes, options);
 }
 function docxToMarkdown(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage(bytes);
-	const content = readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic });
-	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	const text = buildMarkdownText(content);
-	return encodeMarkdownText(text);
+	return convertDocument("docx", "markdown", bytes, options);
 }
 function markdownToOdt(bytes, options) {
-	throwIfAborted(options?.signal);
-	const text = decodeMarkdownText(bytes);
-	const content = readMarkdownContent(text, {
-		signal: options?.signal,
-		images: options?.images
-	});
-	if (content.kind !== "wordprocessing") throw new Error("readMarkdownContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	return encodePackage$1(buildOdtPackage(content));
+	return convertDocument("markdown", "odt", bytes, options);
 }
 function odtToMarkdown(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdtContent(pkg);
-	if (content.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content
-	});
-	const text = buildMarkdownText(content);
-	return encodeMarkdownText(text);
+	return convertDocument("odt", "markdown", bytes, options);
 }
 function docxToPptx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const content = readDocxContent(decodePackage$1(bytes));
-	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
-	const presentation = wordprocessingToPresentation(content);
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content: presentation
-	});
-	return encodePackage(buildPptxPackage(presentation));
+	return convertDocument("docx", "pptx", bytes, options);
 }
 function pptxToDocx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const content = readPptxContent(decodePackage$1(bytes));
-	if (content.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
-	const wordprocessing = presentationToWordprocessing(content);
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content: wordprocessing
-	});
-	return encodePackage(buildDocxPackage(wordprocessing, { onMathDiagnostic: options?.onMathDiagnostic }));
+	return convertDocument("pptx", "docx", bytes, options);
 }
 function odtToOdp(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdtContent(pkg);
-	if (content.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
-	const presentation = wordprocessingToPresentation(content);
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content: presentation
-	});
-	return encodePackage(buildOdpPackage(presentation));
+	return convertDocument("odt", "odp", bytes, options);
 }
 function odpToOdt(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pkg = decodePackage$1(bytes);
-	const content = readOdpContent(pkg);
-	if (content.kind !== "presentation") throw new Error("readOdpContent returned a non-presentation ContentDocument");
-	const wordprocessing = presentationToWordprocessing(content);
-	throwIfAborted(options?.signal);
-	options?.onDocument?.({
-		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
-		content: wordprocessing
-	});
-	return encodePackage(buildOdtPackage(wordprocessing));
+	return convertDocument("odp", "odt", bytes, options);
 }
 function xlsxToPdf(bytes, options) {
-	throwIfAborted(options?.signal);
-	const odsBytes = xlsxToOds(bytes, { signal: options?.signal });
-	throwIfAborted(options?.signal);
-	return odsToPdf(odsBytes, {
-		signal: options?.signal,
-		onSubstitution: options?.onSubstitution,
-		onDocument: options?.onDocument,
-		fonts: options?.fonts,
-		onFontSubstitution: options?.onFontSubstitution,
-		clock: options?.clock
-	});
+	return convertDocument("xlsx", "pdf", bytes, options);
 }
 function pdfToXlsx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const odsBytes = pdfToOds(bytes, {
-		signal: options?.signal,
-		sink: options?.sink
-	});
-	throwIfAborted(options?.signal);
-	return odsToXlsx(odsBytes, {
-		signal: options?.signal,
-		onDocument: options?.onDocument
-	});
+	return convertDocument("pdf", "xlsx", bytes, options);
 }
 function xlsxToMarkdown(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pdfBytes = xlsxToPdf(bytes, {
-		signal: options?.signal,
-		fonts: options?.fonts,
-		onFontSubstitution: options?.onFontSubstitution,
-		onSubstitution: options?.onSubstitution,
-		clock: options?.clock
-	});
-	throwIfAborted(options?.signal);
-	return pdfToMarkdown(pdfBytes, {
-		signal: options?.signal,
-		sink: options?.sink,
-		onDocument: options?.onDocument
-	});
+	return convertDocument("xlsx", "markdown", bytes, options);
 }
 function markdownToXlsx(bytes, options) {
-	throwIfAborted(options?.signal);
-	const pdfBytes = markdownToPdf(bytes, {
-		signal: options?.signal,
-		fonts: options?.fonts,
-		onFontSubstitution: options?.onFontSubstitution,
-		onSubstitution: options?.onSubstitution,
-		clock: options?.clock,
-		images: options?.images
-	});
-	throwIfAborted(options?.signal);
-	return pdfToXlsx(pdfBytes, {
-		signal: options?.signal,
-		sink: options?.sink,
-		onDocument: options?.onDocument
-	});
+	return convertDocument("markdown", "xlsx", bytes, options);
 }
 var OdmUnresolvedSectionError = class extends Error {
 	hrefs;