documents.js 1.57.1 → 1.59.0

package/dist/convert/convert.js

@@ -0,0 +1,441 @@
+import "../model/content.js";
+import { PAGE_SIZE_A4, flipY } from "../model/geometry.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 { 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 { 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 { buildXlsxPackage, decodePackage, encodePackage, readXlsxContent } from "ooxml.js";
+import { COLOR_BLACK, DOCUMENT_PACKAGE_FORMAT_VERSION, LAYOUT_FORMAT_VERSION } from "document-schema.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1, readOdfMetadata, readOdfParagraph, readOdfTable, readOdm } from "odf.js";
+import { createStandardFontMeasurer, loadMathFont, readPdf, writePdf } from "pdf-codec";
+//#region src/convert/convert.ts
+function docxToPdf(bytes, options) {
+	const pkg = openDocx(bytes).toPackage();
+	const content = readDocxContent(pkg);
+	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
+	const { document: layout, formulas } = convertWordprocessingToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas
+	});
+}
+function odtToPdf(bytes, options) {
+	const pkg = decodePackage$1(bytes);
+	const content = readOdtContent(pkg);
+	if (content.document.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
+	const { document: layout, formulas } = convertWordprocessingToLayout(content.document, {
+		measurer: createStandardFontMeasurer(),
+		formulas: content.formulas
+	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content: content.document,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas
+	});
+}
+function pptxToPdf(bytes, options) {
+	const pkg = openPptx(bytes).toPackage();
+	const content = readPptxContent(pkg);
+	if (content.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
+	const { document: layout } = convertPresentationToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution
+	});
+}
+function odpToPdf(bytes, options) {
+	const pkg = decodePackage$1(bytes);
+	const content = readOdpContent(pkg);
+	if (content.document.kind !== "presentation") throw new Error("readOdpContent returned a non-presentation ContentDocument");
+	const { document: layout, formulas } = convertPresentationToLayout(content.document, {
+		measurer: createStandardFontMeasurer(),
+		formulas: content.formulas
+	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content: content.document,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas
+	});
+}
+function odsToPdf(bytes, options) {
+	const pkg = decodePackage$1(bytes);
+	const content = readOdsContent(pkg);
+	if (content.kind !== "spreadsheet") throw new Error("readOdsContent returned a non-spreadsheet ContentDocument");
+	const layout = convertSpreadsheetToLayout(content, {
+		measurer: createStandardFontMeasurer(),
+		signal: options?.signal
+	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution
+	});
+}
+function odgToPdf(bytes, options) {
+	const pkg = decodePackage$1(bytes);
+	const content = readOdgContent(pkg);
+	if (content.kind !== "drawing") throw new Error("readOdgContent returned a non-drawing ContentDocument");
+	const layout = convertDrawingToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution
+	});
+}
+const STANDALONE_FORMULA_SIZE_PT = 18;
+const STANDALONE_FORMULA_MARGIN_PT = 72;
+function odfToPdf(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const formula = readOdfFormulaContent(pkg);
+	const metrics = loadMathFont().metricsAt(STANDALONE_FORMULA_SIZE_PT);
+	const { box } = layoutFormula(formula.mathml, {
+		metrics,
+		sizePt: STANDALONE_FORMULA_SIZE_PT,
+		color: COLOR_BLACK
+	});
+	const flipped = flipY({
+		xPt: STANDALONE_FORMULA_MARGIN_PT,
+		yPt: STANDALONE_FORMULA_MARGIN_PT,
+		widthPt: box.widthPt,
+		heightPt: box.heightPt
+	}, PAGE_SIZE_A4.heightPt);
+	const layout = {
+		formatVersion: LAYOUT_FORMAT_VERSION,
+		metadata: formula.metadata,
+		pages: [{
+			widthPt: PAGE_SIZE_A4.widthPt,
+			heightPt: PAGE_SIZE_A4.heightPt,
+			items: []
+		}],
+		images: {}
+	};
+	throwIfAborted(options?.signal);
+	return writePdf(layout, {
+		signal: options?.signal,
+		formulas: [{
+			pageIndex: 0,
+			xPt: flipped.xPt,
+			yPt: flipped.yPt,
+			box
+		}]
+	});
+}
+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));
+}
+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));
+}
+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));
+}
+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));
+}
+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));
+}
+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));
+}
+function odtToDocx(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const content = readOdtContent(pkg).document;
+	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));
+}
+function docxToOdt(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage(bytes);
+	const content = readDocxContent(pkg);
+	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));
+}
+function odpToPptx(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const content = readOdpContent(pkg).document;
+	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));
+}
+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));
+}
+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));
+}
+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));
+}
+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
+	});
+}
+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
+	});
+}
+var OdmUnresolvedSectionError = class extends Error {
+	hrefs;
+	constructor(hrefs) {
+		super(`odmToPdf: ${hrefs.length} chapter section(s) could not be resolved -- no inline content and no resolveSubDocument result for: ${hrefs.join(", ")}`);
+		this.name = "OdmUnresolvedSectionError";
+		this.hrefs = hrefs;
+	}
+};
+const INLINE_SECTION_MARGIN_PT = 56.69291338582677;
+const INLINE_SECTION_MARGINS = {
+	topPt: INLINE_SECTION_MARGIN_PT,
+	rightPt: INLINE_SECTION_MARGIN_PT,
+	bottomPt: INLINE_SECTION_MARGIN_PT,
+	leftPt: INLINE_SECTION_MARGIN_PT
+};
+function inlineOdmSectionToContentSection(section, pkg) {
+	const blocks = [];
+	for (const node of section.inlineContent ?? []) {
+		if (node.type !== "element") continue;
+		if (node.tag === "text:p" || node.tag === "text:h") blocks.push(readOdfParagraph(node, pkg));
+		else if (node.tag === "table:table") blocks.push(readOdfTable(node, pkg));
+	}
+	return {
+		pageSize: PAGE_SIZE_A4,
+		margins: INLINE_SECTION_MARGINS,
+		blocks
+	};
+}
+function withLeadingChapterBreak(section) {
+	const pageBreak = { kind: "pageBreak" };
+	return {
+		...section,
+		blocks: [pageBreak, ...section.blocks]
+	};
+}
+function odmToPdf(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const odm = readOdm(pkg);
+	const unresolvedHrefs = [];
+	const chapterSections = [];
+	for (const section of odm.sections) {
+		throwIfAborted(options?.signal);
+		if (section.inlineContent !== void 0) {
+			chapterSections.push([inlineOdmSectionToContentSection(section, pkg)]);
+			continue;
+		}
+		const chapterBytes = options?.resolveSubDocument?.(section.href);
+		if (chapterBytes === void 0) {
+			unresolvedHrefs.push(section.href);
+			continue;
+		}
+		const chapterPkg = decodePackage$1(chapterBytes);
+		const chapterContent = readOdtContent(chapterPkg).document;
+		if (chapterContent.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
+		chapterSections.push(chapterContent.sections);
+	}
+	if (unresolvedHrefs.length > 0) throw new OdmUnresolvedSectionError(unresolvedHrefs);
+	const combinedSections = [];
+	chapterSections.forEach((sections, chapterIndex) => {
+		if (chapterIndex === 0) {
+			combinedSections.push(...sections);
+			return;
+		}
+		combinedSections.push(...sections.map((section, sectionIndex) => sectionIndex === 0 ? withLeadingChapterBreak(section) : section));
+	});
+	throwIfAborted(options?.signal);
+	const content = {
+		kind: "wordprocessing",
+		formatVersion: 1,
+		metadata: readOdfMetadata(pkg),
+		sections: combinedSections
+	};
+	const { document: layout } = convertWordprocessingToLayout(content, { measurer: createStandardFontMeasurer() });
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution
+	});
+}
+function odbToXlsx(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const tables = readOdbTables(pkg);
+	throwIfAborted(options?.signal);
+	const content = odbTablesToSpreadsheetDocument(tables);
+	return encodePackage(buildXlsxPackage(content));
+}
+function odbToCsv(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const tables = readOdbTables(pkg);
+	throwIfAborted(options?.signal);
+	return buildOdbTableCsv(tables, options?.table);
+}
+//#endregion
+export { OdmUnresolvedSectionError, docxToOdt, docxToPdf, inlineOdmSectionToContentSection, odbToCsv, odbToXlsx, odfToPdf, odgToPdf, odmToPdf, odpToPdf, odpToPptx, odsToPdf, odsToXlsx, odtToDocx, odtToPdf, pdfToDocx, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pdfToXlsx, pptxToOdp, pptxToPdf, xlsxToOds, xlsxToPdf };

package/dist/convert/local.cjs

@@ -0,0 +1,84 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_convert_capability = require("./capability.cjs");
+//#region src/convert/local.ts
+const SUPPORTED_CONVERSIONS = require_convert_capability.DIRECT_EDGES.map((edge) => ({
+	source: edge.source,
+	target: edge.target
+}));
+function substitutionDiagnostic(substitution, context) {
+	return {
+		severity: "info",
+		code: "char/substituted",
+		message: `"${substitution.from}" is not representable in a standard-14 font; substituted "${substitution.to}"`,
+		pageIndex: context.pageIndex
+	};
+}
+function fromPdfDiagnostic(diagnostic) {
+	return {
+		severity: diagnostic.severity,
+		code: diagnostic.code,
+		message: diagnostic.message,
+		pageIndex: diagnostic.pageIndex
+	};
+}
+function createLocalDocumentConverter() {
+	return {
+		contractVersion: 2,
+		conversions: SUPPORTED_CONVERSIONS,
+		convert(request, options) {
+			const { source, targetFormat } = request;
+			const diagnostics = [];
+			let documentPackage;
+			const onDocument = (pkg) => {
+				documentPackage = pkg;
+			};
+			const strategy = require_convert_capability.resolveConversionPath(source.format, targetFormat);
+			if (strategy?.kind !== "direct") return Promise.reject(/* @__PURE__ */ new Error(`unsupported conversion: ${source.format} -> ${targetFormat}`));
+			const edge = strategy.edge;
+			if (edge.kind === "toPdf") {
+				const bytes = edge.convert(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: edge.target,
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (edge.kind === "fromPdf") {
+				const bytes = edge.convert(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: edge.target,
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			const bytes = edge.convert(source.bytes, {
+				signal: options.signal,
+				onDocument
+			});
+			return Promise.resolve({
+				document: {
+					format: edge.target,
+					bytes
+				},
+				diagnostics,
+				package: documentPackage
+			});
+		}
+	};
+}
+//#endregion
+exports.createLocalDocumentConverter = createLocalDocumentConverter;

package/dist/convert/local.d.cts

@@ -0,0 +1,5 @@
+import { DocumentConverter } from "./port.cjs";
+//#region src/convert/local.d.ts
+declare function createLocalDocumentConverter(): DocumentConverter;
+//#endregion
+export { createLocalDocumentConverter };

package/dist/convert/local.d.ts

@@ -0,0 +1,5 @@
+import { DocumentConverter } from "./port.js";
+//#region src/convert/local.d.ts
+declare function createLocalDocumentConverter(): DocumentConverter;
+//#endregion
+export { createLocalDocumentConverter };

package/dist/convert/local.js

@@ -0,0 +1,83 @@
+import { DIRECT_EDGES, resolveConversionPath } from "./capability.js";
+//#region src/convert/local.ts
+const SUPPORTED_CONVERSIONS = DIRECT_EDGES.map((edge) => ({
+	source: edge.source,
+	target: edge.target
+}));
+function substitutionDiagnostic(substitution, context) {
+	return {
+		severity: "info",
+		code: "char/substituted",
+		message: `"${substitution.from}" is not representable in a standard-14 font; substituted "${substitution.to}"`,
+		pageIndex: context.pageIndex
+	};
+}
+function fromPdfDiagnostic(diagnostic) {
+	return {
+		severity: diagnostic.severity,
+		code: diagnostic.code,
+		message: diagnostic.message,
+		pageIndex: diagnostic.pageIndex
+	};
+}
+function createLocalDocumentConverter() {
+	return {
+		contractVersion: 2,
+		conversions: SUPPORTED_CONVERSIONS,
+		convert(request, options) {
+			const { source, targetFormat } = request;
+			const diagnostics = [];
+			let documentPackage;
+			const onDocument = (pkg) => {
+				documentPackage = pkg;
+			};
+			const strategy = resolveConversionPath(source.format, targetFormat);
+			if (strategy?.kind !== "direct") return Promise.reject(/* @__PURE__ */ new Error(`unsupported conversion: ${source.format} -> ${targetFormat}`));
+			const edge = strategy.edge;
+			if (edge.kind === "toPdf") {
+				const bytes = edge.convert(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: edge.target,
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (edge.kind === "fromPdf") {
+				const bytes = edge.convert(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: edge.target,
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			const bytes = edge.convert(source.bytes, {
+				signal: options.signal,
+				onDocument
+			});
+			return Promise.resolve({
+				document: {
+					format: edge.target,
+					bytes
+				},
+				diagnostics,
+				package: documentPackage
+			});
+		}
+	};
+}
+//#endregion
+export { createLocalDocumentConverter };

package/dist/convert/port.d.cts

@@ -0,0 +1,34 @@
+import { DocumentPackage } from "document-schema.js";
+//#region src/convert/port.d.ts
+type DocumentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'odf' | 'pdf';
+interface DocumentPayload {
+  readonly format: DocumentFormat;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+interface Diagnostic {
+  readonly severity: 'info' | 'warning';
+  readonly code: string;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+interface ConversionRequest {
+  readonly source: DocumentPayload;
+  readonly targetFormat: DocumentFormat;
+}
+interface ConversionResult {
+  readonly document: DocumentPayload;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly package?: DocumentPackage;
+}
+interface DocumentConverter {
+  readonly contractVersion: number;
+  readonly conversions: readonly {
+    readonly source: DocumentFormat;
+    readonly target: DocumentFormat;
+  }[];
+  convert(request: ConversionRequest, options: {
+    readonly signal: AbortSignal;
+  }): Promise<ConversionResult>;
+}
+//#endregion
+export { ConversionRequest, ConversionResult, Diagnostic, DocumentConverter, DocumentFormat, DocumentPayload };

package/dist/convert/port.d.ts

@@ -0,0 +1,34 @@
+import { DocumentPackage } from "document-schema.js";
+//#region src/convert/port.d.ts
+type DocumentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'odf' | 'pdf';
+interface DocumentPayload {
+  readonly format: DocumentFormat;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+interface Diagnostic {
+  readonly severity: 'info' | 'warning';
+  readonly code: string;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+interface ConversionRequest {
+  readonly source: DocumentPayload;
+  readonly targetFormat: DocumentFormat;
+}
+interface ConversionResult {
+  readonly document: DocumentPayload;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly package?: DocumentPackage;
+}
+interface DocumentConverter {
+  readonly contractVersion: number;
+  readonly conversions: readonly {
+    readonly source: DocumentFormat;
+    readonly target: DocumentFormat;
+  }[];
+  convert(request: ConversionRequest, options: {
+    readonly signal: AbortSignal;
+  }): Promise<ConversionResult>;
+}
+//#endregion
+export { ConversionRequest, ConversionResult, Diagnostic, DocumentConverter, DocumentFormat, DocumentPayload };