document-cli 1.2.11 → 1.4.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { OdbNoEmbeddedDataSourceError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, buildDocxPackage, buildMarkdownText, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, createLocalDocumentConverter, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, odbToCsv, odbToXlsx, odmToPdf, readOdbForms, readOdbReports, readOdbTables, readPdf, writePdf } from "documents.js";
+import { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError, OdbNoEmbeddedDataSourceError, OdbReportNotSpecifiedError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, buildDocxPackage, buildMarkdownText, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, convertWordprocessingToLayout, createFontMeasurer, createFontRegistry, createLocalDocumentConverter, decodePackage, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, evaluateSelect, extractSourceFonts, hsqldbCellDisplayText, layoutDocumentWithSchema, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, writePdf } from "documents.js";
 import { basename, dirname, extname, join } from "node:path";
 import { Command, InvalidArgumentError } from "commander";
-import { decodePackage, encodePackage as encodePackage$1 } from "odf.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/format.ts
 const EXTENSION_TO_FORMAT = {
@@ -161,7 +161,8 @@ const EXIT_INTERRUPTED = 130;
 function mapErrorToExit(error, abortReason) {
 	if (abortReason === "interrupt") return 130;
 	if (abortReason === "timeout") return 124;
-	if (error instanceof OdmUnresolvedSectionError || error instanceof OdbTableNotSpecifiedError || error instanceof OdbTableNotFoundError || error instanceof OdbNoEmbeddedDataSourceError || error instanceof OdbUnsupportedFormatError) return 3;
+	if (error instanceof OdmUnresolvedSectionError || error instanceof OdbTableNotSpecifiedError || error instanceof OdbTableNotFoundError || error instanceof OdbNoEmbeddedDataSourceError || error instanceof OdbUnsupportedFormatError || error instanceof OdbReportNotSpecifiedError) return 3;
+	if (error instanceof HsqldbSqlUnsupportedError || error instanceof HsqldbSqlParseError || error instanceof HsqldbSqlEvaluationError) return 1;
 	if (error instanceof PdfEncryptedError || error instanceof PdfParseError) return 1;
 	return 1;
 }
@@ -531,8 +532,158 @@ function registerConversionCommands(program) {
 	});
 }
 //#endregion
+//#region src/docx-extras-format.ts
+const INDENT$1 = "  ";
+function indent$1(depth) {
+	return INDENT$1.repeat(depth);
+}
+function commentLine(comment, position) {
+	const author = comment.author ?? "(no author)";
+	return `${indent$1(1)}[${position}] ${author}: ${comment.text}`;
+}
+function footnoteLine(footnote, position) {
+	const typeSuffix = footnote.type === void 0 ? "" : ` (${footnote.type})`;
+	return `${indent$1(1)}[${position}]${typeSuffix} ${footnote.text}`;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return [];
+	return ["comments", ...comments.map((comment, index) => commentLine(comment, index + 1))];
+}
+function footnotesSection(footnotes) {
+	if (footnotes.length === 0) return [];
+	return ["footnotes", ...footnotes.map((footnote, index) => footnoteLine(footnote, index + 1))];
+}
+function headerOrFooterSection(label, values) {
+	if (values.length === 0) return [];
+	return [label, ...values.map((text, index) => `${indent$1(1)}[${index + 1}] ${text}`)];
+}
+function numberingLevelLine(ilvl, level) {
+	const restartSuffix = level.restart === void 0 ? "" : `, restarts at level ${level.restart}`;
+	return `${indent$1(2)}level ${ilvl}: ${level.format} ${JSON.stringify(level.text)} starting at ${level.startAt}${restartSuffix}`;
+}
+function numberingSection(numbering) {
+	const numIds = Object.keys(numbering);
+	if (numIds.length === 0) return [];
+	const lines = ["numbering"];
+	for (const numId of numIds) {
+		const definition = numbering[numId];
+		if (definition === void 0) continue;
+		lines.push(`${indent$1(1)}numId ${numId}`);
+		const ilvls = Object.keys(definition.levels).sort((a, b) => Number(a) - Number(b));
+		for (const ilvl of ilvls) {
+			const level = definition.levels[ilvl];
+			if (level === void 0) continue;
+			lines.push(numberingLevelLine(ilvl, level));
+		}
+	}
+	return lines;
+}
+function formatDocxExtrasLines(extras) {
+	const nonEmptySections = [
+		commentsSection(extras.comments),
+		footnotesSection(extras.footnotes),
+		headerOrFooterSection("headers", extras.headers),
+		headerOrFooterSection("footers", extras.footers),
+		numberingSection(extras.numbering)
+	].filter((section) => section.length > 0);
+	if (nonEmptySections.length === 0) return ["This document carries no comments, footnotes, headers, footers, or numbering definitions."];
+	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
+}
+//#endregion
+//#region src/commands/docx-extras.ts
+async function runDocxExtras(input, options) {
+	const command = "docx-extras";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const extras = readDocxExtras(pkg);
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(extras)}\n`);
+			return 0;
+		}
+		for (const line of formatDocxExtrasLines(extras)) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		process.stderr.write(`[${command}] ${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerDocxExtrasCommand(program) {
+	program.command("docx-extras <input>").description("print a docx's own comments, footnotes, headers, footers, and numbering definitions -- data readDocxContent's ContentDocument cannot carry").option("--json", "emit the raw DocxExtras object as JSON instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runDocxExtras(input, options);
+	});
+}
+//#endregion
+//#region src/commands/fonts.ts
+const FONT_SOURCE_FORMATS = {
+	docx: true,
+	pptx: true,
+	odt: true,
+	odp: true,
+	ods: true,
+	odg: true
+};
+function isFontSourceFormat(format) {
+	return format in FONT_SOURCE_FORMATS;
+}
+function resolveFontSourcePackage(format, bytes) {
+	if (format === "docx" || format === "pptx") return {
+		kind: format,
+		package: decodePackage(bytes)
+	};
+	return {
+		kind: "odf",
+		package: decodePackage$1(bytes)
+	};
+}
+async function runFonts(input, options) {
+	const command = "fonts";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const format = inferFormatFromExtension(input);
+		if (format === void 0) {
+			process.stderr.write(`[${command}] cannot infer a document format from '${input}'; expected one of docx, pptx, odt, odp, ods, odg\n`);
+			return 2;
+		}
+		if (!isFontSourceFormat(format)) {
+			process.stderr.write(`[${command}] '${format}' documents carry no source-embedded font faces this command can extract; expected one of docx, pptx, odt, odp, ods, odg\n`);
+			return 2;
+		}
+		const inputBytes = await readInput(input, { signal });
+		const source = resolveFontSourcePackage(format, new Uint8Array(inputBytes));
+		const summaries = extractSourceFonts(source).map((face) => ({
+			family: face.family,
+			bold: face.bold,
+			italic: face.italic,
+			byteLength: face.bytes.length
+		}));
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(summaries)}\n`);
+			return 0;
+		}
+		if (summaries.length === 0) {
+			process.stdout.write("This document embeds no source fonts.\n");
+			return 0;
+		}
+		for (const face of summaries) {
+			const style = [face.bold ? "bold" : void 0, face.italic ? "italic" : void 0].filter((value) => value !== void 0).join(" ");
+			process.stdout.write(`${face.family}${style === "" ? "" : ` (${style})`} -- ${face.byteLength} bytes\n`);
+		}
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerFontsCommand(program) {
+	program.command("fonts <input>").description("list every source-embedded font face a docx/pptx/odt/odp/ods/odg document carries (family, weight/style, byte length)").option("--json", "emit the face list as a JSON array instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runFonts(input, options);
+	});
+}
+//#endregion
 //#region src/commands/formats.ts
-const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package";
+const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package, fonts, docx-extras";
 function registerFormatsCommand(program) {
 	program.command("formats").description("list every source -> target conversion this CLI supports via a <source>-to-<target> command").option("--json", "emit the conversion list as a JSON array instead of a human-readable table", false).action((options) => {
 		const { conversions } = createLocalDocumentConverter();
@@ -757,6 +908,27 @@ function formatOdbReportLines(report) {
 	return lines;
 }
 //#endregion
+//#region src/sql-result-format.ts
+const COLUMN_GAP = "  ";
+function columnWidths(columns, cells) {
+	return columns.map((column, index) => {
+		const cellWidths = cells.map((row) => row[index]?.length ?? 0);
+		return Math.max(column.length, ...cellWidths);
+	});
+}
+function formatRow(values, widths) {
+	return values.map((value, index) => value.padEnd(widths[index] ?? value.length)).join(COLUMN_GAP).trimEnd();
+}
+function formatSqlResultSetTable(result) {
+	const { columns, rows } = result;
+	const cells = rows.map((row) => row.map((value) => hsqldbCellDisplayText(value)));
+	const widths = columnWidths(columns, cells);
+	const lines = [formatRow(columns, widths), formatRow(widths.map((width) => "-".repeat(width)), widths)];
+	for (const row of cells) lines.push(formatRow(row, widths));
+	lines.push(`${rows.length} row${rows.length === 1 ? "" : "s"}`);
+	return lines;
+}
+//#endregion
 //#region src/commands/odb.ts
 function reportOdbError(command, error, verbose, abortReason) {
 	if (error instanceof OdbNoEmbeddedDataSourceError || error instanceof OdbUnsupportedFormatError) {
@@ -773,6 +945,13 @@ function reportOdbCsvError(command, error, verbose, abortReason) {
 	}
 	return reportOdbError(command, error, verbose, abortReason);
 }
+function reportOdbReportError(command, error, verbose, abortReason) {
+	if (error instanceof OdbReportNotSpecifiedError) {
+		process.stderr.write(`[${command}] ${error.message}\nrun 'odb-reports' first to see the available reports\n`);
+		return mapErrorToExit(error, abortReason);
+	}
+	return reportOdbError(command, error, verbose, abortReason);
+}
 function resolveDefaultCsvOutputPath(inputPath) {
 	const directory = dirname(inputPath);
 	const stem = basename(inputPath, extname(inputPath));
@@ -838,7 +1017,7 @@ async function runOdbTables(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
 		const tables = readOdbTables(pkg);
 		if (options.json) {
 			const summary = tables.map((table) => ({
@@ -858,12 +1037,54 @@ async function runOdbTables(input, options) {
 		return reportOdbError(command, error, false, getAbortReason());
 	}
 }
+function resolveQuerySql(pkg, options) {
+	if (options.sql !== void 0) return { sql: options.sql };
+	const queryName = options.query;
+	if (queryName === void 0) return { errorMessage: "pass --sql <text> or --query <savedName>" };
+	const inventory = readOdbInventory(pkg);
+	const saved = inventory.queries.find((candidate) => candidate.name === queryName);
+	if (saved === void 0) {
+		const available = inventory.queries.map((candidate) => candidate.name);
+		return { errorMessage: `this .odb declares no saved query named '${queryName}'${available.length === 0 ? "" : ` -- available: ${available.join(", ")}`}` };
+	}
+	return { sql: saved.command };
+}
+async function runOdbQuery(input, options) {
+	const command = "odb-query";
+	if (options.sql !== void 0 && options.query !== void 0) {
+		process.stderr.write(`[${command}] pass --sql or --query, not both\n`);
+		return 2;
+	}
+	if (options.sql === void 0 && options.query === void 0) {
+		process.stderr.write(`[${command}] pass --sql <text> or --query <savedName>\n`);
+		return 2;
+	}
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
+		const resolved = resolveQuerySql(pkg, options);
+		if ("errorMessage" in resolved) {
+			process.stderr.write(`[${command}] ${resolved.errorMessage}\n`);
+			return 2;
+		}
+		const result = evaluateSelect(parseSelect(resolved.sql), readOdbTables(pkg));
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(result)}\n`);
+			return 0;
+		}
+		for (const line of formatSqlResultSetTable(result)) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		return reportOdbError(command, error, false, getAbortReason());
+	}
+}
 async function runOdbForms(input, options) {
 	const command = "odb-forms";
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const forms = readOdbForms(decodePackage(new Uint8Array(inputBytes)));
+		const forms = readOdbForms(decodePackage$1(new Uint8Array(inputBytes)));
 		if (options.json) {
 			process.stdout.write(`${JSON.stringify(forms.map((form) => odbFormSummary(form)))}\n`);
 			return 0;
@@ -886,7 +1107,7 @@ async function runOdbReports(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const reports = readOdbReports(decodePackage(new Uint8Array(inputBytes)));
+		const reports = readOdbReports(decodePackage$1(new Uint8Array(inputBytes)));
 		if (options.json) {
 			process.stdout.write(`${JSON.stringify(reports)}\n`);
 			return 0;
@@ -904,6 +1125,93 @@ async function runOdbReports(input, options) {
 		return reportOdbError(command, error, false, getAbortReason());
 	}
 }
+const ODB_REPORT_TARGET_FORMATS = {
+	docx: true,
+	odt: true,
+	pdf: true
+};
+function isOdbReportTargetFormat(format) {
+	return format in ODB_REPORT_TARGET_FORMATS;
+}
+function renderOdbReportBytes(content, target, options) {
+	if (target === "docx") return encodePackage(buildDocxPackage(content));
+	if (target === "odt") return encodePackage$1(buildOdtPackage(content));
+	if (content.kind !== "wordprocessing") throw new Error("readOdbReportContent returned a non-wordprocessing ContentDocument");
+	const fonts = createFontRegistry({
+		fonts: options.fonts,
+		onSubstitution: (substitution) => {
+			if (options.reportFontSubstitution !== void 0) {
+				options.reportFontSubstitution(substitution);
+				return;
+			}
+			options.onDiagnosticCounted();
+			options.reporter.report(fontSubstitutionToDiagnostic(substitution));
+		}
+	});
+	const { document: layout, formulas } = convertWordprocessingToLayout(content, { measurer: createFontMeasurer(fonts) });
+	return writePdf(layout, {
+		signal: options.signal,
+		onSubstitution: (substitution, context) => {
+			options.onDiagnosticCounted();
+			options.reporter.report(substitutionToDiagnostic(substitution, context.pageIndex));
+		},
+		formulas,
+		fonts
+	});
+}
+async function runOdbRenderReport(input, output, options) {
+	const command = "odb-render-report";
+	if (output !== void 0 && options.out !== void 0 && output !== options.out) {
+		process.stderr.write(`[${command}] conflicting output destinations: positional '${output}' and --out '${options.out}'\n`);
+		return 2;
+	}
+	const target = resolveTargetFormat(output, options.out, options.to);
+	if ("errorMessage" in target) {
+		process.stderr.write(`[${command}] ${target.errorMessage}\n`);
+		return 2;
+	}
+	if (!isOdbReportTargetFormat(target.format)) {
+		process.stderr.write(`[${command}] '${target.format}' is not a supported report render target; expected one of docx, odt, pdf\n`);
+		return 2;
+	}
+	const targetFormat = target.format;
+	const resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, targetFormat));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	const reporter = createDiagnosticReporter({
+		json: options.json,
+		quiet: options.quiet,
+		command
+	});
+	let diagnosticCount = 0;
+	const reportFontSubstitution = options.reportFontSubstitutions === true ? createFontSubstitutionReporter({
+		json: options.json,
+		quiet: options.quiet,
+		command
+	}) : void 0;
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const fonts = await loadProvidedFonts(options.fontFile ?? [], { signal });
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
+		const bytes = renderOdbReportBytes(readOdbReportContent(pkg, { report: options.report }), targetFormat, {
+			fonts,
+			signal,
+			reporter,
+			reportFontSubstitution,
+			onDiagnosticCounted: () => {
+				diagnosticCount += 1;
+			}
+		});
+		await writeOutput(resolvedOutput, bytes);
+		reporter.summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount
+		});
+		return 0;
+	} catch (error) {
+		return reportOdbReportError(command, error, options.verbose, getAbortReason());
+	}
+}
 function registerOdbToXlsxCommand(program) {
 	const command = program.command("odb-to-xlsx <input> [output]").description("extract every table an embedded .odb database declares into one xlsx workbook, one sheet per table");
 	addOutOption(command);
@@ -942,12 +1250,33 @@ function registerOdbReportsCommand(program) {
 		process.exitCode = await runOdbReports(input, options);
 	});
 }
+function registerOdbQueryCommand(program) {
+	program.command("odb-query <input>").description("run a bounded SELECT over an embedded .odb database's own extracted tables, given directly or by naming one of its saved queries").option("--sql <text>", "the SELECT statement to run -- mutually exclusive with --query").option("--query <savedName>", "the name of one of the .odb's own saved queries to run -- mutually exclusive with --sql").option("--json", "emit the result set as JSON ({ columns, rows }) instead of a plain-text table", false).action(async (input, options) => {
+		process.exitCode = await runOdbQuery(input, options);
+	});
+}
+function registerOdbRenderReportCommand(program) {
+	const command = program.command("odb-render-report <input> [output]").description("render one of an .odb's own reports -- its query resolved, its rpt: formulas evaluated, its bands laid out -- to docx, odt, or pdf");
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	addFontOptions(command);
+	command.option("--report <name>", "the report to render -- required only when the .odb declares more than one report");
+	command.option("--to <format>", "target format when it cannot be inferred from the output path (docx, odt, pdf)");
+	command.action(async (input, output, options) => {
+		process.exitCode = await runOdbRenderReport(input, output, options);
+	});
+}
 function registerOdbCommands(program) {
 	registerOdbToXlsxCommand(program);
 	registerOdbToCsvCommand(program);
 	registerOdbTablesCommand(program);
 	registerOdbFormsCommand(program);
 	registerOdbReportsCommand(program);
+	registerOdbQueryCommand(program);
+	registerOdbRenderReportCommand(program);
 }
 //#endregion
 //#region src/commands/odm.ts
@@ -1073,7 +1402,7 @@ async function runPdfInspect(input, options) {
 			}
 		});
 		if (options.full) {
-			process.stdout.write(`${JSON.stringify(layout, void 0, 2)}\n`);
+			process.stdout.write(`${JSON.stringify(layoutDocumentWithSchema(layout), void 0, 2)}\n`);
 			return 0;
 		}
 		const imagesByFormat = countImagesByFormat(layout.images);
@@ -1128,7 +1457,7 @@ function registerPdfInspectCommand(program) {
 }
 //#endregion
 //#region package.json
-var version = "1.2.11";
+var version = "1.4.0";
 //#endregion
 //#region src/program.ts
 function createProgram() {
@@ -1145,6 +1474,8 @@ function createProgram() {
 	registerOdmCommand(program);
 	registerOdbCommands(program);
 	registerPdfInspectCommand(program);
+	registerFontsCommand(program);
+	registerDocxExtrasCommand(program);
 	return program;
 }
 //#endregion

package/dist/{odb-structure-CX_0zL8_.js → odb-structure-DkfNyHGR.js}

@@ -247,6 +247,64 @@ function resolveDefaultOutputPath(inputPath, targetFormat) {
 	return join(directory, `${stem}.${formatToExtension(targetFormat)}`);
 }
 //#endregion
+//#region src/docx-extras-format.ts
+const INDENT$1 = "  ";
+function indent$1(depth) {
+	return INDENT$1.repeat(depth);
+}
+function commentLine(comment, position) {
+	const author = comment.author ?? "(no author)";
+	return `${indent$1(1)}[${position}] ${author}: ${comment.text}`;
+}
+function footnoteLine(footnote, position) {
+	const typeSuffix = footnote.type === void 0 ? "" : ` (${footnote.type})`;
+	return `${indent$1(1)}[${position}]${typeSuffix} ${footnote.text}`;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return [];
+	return ["comments", ...comments.map((comment, index) => commentLine(comment, index + 1))];
+}
+function footnotesSection(footnotes) {
+	if (footnotes.length === 0) return [];
+	return ["footnotes", ...footnotes.map((footnote, index) => footnoteLine(footnote, index + 1))];
+}
+function headerOrFooterSection(label, values) {
+	if (values.length === 0) return [];
+	return [label, ...values.map((text, index) => `${indent$1(1)}[${index + 1}] ${text}`)];
+}
+function numberingLevelLine(ilvl, level) {
+	const restartSuffix = level.restart === void 0 ? "" : `, restarts at level ${level.restart}`;
+	return `${indent$1(2)}level ${ilvl}: ${level.format} ${JSON.stringify(level.text)} starting at ${level.startAt}${restartSuffix}`;
+}
+function numberingSection(numbering) {
+	const numIds = Object.keys(numbering);
+	if (numIds.length === 0) return [];
+	const lines = ["numbering"];
+	for (const numId of numIds) {
+		const definition = numbering[numId];
+		if (definition === void 0) continue;
+		lines.push(`${indent$1(1)}numId ${numId}`);
+		const ilvls = Object.keys(definition.levels).sort((a, b) => Number(a) - Number(b));
+		for (const ilvl of ilvls) {
+			const level = definition.levels[ilvl];
+			if (level === void 0) continue;
+			lines.push(numberingLevelLine(ilvl, level));
+		}
+	}
+	return lines;
+}
+function formatDocxExtrasLines(extras) {
+	const nonEmptySections = [
+		commentsSection(extras.comments),
+		footnotesSection(extras.footnotes),
+		headerOrFooterSection("headers", extras.headers),
+		headerOrFooterSection("footers", extras.footers),
+		numberingSection(extras.numbering)
+	].filter((section) => section.length > 0);
+	if (nonEmptySections.length === 0) return ["This document carries no comments, footnotes, headers, footers, or numbering definitions."];
+	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
+}
+//#endregion
 //#region src/odb-structure.ts
 const INDENT = "  ";
 function indent(depth) {
@@ -379,4 +437,4 @@ function formatOdbReportLines(report) {
 	return lines;
 }
 //#endregion
-export { odbFormSummary as a, writeOutput as c, inferFormatFromExtension as d, isDocumentFormat as f, formatOdbReportLines as i, loadProvidedFonts as l, describeOdbReport as n, readInput as o, formatOdbFormLines as r, resolveDefaultOutputPath as s, describeOdbForm as t, formatToExtension as u };
+export { odbFormSummary as a, resolveDefaultOutputPath as c, formatToExtension as d, inferFormatFromExtension as f, formatOdbReportLines as i, writeOutput as l, describeOdbReport as n, formatDocxExtrasLines as o, isDocumentFormat as p, formatOdbFormLines as r, readInput as s, describeOdbForm as t, loadProvidedFonts as u };