@optique/man 0.10.0-dev.0

package/dist/cli.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+import "./roff-i3JSYqke.js";
+import "./man-BmhJz56F.js";
+import { generateManPageAsync } from "./generator-DQks_OLj.js";
+import { object } from "@optique/core/constructs";
+import { argument, option } from "@optique/core/primitives";
+import { choice, string } from "@optique/core/valueparser";
+import { optional, withDefault } from "@optique/core/modifiers";
+import { commandLine, message, metavar, optionName } from "@optique/core/message";
+import { defineProgram } from "@optique/core/program";
+import { printError, runSync } from "@optique/run";
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+//#region deno.json
+var name = "@optique/man";
+var version = "0.10.0";
+var license = "MIT";
+var exports = {
+	".": "./src/index.ts",
+	"./roff": "./src/roff.ts",
+	"./man": "./src/man.ts",
+	"./cli": "./src/cli.ts"
+};
+var imports = { "tsx/esm/api": "npm:tsx@^4.21.0/esm/api" };
+var exclude = ["dist/", "tsdown.config.ts"];
+var tasks = {
+	"build": "pnpm build",
+	"test": "deno test",
+	"test:node": {
+		"dependencies": ["build"],
+		"command": "node --experimental-transform-types --test"
+	},
+	"test:bun": {
+		"dependencies": ["build"],
+		"command": "bun test"
+	},
+	"test-all": { "dependencies": [
+		"test",
+		"test:node",
+		"test:bun"
+	] }
+};
+var deno_default = {
+	name,
+	version,
+	license,
+	exports,
+	imports,
+	exclude,
+	tasks
+};
+
+//#endregion
+//#region src/cli.ts
+const EXIT_FILE_NOT_FOUND = 1;
+const EXIT_EXPORT_NOT_FOUND = 2;
+const EXIT_NOT_PROGRAM_OR_PARSER = 3;
+const EXIT_TSX_REQUIRED = 4;
+const EXIT_GENERATION_FAILED = 5;
+const EXIT_WRITE_FAILED = 6;
+const sectionValues = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8
+];
+/**
+* CLI program definition for optique-man.
+*/
+const cliProgram = defineProgram({
+	parser: object({
+		file: argument(string({ metavar: "FILE" }), { description: message`Path to a TypeScript or JavaScript file that exports
+a ${metavar("PROGRAM")} or ${metavar("PARSER")} to generate a man page from.` }),
+		section: option("-s", "--section", choice(sectionValues, { metavar: "SECTION" }), { description: message`Man page section number (${"1"}-${"8"}). Common sections:
+
+  ${"1"}  User commands
+  ${"5"}  File formats
+  ${"8"}  System administration` }),
+		exportName: withDefault(option("-e", "--export", string({ metavar: "NAME" }), { description: message`JavaScript export name to use. The export must be
+a ${metavar("PROGRAM")} (from ${commandLine("defineProgram()")}) or
+a ${metavar("PARSER")}. If not specified, the default export is used.` }), "default"),
+		output: optional(option("-o", "--output", string({ metavar: "PATH" }), { description: message`Output file path. If not specified, the man page
+is written to stdout.` })),
+		name: optional(option("--name", string({ metavar: "NAME" }), { description: message`Program name to use in the man page header.
+If not specified, inferred from the ${metavar("PROGRAM")} metadata
+or the input file name.` })),
+		date: optional(option("--date", string({ metavar: "DATE" }), { description: message`Date to display in the man page footer.
+Defaults to the current date.` })),
+		versionString: optional(option("--version-string", string({ metavar: "VERSION" }), { description: message`Version string for the man page footer
+(e.g., ${"MyApp 1.0.0"}). Overrides the version from
+${metavar("PROGRAM")} metadata if provided.` })),
+		manual: optional(option("--manual", string({ metavar: "TITLE" }), { description: message`Manual name for the man page header
+(e.g., ${"User Commands"}).` }))
+	}),
+	metadata: {
+		name: "optique-man",
+		version: deno_default.version,
+		brief: message`Generate Unix man pages from Optique parsers`,
+		description: message`Generates a Unix man page from an Optique
+${metavar("PROGRAM")} or ${metavar("PARSER")} exported from a TypeScript
+or JavaScript file.
+
+The input file should export a ${metavar("PROGRAM")} (created with
+${commandLine("defineProgram()")}) or a ${metavar("PARSER")}. When using
+a ${metavar("PROGRAM")}, metadata like name, version, author, and examples
+are automatically extracted.`,
+		examples: message`Generate a man page for section ${"1"} (user commands):
+
+  ${commandLine("optique-man ./src/cli.ts -s 1")}
+
+Use a named export instead of the default export:
+
+  ${commandLine("optique-man ./src/cli.ts -s 1 -e myProgram")}
+
+Write output to a file:
+
+  ${commandLine("optique-man ./src/cli.ts -s 1 -o myapp.1")}
+
+Override the program name:
+
+  ${commandLine("optique-man ./src/cli.ts -s 1 --name myapp")}`,
+		bugs: message`Report bugs to: <https://github.com/dahlia/optique/issues>.`
+	}
+});
+/**
+* Gets the Node.js major and minor version numbers.
+* @returns A tuple of [major, minor] or null if not running on Node.js.
+*/
+function getNodeMajorMinor() {
+	if (typeof process === "undefined" || !process.versions?.node) return null;
+	const [major, minor] = process.versions.node.split(".").map(Number);
+	return [major, minor];
+}
+/**
+* Checks if Node.js natively supports TypeScript via type stripping.
+* Node.js 25.2.0+ has type stripping enabled by default.
+* @returns true if native TypeScript is supported.
+*/
+function nodeSupportsNativeTypeScript() {
+	const version$1 = getNodeMajorMinor();
+	if (version$1 == null) return false;
+	const [major, minor] = version$1;
+	return major > 25 || major === 25 && minor >= 2;
+}
+/**
+* Error handler for file not found.
+*/
+function fileNotFoundError(filePath) {
+	printError(message`File ${filePath} not found.
+
+Make sure the file path is correct and the file exists.`, { exitCode: EXIT_FILE_NOT_FOUND });
+}
+/**
+* Error handler for export not found.
+*/
+function exportNotFoundError(filePath, exportName, availableExports) {
+	const exportDisplay = exportName === "default" ? "default export" : `export ${exportName}`;
+	let suggestion;
+	if (availableExports.length > 0) suggestion = message`
+
+Available exports: ${availableExports.join(", ")}.
+Use ${optionName("-e")} to specify one of these exports.`;
+	else suggestion = message`
+
+The file has no exports. Make sure it exports a Program or Parser.`;
+	printError(message`No ${exportDisplay} found in ${filePath}.${suggestion}`, { exitCode: EXIT_EXPORT_NOT_FOUND });
+}
+/**
+* Error handler for invalid export type.
+*/
+function notProgramOrParserError(filePath, exportName, actualType) {
+	const exportDisplay = exportName === "default" ? "default export" : `export ${exportName}`;
+	printError(message`The ${exportDisplay} in ${filePath} is not a Program or Parser.
+
+Got type: ${actualType}
+
+The export should be created with ${commandLine("defineProgram()")} or be
+an Optique parser (e.g., from ${commandLine("object()")},
+${commandLine("command()")}, etc.).`, { exitCode: EXIT_NOT_PROGRAM_OR_PARSER });
+}
+/**
+* Error handler for missing tsx.
+*/
+function tsxRequiredError(filePath) {
+	const version$1 = getNodeMajorMinor();
+	const versionStr = version$1 ? `${version$1[0]}.${version$1[1]}` : "unknown";
+	printError(message`TypeScript file ${filePath} cannot be loaded on Node.js ${versionStr}.
+
+Install tsx as a dev dependency:
+
+  ${commandLine("npm install -D tsx")}
+
+Or upgrade to Node.js 25.2.0 or later, which supports TypeScript natively.
+
+Alternatively, use a pre-compiled JavaScript file instead.`, { exitCode: EXIT_TSX_REQUIRED });
+}
+/**
+* Error handler for man page generation failure.
+*/
+function generationError(error) {
+	printError(message`Failed to generate man page: ${error.message}`, { exitCode: EXIT_GENERATION_FAILED });
+}
+/**
+* Error handler for file write failure.
+*/
+function writeError(outputPath, error) {
+	printError(message`Failed to write to ${outputPath}: ${error.message}
+
+Make sure you have write permission and the parent directory exists.`, { exitCode: EXIT_WRITE_FAILED });
+}
+/**
+* Imports a module from the given file path.
+* Handles TypeScript files on Node.js by using tsx if needed.
+*/
+async function importModule(filePath) {
+	const absolutePath = resolve(filePath);
+	if (!existsSync(absolutePath)) fileNotFoundError(filePath);
+	const isTypeScript = /\.[mc]?ts$/.test(filePath);
+	if (typeof globalThis.Deno !== "undefined") return await import(absolutePath);
+	if (typeof globalThis.Bun !== "undefined") return await import(absolutePath);
+	if (isTypeScript && !nodeSupportsNativeTypeScript()) try {
+		const tsx = await import("tsx/esm/api");
+		tsx.register();
+	} catch {
+		tsxRequiredError(filePath);
+	}
+	const fileUrl = pathToFileURL(absolutePath).href;
+	return await import(fileUrl);
+}
+/**
+* Checks if a value is a Program object.
+*/
+function isProgram(value) {
+	return value != null && typeof value === "object" && "parser" in value && "metadata" in value && typeof value.metadata === "object" && value.metadata != null;
+}
+/**
+* Checks if a value is a Parser object.
+*/
+function isParser(value) {
+	return value != null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "$mode" in value && "usage" in value;
+}
+/**
+* Infers the program name from a file path.
+*/
+function inferNameFromPath(filePath) {
+	const base = basename(filePath);
+	const ext = extname(base);
+	return base.slice(0, -ext.length);
+}
+/**
+* Gets available exports from a module.
+*/
+function getAvailableExports(mod) {
+	return Object.keys(mod).filter((key) => key !== "__esModule");
+}
+/**
+* Describes the type of a value for error messages.
+*/
+function describeType(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+/**
+* Main CLI entry point.
+*/
+async function main() {
+	const args = runSync(cliProgram, {
+		help: "option",
+		version: {
+			value: deno_default.version,
+			mode: "option"
+		}
+	});
+	const mod = await importModule(args.file);
+	const target = args.exportName === "default" ? mod.default : mod[args.exportName];
+	if (target === void 0) exportNotFoundError(args.file, args.exportName, getAvailableExports(mod));
+	if (!isProgram(target) && !isParser(target)) notProgramOrParserError(args.file, args.exportName, describeType(target));
+	const name$1 = args.name ?? (isProgram(target) ? target.metadata.name : null) ?? inferNameFromPath(args.file);
+	let manPage;
+	try {
+		if (isProgram(target)) manPage = await generateManPageAsync(target, {
+			section: args.section,
+			name: args.name,
+			date: args.date,
+			version: args.versionString,
+			manual: args.manual
+		});
+		else manPage = await generateManPageAsync(target, {
+			name: name$1,
+			section: args.section,
+			date: args.date,
+			version: args.versionString,
+			manual: args.manual
+		});
+	} catch (error) {
+		generationError(error instanceof Error ? error : new Error(String(error)));
+	}
+	if (args.output) try {
+		await writeFile(args.output, manPage, "utf-8");
+	} catch (error) {
+		writeError(args.output, error instanceof Error ? error : new Error(String(error)));
+	}
+	else console.log(manPage);
+}
+const isMain = "main" in import.meta ? import.meta.main : process.argv[1] === fileURLToPath(import.meta.url);
+if (isMain) main();
+
+//#endregion
+export { main };

package/dist/generator-DFTQgmHv.cjs

@@ -0,0 +1,104 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_man = require('./man-K9LPAprq.cjs');
+const __optique_core_parser = __toESM(require("@optique/core/parser"));
+
+//#region src/generator.ts
+/**
+* Checks if the given value is a {@link Program} object.
+*/
+function isProgram(value) {
+	return typeof value === "object" && value !== null && "parser" in value && "metadata" in value;
+}
+/**
+* Extracts parser and merged options from a parser or program.
+*/
+function extractParserAndOptions(parserOrProgram, options) {
+	if (isProgram(parserOrProgram)) {
+		const { metadata } = parserOrProgram;
+		const programOptions = options;
+		return {
+			parser: parserOrProgram.parser,
+			mergedOptions: {
+				name: programOptions.name ?? metadata.name,
+				section: programOptions.section,
+				date: programOptions.date,
+				version: programOptions.version ?? metadata.version,
+				manual: programOptions.manual,
+				author: programOptions.author ?? metadata.author,
+				bugs: programOptions.bugs ?? metadata.bugs,
+				examples: programOptions.examples ?? metadata.examples,
+				seeAlso: programOptions.seeAlso,
+				environment: programOptions.environment,
+				files: programOptions.files,
+				exitStatus: programOptions.exitStatus
+			}
+		};
+	}
+	return {
+		parser: parserOrProgram,
+		mergedOptions: options
+	};
+}
+function generateManPageSync(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	const docPage = (0, __optique_core_parser.getDocPageSync)(parser) ?? { sections: [] };
+	return require_man.formatDocPageAsMan(docPage, mergedOptions);
+}
+async function generateManPageAsync(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	const docPage = await (0, __optique_core_parser.getDocPageAsync)(parser) ?? { sections: [] };
+	return require_man.formatDocPageAsMan(docPage, mergedOptions);
+}
+function generateManPage(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	if (parser.$mode === "async") return generateManPageAsync(parser, mergedOptions);
+	return generateManPageSync(parser, mergedOptions);
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'generateManPage', {
+  enumerable: true,
+  get: function () {
+    return generateManPage;
+  }
+});
+Object.defineProperty(exports, 'generateManPageAsync', {
+  enumerable: true,
+  get: function () {
+    return generateManPageAsync;
+  }
+});
+Object.defineProperty(exports, 'generateManPageSync', {
+  enumerable: true,
+  get: function () {
+    return generateManPageSync;
+  }
+});

package/dist/generator-DQks_OLj.js

@@ -0,0 +1,58 @@
+import { formatDocPageAsMan } from "./man-BmhJz56F.js";
+import { getDocPageAsync, getDocPageSync } from "@optique/core/parser";
+
+//#region src/generator.ts
+/**
+* Checks if the given value is a {@link Program} object.
+*/
+function isProgram(value) {
+	return typeof value === "object" && value !== null && "parser" in value && "metadata" in value;
+}
+/**
+* Extracts parser and merged options from a parser or program.
+*/
+function extractParserAndOptions(parserOrProgram, options) {
+	if (isProgram(parserOrProgram)) {
+		const { metadata } = parserOrProgram;
+		const programOptions = options;
+		return {
+			parser: parserOrProgram.parser,
+			mergedOptions: {
+				name: programOptions.name ?? metadata.name,
+				section: programOptions.section,
+				date: programOptions.date,
+				version: programOptions.version ?? metadata.version,
+				manual: programOptions.manual,
+				author: programOptions.author ?? metadata.author,
+				bugs: programOptions.bugs ?? metadata.bugs,
+				examples: programOptions.examples ?? metadata.examples,
+				seeAlso: programOptions.seeAlso,
+				environment: programOptions.environment,
+				files: programOptions.files,
+				exitStatus: programOptions.exitStatus
+			}
+		};
+	}
+	return {
+		parser: parserOrProgram,
+		mergedOptions: options
+	};
+}
+function generateManPageSync(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	const docPage = getDocPageSync(parser) ?? { sections: [] };
+	return formatDocPageAsMan(docPage, mergedOptions);
+}
+async function generateManPageAsync(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	const docPage = await getDocPageAsync(parser) ?? { sections: [] };
+	return formatDocPageAsMan(docPage, mergedOptions);
+}
+function generateManPage(parserOrProgram, options) {
+	const { parser, mergedOptions } = extractParserAndOptions(parserOrProgram, options);
+	if (parser.$mode === "async") return generateManPageAsync(parser, mergedOptions);
+	return generateManPageSync(parser, mergedOptions);
+}
+
+//#endregion
+export { generateManPage, generateManPageAsync, generateManPageSync };

package/dist/index.cjs

@@ -0,0 +1,13 @@
+const require_generator = require('./generator-DFTQgmHv.cjs');
+const require_roff = require('./roff-DzxoXJIL.cjs');
+const require_man = require('./man-K9LPAprq.cjs');
+
+exports.escapeHyphens = require_roff.escapeHyphens;
+exports.escapeRoff = require_roff.escapeRoff;
+exports.formatDateForMan = require_man.formatDateForMan;
+exports.formatDocPageAsMan = require_man.formatDocPageAsMan;
+exports.formatMessageAsRoff = require_roff.formatMessageAsRoff;
+exports.formatUsageTermAsRoff = require_man.formatUsageTermAsRoff;
+exports.generateManPage = require_generator.generateManPage;
+exports.generateManPageAsync = require_generator.generateManPageAsync;
+exports.generateManPageSync = require_generator.generateManPageSync;

package/dist/index.d.cts

@@ -0,0 +1,162 @@
+import { escapeHyphens, escapeRoff, formatMessageAsRoff } from "./roff-Cs3_UBG5.cjs";
+import { ManPageOptions, formatDateForMan, formatDocPageAsMan, formatUsageTermAsRoff } from "./man-BMb0Vyt9.cjs";
+import { Mode, ModeValue, Parser } from "@optique/core/parser";
+import { Program } from "@optique/core/program";
+
+//#region src/generator.d.ts
+
+/**
+ * Options for generating a man page from a parser.
+ * Extends {@link ManPageOptions} with the same configuration.
+ * @since 0.10.0
+ */
+interface GenerateManPageOptions extends ManPageOptions {}
+/**
+ * Options for generating a man page from a {@link Program}.
+ *
+ * This interface omits `name`, `version`, `author`, `bugs`, and `examples`
+ * from {@link ManPageOptions} since they are extracted from the program's
+ * metadata. You can still override them by providing values in this options
+ * object.
+ *
+ * @since 0.11.0
+ */
+interface GenerateManPageProgramOptions extends Partial<Omit<ManPageOptions, "section">>, Pick<ManPageOptions, "section"> {}
+/**
+ * Generates a man page from a parser synchronously.
+ *
+ * This function extracts documentation from the parser's structure
+ * and formats it as a complete man page in roff format.
+ *
+ * @example
+ * ```typescript
+ * import { generateManPageSync } from "@optique/man";
+ * import { object, option, flag } from "@optique/core/primitives";
+ * import { string } from "@optique/core/valueparser";
+ *
+ * const parser = object({
+ *   verbose: flag("-v", "--verbose"),
+ *   config: option("-c", "--config", string()),
+ * });
+ *
+ * const manPage = generateManPageSync(parser, {
+ *   name: "myapp",
+ *   section: 1,
+ *   version: "1.0.0",
+ * });
+ *
+ * console.log(manPage);
+ * ```
+ *
+ * @param parser The parser to generate documentation from.
+ * @param options The man page generation options.
+ * @returns The complete man page in roff format.
+ * @since 0.10.0
+ * @since 0.11.0 Added support for {@link Program} objects.
+ */
+declare function generateManPageSync<T>(program: Program<"sync", T>, options: GenerateManPageProgramOptions): string;
+declare function generateManPageSync(parser: Parser<"sync", unknown, unknown>, options: GenerateManPageOptions): string;
+/**
+ * Generates a man page from a parser asynchronously.
+ *
+ * This function extracts documentation from the parser's structure
+ * and formats it as a complete man page in roff format. It supports
+ * both sync and async parsers.
+ *
+ * @example
+ * ```typescript
+ * import { generateManPageAsync } from "@optique/man";
+ * import { object, option } from "@optique/core/primitives";
+ * import { string } from "@optique/core/valueparser";
+ *
+ * const parser = object({
+ *   config: option("-c", "--config", string()),
+ * });
+ *
+ * const manPage = await generateManPageAsync(parser, {
+ *   name: "myapp",
+ *   section: 1,
+ * });
+ * ```
+ *
+ * @param parser The parser to generate documentation from.
+ * @param options The man page generation options.
+ * @returns A promise that resolves to the complete man page in roff format.
+ * @since 0.10.0
+ * @since 0.11.0 Added support for {@link Program} objects.
+ */
+declare function generateManPageAsync<M extends Mode, T>(program: Program<M, T>, options: GenerateManPageProgramOptions): Promise<string>;
+declare function generateManPageAsync<M extends Mode>(parser: Parser<M, unknown, unknown>, options: GenerateManPageOptions): Promise<string>;
+/**
+ * Generates a man page from a parser or program.
+ *
+ * This function extracts documentation from the parser's structure
+ * and formats it as a complete man page in roff format.
+ *
+ * For sync parsers, it returns the man page directly.
+ * For async parsers, it returns a Promise that resolves to the man page.
+ *
+ * @example Parser-based API
+ * ```typescript
+ * import { generateManPage } from "@optique/man";
+ * import { object, option, flag } from "@optique/core/primitives";
+ * import { string, integer } from "@optique/core/valueparser";
+ * import { message } from "@optique/core/message";
+ *
+ * const parser = object({
+ *   verbose: flag("-v", "--verbose", {
+ *     description: message`Enable verbose output.`,
+ *   }),
+ *   port: option("-p", "--port", integer(), {
+ *     description: message`Port to listen on.`,
+ *   }),
+ * });
+ *
+ * const manPage = generateManPage(parser, {
+ *   name: "myapp",
+ *   section: 1,
+ *   version: "1.0.0",
+ *   date: new Date(),
+ *   author: message`Hong Minhee`,
+ * });
+ *
+ * // Write to file
+ * import { writeFileSync } from "node:fs";
+ * writeFileSync("myapp.1", manPage);
+ * ```
+ *
+ * @example Program-based API
+ * ```typescript
+ * import { generateManPage } from "@optique/man";
+ * import { defineProgram } from "@optique/core/program";
+ * import { object, flag } from "@optique/core/primitives";
+ * import { message } from "@optique/core/message";
+ *
+ * const prog = defineProgram({
+ *   parser: object({
+ *     verbose: flag("-v", "--verbose"),
+ *   }),
+ *   metadata: {
+ *     name: "myapp",
+ *     version: "1.0.0",
+ *     author: message`Hong Minhee`,
+ *   },
+ * });
+ *
+ * // Metadata is automatically extracted from the program
+ * const manPage = generateManPage(prog, { section: 1 });
+ * ```
+ *
+ * @param parserOrProgram The parser or program to generate documentation from.
+ * @param options The man page generation options.
+ * @returns The complete man page in roff format, or a Promise for async parsers.
+ * @since 0.10.0
+ * @since 0.11.0 Added support for {@link Program} objects.
+ */
+declare function generateManPage<T>(program: Program<"sync", T>, options: GenerateManPageProgramOptions): string;
+declare function generateManPage<T>(program: Program<"async", T>, options: GenerateManPageProgramOptions): Promise<string>;
+declare function generateManPage(parser: Parser<"sync", unknown, unknown>, options: GenerateManPageOptions): string;
+declare function generateManPage(parser: Parser<"async", unknown, unknown>, options: GenerateManPageOptions): Promise<string>;
+declare function generateManPage<M extends Mode>(parser: Parser<M, unknown, unknown>, options: GenerateManPageOptions): ModeValue<M, string>;
+//#endregion
+export { type GenerateManPageOptions, type GenerateManPageProgramOptions, type ManPageOptions, escapeHyphens, escapeRoff, formatDateForMan, formatDocPageAsMan, formatMessageAsRoff, formatUsageTermAsRoff, generateManPage, generateManPageAsync, generateManPageSync };