document-cli 0.0.0 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { DocumentFormat } from "documents.js";
+import { Command } from "commander";
+//#region src/format.d.ts
+declare function isDocumentFormat(value: string): value is DocumentFormat;
+declare function inferFormatFromExtension(path: string): DocumentFormat | undefined;
+declare function formatToExtension(format: DocumentFormat): string;
+//#endregion
+//#region src/commands/shared.d.ts
+interface ConversionCommandOptions {
+  readonly out?: string;
+  readonly timeoutMs?: number;
+  readonly json: boolean;
+  readonly quiet: boolean;
+  readonly verbose: boolean;
+  readonly dumpPackage?: string;
+}
+declare function formatError(error: unknown, verbose: boolean): string;
+declare function buildConversionAction(source: DocumentFormat, target: DocumentFormat): (input: string, output: string | undefined, options: ConversionCommandOptions) => Promise<number>;
+//#endregion
+//#region src/program.d.ts
+declare function createProgram(): Command;
+//#endregion
+//#region src/runtime/exit-codes.d.ts
+declare const EXIT_SUCCESS = 0;
+declare const EXIT_INPUT_ERROR = 1;
+declare const EXIT_USAGE_ERROR = 2;
+declare const EXIT_NEEDS_INFO = 3;
+declare const EXIT_TIMEOUT = 124;
+declare const EXIT_INTERRUPTED = 130;
+declare function mapErrorToExit(error: unknown, abortReason: 'interrupt' | 'timeout' | undefined): number;
+//#endregion
+export { type ConversionCommandOptions, EXIT_INPUT_ERROR, EXIT_INTERRUPTED, EXIT_NEEDS_INFO, EXIT_SUCCESS, EXIT_TIMEOUT, EXIT_USAGE_ERROR, buildConversionAction, createProgram, formatError, formatToExtension, inferFormatFromExtension, isDocumentFormat, mapErrorToExit };

package/dist/index.js

@@ -0,0 +1,651 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { OdbNoEmbeddedDataSourceError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, createLocalDocumentConverter, odbToCsv, odbToXlsx, odmToPdf, readOdbTables, readPdf } from "documents.js";
+import { basename, dirname, extname, join } from "node:path";
+import { Command, InvalidArgumentError } from "commander";
+import { decodePackage } from "odf.js";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/format.ts
+const EXTENSION_TO_FORMAT = {
+	docx: "docx",
+	pptx: "pptx",
+	xlsx: "xlsx",
+	odt: "odt",
+	odp: "odp",
+	ods: "ods",
+	odg: "odg",
+	odf: "odf",
+	pdf: "pdf"
+};
+const FORMAT_TO_EXTENSION = {
+	docx: "docx",
+	pptx: "pptx",
+	xlsx: "xlsx",
+	odt: "odt",
+	odp: "odp",
+	ods: "ods",
+	odg: "odg",
+	odf: "odf",
+	pdf: "pdf"
+};
+function isDocumentFormat(value) {
+	return value in FORMAT_TO_EXTENSION;
+}
+function inferFormatFromExtension(path) {
+	if (path === "-") return;
+	const lastSegment = path.split(/[/\\]/).pop() ?? path;
+	const dotIndex = lastSegment.lastIndexOf(".");
+	if (dotIndex <= 0) return;
+	const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+	return EXTENSION_TO_FORMAT[extension];
+}
+function formatToExtension(format) {
+	return FORMAT_TO_EXTENSION[format];
+}
+//#endregion
+//#region src/runtime/abort.ts
+function combineSignals(a, b) {
+	const controller = new AbortController();
+	const forward = (signal) => {
+		controller.abort(signal.reason);
+	};
+	if (a.aborted) forward(a);
+	else a.addEventListener("abort", () => forward(a), { once: true });
+	if (b.aborted) forward(b);
+	else b.addEventListener("abort", () => forward(b), { once: true });
+	return controller.signal;
+}
+function createRuntimeSignal(options) {
+	let abortReason;
+	const interruptController = new AbortController();
+	process.on("SIGINT", () => {
+		abortReason ??= "interrupt";
+		interruptController.abort(/* @__PURE__ */ new Error("Interrupted by SIGINT"));
+	});
+	const getAbortReason = () => abortReason;
+	if (options.timeoutMs === void 0) return {
+		signal: interruptController.signal,
+		getAbortReason
+	};
+	const timeoutController = new AbortController();
+	setTimeout(() => {
+		abortReason ??= "timeout";
+		timeoutController.abort(/* @__PURE__ */ new Error(`Timed out after ${options.timeoutMs}ms`));
+	}, options.timeoutMs).unref();
+	return {
+		signal: combineSignals(interruptController.signal, timeoutController.signal),
+		getAbortReason
+	};
+}
+//#endregion
+//#region src/runtime/diagnostics.ts
+function createDiagnosticReporter(options) {
+	const { json, quiet, command } = options;
+	return {
+		report(diagnostic) {
+			if (quiet) return;
+			if (json) {
+				process.stderr.write(`${JSON.stringify({
+					type: "diagnostic",
+					command,
+					...diagnostic
+				})}\n`);
+				return;
+			}
+			const pageClause = diagnostic.pageIndex === void 0 ? "" : ` (page ${diagnostic.pageIndex})`;
+			process.stderr.write(`[${command}] ${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}${pageClause}\n`);
+		},
+		summarize(result) {
+			if (json) {
+				process.stderr.write(`${JSON.stringify({
+					type: "result",
+					...result
+				})}\n`);
+				return;
+			}
+			if (quiet) return;
+			const diagnosticClause = `${result.diagnosticCount} diagnostic${result.diagnosticCount === 1 ? "" : "s"}`;
+			process.stderr.write(`[${command}] wrote ${result.bytes} bytes to ${result.output} (${diagnosticClause})\n`);
+		}
+	};
+}
+function substitutionToDiagnostic(substitution, pageIndex) {
+	return {
+		severity: "warning",
+		code: "win-ansi-substitution",
+		message: `Character '${substitution.from}' has no glyph in the standard font; substituted with '${substitution.to}'`,
+		pageIndex
+	};
+}
+function pdfDiagnosticToDiagnostic(diagnostic) {
+	return {
+		severity: diagnostic.severity,
+		code: diagnostic.code,
+		message: diagnostic.message,
+		pageIndex: diagnostic.pageIndex
+	};
+}
+//#endregion
+//#region src/runtime/exit-codes.ts
+const EXIT_SUCCESS = 0;
+const EXIT_INPUT_ERROR = 1;
+const EXIT_USAGE_ERROR = 2;
+const EXIT_NEEDS_INFO = 3;
+const EXIT_TIMEOUT = 124;
+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 PdfEncryptedError || error instanceof PdfParseError) return 1;
+	return 1;
+}
+//#endregion
+//#region src/runtime/io.ts
+function isUint8Array(value) {
+	return value instanceof Uint8Array;
+}
+async function readStdin(signal) {
+	const chunks = [];
+	for await (const chunk of process.stdin) {
+		if (signal?.aborted === true) throw new Error("Reading from stdin was aborted");
+		if (!isUint8Array(chunk)) throw new Error("Unexpected non-buffer chunk read from stdin");
+		chunks.push(chunk);
+	}
+	return new Uint8Array(Buffer.concat(chunks));
+}
+async function readInput(pathOrDash, options) {
+	if (pathOrDash === "-") return readStdin(options?.signal);
+	const buffer = await readFile(pathOrDash, { signal: options?.signal });
+	return new Uint8Array(buffer);
+}
+async function writeOutput(pathOrDash, bytes) {
+	if (pathOrDash === "-") {
+		await new Promise((resolve, reject) => {
+			process.stdout.write(bytes, (error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		return;
+	}
+	await writeFile(pathOrDash, bytes);
+}
+function resolveDefaultOutputPath(inputPath, targetFormat) {
+	const directory = dirname(inputPath);
+	const stem = basename(inputPath, extname(inputPath));
+	return join(directory, `${stem}.${formatToExtension(targetFormat)}`);
+}
+//#endregion
+//#region src/commands/shared.ts
+function formatError(error, verbose) {
+	if (!(error instanceof Error)) return `error: ${String(error)}`;
+	const stackClause = verbose && error.stack !== void 0 ? `\n${error.stack}` : "";
+	return `error: ${error.message}${stackClause}`;
+}
+function buildConversionAction(source, target) {
+	const command = `${source}-to-${target}`;
+	return async (input, output, options) => {
+		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 resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, target));
+		const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeoutMs });
+		try {
+			const inputBytes = await readInput(input, { signal });
+			const result = await createLocalDocumentConverter().convert({
+				source: {
+					format: source,
+					bytes: new Uint8Array(inputBytes)
+				},
+				targetFormat: target
+			}, { signal });
+			await writeOutput(resolvedOutput, result.document.bytes);
+			const reporter = createDiagnosticReporter({
+				json: options.json,
+				quiet: options.quiet,
+				command
+			});
+			for (const diagnostic of result.diagnostics) reporter.report(diagnostic);
+			if (options.dumpPackage !== void 0) if (result.package === void 0) process.stderr.write(`[${command}] this conversion does not produce an intermediate DocumentPackage\n`);
+			else await writeFile(options.dumpPackage, JSON.stringify(result.package, void 0, 2));
+			reporter.summarize({
+				output: resolvedOutput,
+				bytes: result.document.bytes.byteLength,
+				diagnosticCount: result.diagnostics.length
+			});
+			return 0;
+		} catch (error) {
+			process.stderr.write(`${formatError(error, options.verbose)}\n`);
+			return mapErrorToExit(error, getAbortReason());
+		}
+	};
+}
+//#endregion
+//#region src/commands/options.ts
+function addOutOption(command) {
+	return command.option("-o, --out <file>", "output file path (defaults to the input path with the target format's extension); use - for stdout");
+}
+function addTimeoutOption(command) {
+	return command.option("--timeout <ms>", "abort the run after this many milliseconds", (value) => Number.parseInt(value, 10));
+}
+function addJsonOption(command) {
+	return command.option("--json", "emit diagnostics and the result summary as newline-delimited JSON on stderr", false);
+}
+function addQuietOption(command) {
+	return command.option("-q, --quiet", "suppress diagnostic and summary output", false);
+}
+function addVerboseOption(command) {
+	return command.option("--verbose", "include a full stack trace when the run fails", false);
+}
+function addDumpPackageOption(command) {
+	return command.option("--dump-package <file>", "write the intermediate DocumentPackage (content + layout) this conversion built to a JSON file");
+}
+function addConversionFlags(command) {
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	return command;
+}
+//#endregion
+//#region src/commands/convert.ts
+function toConversionCommandOptions(options) {
+	return {
+		out: options.out,
+		timeoutMs: options.timeout,
+		json: options.json,
+		quiet: options.quiet,
+		verbose: options.verbose,
+		dumpPackage: options.dumpPackage
+	};
+}
+const KNOWN_FORMATS = "docx, pptx, xlsx, odt, odp, ods, odg, odf, pdf";
+function resolveGenericTarget(output, options) {
+	if (options.to !== void 0) {
+		if (!isDocumentFormat(options.to)) return { errorMessage: `unknown --to format '${options.to}'; expected one of ${KNOWN_FORMATS}` };
+		return { format: options.to };
+	}
+	const destination = output ?? options.out;
+	if (destination === void 0) return { errorMessage: "cannot infer a target format -- pass an output path with a recognised extension, --out with one, or --to <format>" };
+	const inferred = inferFormatFromExtension(destination);
+	if (inferred === void 0) return { errorMessage: `cannot infer a target format from '${destination}'; pass --to <format> instead` };
+	return { format: inferred };
+}
+async function runGenericConvert(input, output, options) {
+	const extension = extname(input).toLowerCase();
+	if (extension === ".odm") {
+		process.stderr.write("convert: '.odm' master documents are not supported by the generic convert command -- use 'odm-to-pdf' instead\n");
+		return 2;
+	}
+	if (extension === ".odb") {
+		process.stderr.write("convert: '.odb' embedded databases are not supported by the generic convert command -- use 'odb-to-csv', 'odb-to-xlsx', or 'odb-tables' instead\n");
+		return 2;
+	}
+	const source = inferFormatFromExtension(input);
+	if (source === void 0) {
+		process.stderr.write(`convert: cannot infer a source format from '${input}'; rename the file with a recognised extension (${KNOWN_FORMATS}) or use one of the explicit '<source>-to-<target>' commands\n`);
+		return 2;
+	}
+	const target = resolveGenericTarget(output, options);
+	if ("errorMessage" in target) {
+		process.stderr.write(`convert: ${target.errorMessage}\n`);
+		return 2;
+	}
+	return buildConversionAction(source, target.format)(input, output, toConversionCommandOptions(options));
+}
+function registerConversionCommands(program) {
+	const { conversions } = createLocalDocumentConverter();
+	for (const { source, target } of conversions) {
+		const commandName = `${source}-to-${target}`;
+		const command = program.command(`${commandName} <input> [output]`).description(`convert a ${source} document to ${target}`);
+		addConversionFlags(command);
+		addDumpPackageOption(command);
+		command.action(async (input, output, options) => {
+			process.exitCode = await buildConversionAction(source, target)(input, output, toConversionCommandOptions(options));
+		});
+	}
+	const generic = program.command("convert <input> [output]").description("convert between any two supported document formats, inferring source/target from file extensions where possible");
+	addConversionFlags(generic);
+	addDumpPackageOption(generic);
+	generic.option("--to <format>", `target format when it cannot be inferred from the output path (${KNOWN_FORMATS})`);
+	generic.action(async (input, output, options) => {
+		process.exitCode = await runGenericConvert(input, output, options);
+	});
+}
+//#endregion
+//#region src/commands/formats.ts
+const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, pdf-inspect";
+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();
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(conversions)}\n`);
+			return;
+		}
+		for (const { source, target } of conversions) process.stdout.write(`${source} -> ${target}\n`);
+		process.stdout.write(`\nnot covered by this list, each its own command: ${COMMANDS_NOT_LISTED}\n`);
+	});
+}
+//#endregion
+//#region src/commands/odb.ts
+function reportOdbError(command, error, verbose, abortReason) {
+	if (error instanceof OdbNoEmbeddedDataSourceError || error instanceof OdbUnsupportedFormatError) {
+		process.stderr.write(`[${command}] ${error.message}\n`);
+		return mapErrorToExit(error, abortReason);
+	}
+	process.stderr.write(`[${command}] ${formatError(error, verbose)}\n`);
+	return mapErrorToExit(error, abortReason);
+}
+function reportOdbCsvError(command, error, verbose, abortReason) {
+	if (error instanceof OdbTableNotSpecifiedError || error instanceof OdbTableNotFoundError) {
+		process.stderr.write(`[${command}] ${error.message}\nrun 'odb-tables' first to see the available tables\n`);
+		return mapErrorToExit(error, abortReason);
+	}
+	return reportOdbError(command, error, verbose, abortReason);
+}
+function resolveDefaultCsvOutputPath(inputPath) {
+	const directory = dirname(inputPath);
+	const stem = basename(inputPath, extname(inputPath));
+	return join(directory, `${stem}.csv`);
+}
+async function runOdbToXlsx(input, output, options) {
+	const command = "odb-to-xlsx";
+	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 resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, "xlsx"));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const bytes = odbToXlsx(new Uint8Array(inputBytes), { signal });
+		await writeOutput(resolvedOutput, bytes);
+		createDiagnosticReporter({
+			json: options.json,
+			quiet: options.quiet,
+			command
+		}).summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount: 0
+		});
+		return 0;
+	} catch (error) {
+		return reportOdbError(command, error, options.verbose, getAbortReason());
+	}
+}
+async function runOdbToCsv(input, output, options) {
+	const command = "odb-to-csv";
+	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 resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultCsvOutputPath(input));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const bytes = odbToCsv(new Uint8Array(inputBytes), {
+			signal,
+			table: options.table
+		});
+		await writeOutput(resolvedOutput, bytes);
+		createDiagnosticReporter({
+			json: options.json,
+			quiet: options.quiet,
+			command
+		}).summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount: 0
+		});
+		return 0;
+	} catch (error) {
+		return reportOdbCsvError(command, error, options.verbose, getAbortReason());
+	}
+}
+async function runOdbTables(input, options) {
+	const command = "odb-tables";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const tables = readOdbTables(pkg);
+		if (options.json) {
+			const summary = tables.map((table) => ({
+				tableName: table.tableName,
+				columns: table.columns,
+				rowCount: table.rows.length
+			}));
+			process.stdout.write(`${JSON.stringify(summary)}\n`);
+			return 0;
+		}
+		for (const table of tables) {
+			process.stdout.write(`${table.tableName} (${table.rows.length} row${table.rows.length === 1 ? "" : "s"})\n`);
+			for (const column of table.columns) process.stdout.write(`  ${column.name}: ${column.type}\n`);
+		}
+		return 0;
+	} catch (error) {
+		return reportOdbError(command, error, false, 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);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	command.action(async (input, output, options) => {
+		process.exitCode = await runOdbToXlsx(input, output, options);
+	});
+}
+function registerOdbToCsvCommand(program) {
+	const command = program.command("odb-to-csv <input> [output]").description("extract exactly one named table from an embedded .odb database as CSV");
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	command.option("--table <name>", "the table to export -- required when the .odb declares more than one table");
+	command.action(async (input, output, options) => {
+		process.exitCode = await runOdbToCsv(input, output, options);
+	});
+}
+function registerOdbTablesCommand(program) {
+	program.command("odb-tables <input>").description("list every table an embedded .odb database declares, with column names/types and row counts").option("--json", "emit the table list as a JSON array instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runOdbTables(input, options);
+	});
+}
+function registerOdbCommands(program) {
+	registerOdbToXlsxCommand(program);
+	registerOdbToCsvCommand(program);
+	registerOdbTablesCommand(program);
+}
+//#endregion
+//#region src/commands/odm.ts
+function collectChapterOverride(value, previous) {
+	const separatorIndex = value.indexOf("=");
+	if (separatorIndex === -1) throw new InvalidArgumentError(`--chapter must be formatted as <href>=<file>, got '${value}'`);
+	const next = new Map(previous);
+	next.set(value.slice(0, separatorIndex), value.slice(separatorIndex + 1));
+	return next;
+}
+function createResolveSubDocument(overrides, chaptersDir) {
+	return (href) => {
+		const overridePath = overrides.get(href);
+		if (overridePath !== void 0) return new Uint8Array(readFileSync(overridePath));
+		if (chaptersDir === void 0) return;
+		const candidate = join(chaptersDir, basename(href));
+		if (!existsSync(candidate)) return;
+		return new Uint8Array(readFileSync(candidate));
+	};
+}
+async function runOdmToPdf(input, output, options) {
+	const command = "odm-to-pdf";
+	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 resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, "pdf"));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	const resolveSubDocument = createResolveSubDocument(options.chapter, options.chaptersDir);
+	const reporter = createDiagnosticReporter({
+		json: options.json,
+		quiet: options.quiet,
+		command
+	});
+	let diagnosticCount = 0;
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const bytes = odmToPdf(new Uint8Array(inputBytes), {
+			signal,
+			resolveSubDocument,
+			onSubstitution: (substitution, context) => {
+				diagnosticCount += 1;
+				reporter.report(substitutionToDiagnostic(substitution, context.pageIndex));
+			}
+		});
+		await writeOutput(resolvedOutput, bytes);
+		reporter.summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount
+		});
+		return 0;
+	} catch (error) {
+		if (error instanceof OdmUnresolvedSectionError) {
+			process.stderr.write(`${error.message}\npass --chapters-dir <dir> containing these files, or --chapter <href>=<file>\n`);
+			return mapErrorToExit(error, getAbortReason());
+		}
+		process.stderr.write(`${formatError(error, options.verbose)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerOdmCommand(program) {
+	const command = program.command("odm-to-pdf <input> [output]").description("convert a .odm master document to pdf, resolving each chapter's external .odt reference via --chapters-dir and/or --chapter");
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	command.option("--chapters-dir <dir>", "directory to search for each unresolved chapter href, matched by the href's own basename");
+	command.option("--chapter <href>=<file>", "resolve one chapter href to a local file explicitly; repeatable", collectChapterOverride, /* @__PURE__ */ new Map());
+	command.action(async (input, output, options) => {
+		process.exitCode = await runOdmToPdf(input, output, options);
+	});
+}
+//#endregion
+//#region src/commands/pdf-inspect.ts
+function buildItemKindHistogram(items) {
+	const histogram = /* @__PURE__ */ new Map();
+	for (const item of items) histogram.set(item.kind, (histogram.get(item.kind) ?? 0) + 1);
+	return histogram;
+}
+function countImagesByFormat(images) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const asset of Object.values(images)) counts.set(asset.format, (counts.get(asset.format) ?? 0) + 1);
+	return counts;
+}
+function isPresent(entry) {
+	return entry[1] !== void 0;
+}
+function formatMetadataValue(value) {
+	return typeof value === "string" ? value : value.join(", ");
+}
+async function runPdfInspect(input, options) {
+	const command = "pdf-inspect";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	const reporter = createDiagnosticReporter({
+		json: options.json,
+		quiet: false,
+		command
+	});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const layout = readPdf(new Uint8Array(inputBytes), {
+			signal,
+			sink: (diagnostic) => {
+				reporter.report(pdfDiagnosticToDiagnostic(diagnostic));
+			}
+		});
+		if (options.full) {
+			process.stdout.write(`${JSON.stringify(layout, void 0, 2)}\n`);
+			return 0;
+		}
+		const imagesByFormat = countImagesByFormat(layout.images);
+		if (options.json) {
+			const summary = {
+				pageCount: layout.pages.length,
+				pages: layout.pages.map((page) => ({
+					widthPt: page.widthPt,
+					heightPt: page.heightPt,
+					itemKinds: Object.fromEntries(buildItemKindHistogram(page.items))
+				})),
+				metadata: layout.metadata,
+				imagesByFormat: Object.fromEntries(imagesByFormat)
+			};
+			process.stdout.write(`${JSON.stringify(summary)}\n`);
+			return 0;
+		}
+		process.stdout.write(`${layout.pages.length} page${layout.pages.length === 1 ? "" : "s"}\n`);
+		layout.pages.forEach((page, index) => {
+			const histogram = buildItemKindHistogram(page.items);
+			const histogramText = Array.from(histogram.entries()).map(([kind, count]) => `${kind}=${count}`).join(", ");
+			process.stdout.write(`  page ${index + 1}: ${page.widthPt}pt x ${page.heightPt}pt${histogramText === "" ? "" : ` (${histogramText})`}\n`);
+		});
+		const presentMetadata = [
+			["title", layout.metadata.title],
+			["author", layout.metadata.author],
+			["subject", layout.metadata.subject],
+			["keywords", layout.metadata.keywords],
+			["creator", layout.metadata.creator],
+			["producer", layout.metadata.producer],
+			["createdIso", layout.metadata.createdIso],
+			["modifiedIso", layout.metadata.modifiedIso]
+		].filter(isPresent);
+		if (presentMetadata.length > 0) {
+			process.stdout.write("metadata:\n");
+			for (const [key, value] of presentMetadata) process.stdout.write(`  ${key}: ${formatMetadataValue(value)}\n`);
+		}
+		if (imagesByFormat.size > 0) {
+			process.stdout.write("images:\n");
+			for (const [format, count] of imagesByFormat) process.stdout.write(`  ${format}: ${count}\n`);
+		}
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerPdfInspectCommand(program) {
+	program.command("pdf-inspect <input>").description("inspect a PDF: page count, per-page size and item-kind histogram, document metadata, and embedded image formats").option("--json", "emit the summary as JSON instead of a human-readable report", false).option("--full", "dump the entire parsed LayoutDocument as JSON instead of a summary", false).action(async (input, options) => {
+		process.exitCode = await runPdfInspect(input, options);
+	});
+}
+//#endregion
+//#region package.json
+var version = "1.0.0";
+//#endregion
+//#region src/program.ts
+function createProgram() {
+	const program = new Command("document-cli");
+	program.description("every documents.js docx/pptx/odt/odp/ods/odg/odf/odm/odb conversion, bridge, and inspector as a scriptable command");
+	program.version(version);
+	program.exitOverride((error) => {
+		process.exitCode = error.exitCode === 0 ? 0 : 2;
+		throw error;
+	});
+	registerConversionCommands(program);
+	registerFormatsCommand(program);
+	registerOdmCommand(program);
+	registerOdbCommands(program);
+	registerPdfInspectCommand(program);
+	return program;
+}
+//#endregion
+export { EXIT_INPUT_ERROR, EXIT_INTERRUPTED, EXIT_NEEDS_INFO, EXIT_SUCCESS, EXIT_TIMEOUT, EXIT_USAGE_ERROR, buildConversionAction, createProgram, formatError, formatToExtension, inferFormatFromExtension, isDocumentFormat, mapErrorToExit };