fontmin-rs 0.1.0 → 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,784 @@
+import { _ as woffToTtf, a as inspect, b as findConfig, d as ttfToSvg, f as ttfToWoff, g as woff2ToTtf, n as analyzeCoverage, o as otfToTtf, p as ttfToWoff2, r as eotToTtf, s as subsetTtf, t as optimize, u as ttfToEot, x as loadConfig } from "./optimize-pipeline-4Thm4vQb.mjs";
+import { deliverySlices, glyph, svgs2ttf } from "./plugins.mjs";
+import { mkdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, parse, relative, resolve, sep } from "node:path";
+import { glob } from "tinyglobby";
+//#region src/cli.mjs
+const INIT_CONFIG_FILE = "fontmin.config.jsonc";
+const FONTMIN_VERSION = "0.2.0";
+const DEFAULT_CACHE_DIR = "node_modules/.cache/fontmin-rs";
+let emitWarnings = true;
+const DEFAULT_INIT_CONFIG = `{
+  // Generated by fontmin-rs init.
+  "input": ["fonts/*.ttf"],
+  "outDir": "build",
+  "subset": {
+    "text": "Hello",
+    "basicText": true
+  },
+  "outputs": [
+    { "format": "woff2" },
+    { "format": "woff" },
+    { "format": "css" }
+  ],
+  "css": {
+    "fontFamily": "MyFont",
+    "fontPath": "./",
+    "fontDisplay": "swap"
+  },
+  "cache": {
+    "enabled": true
+  }
+}
+`;
+async function runCli(argv = process.argv.slice(2)) {
+	const command = argv[0];
+	const commandArgs = argv.slice(1);
+	try {
+		if (command === void 0 || command === "--help" || command === "-h" || commandArgs.includes("--help") || commandArgs.includes("-h")) usage(process.stdout);
+		else if (command === "--version" || command === "-V") process.stdout.write(`${FONTMIN_VERSION}\n`);
+		else if (command === "doctor") {
+			assertNoUnexpectedArgs(commandArgs, 0);
+			process.stdout.write("fontmin-rs doctor ok\n");
+		} else if (command === "subset") await subsetCommand(commandArgs);
+		else if (command === "coverage") await coverageCommand(commandArgs);
+		else if (command === "convert") await convertCommand(commandArgs);
+		else if (command === "build") await buildCommand(commandArgs);
+		else if (command === "inspect") await inspectCommand(commandArgs);
+		else if (command === "init") {
+			assertNoUnexpectedArgs(commandArgs, 0);
+			await initCommand();
+		} else if (command === "bench") await benchCommand(commandArgs);
+		else {
+			usage(process.stderr);
+			process.exitCode = 1;
+		}
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 1;
+	}
+}
+async function subsetCommand(args) {
+	const output = readOption(args, ["-o", "--output"]);
+	const subsetOptions = await subsetOptionsFromArgs(args);
+	const basicText = readFlag(args, ["-b", "--basic-text"]);
+	assertNoUnexpectedArgs(args);
+	const [input] = args;
+	requireValue(input, "subset requires an input font");
+	requireValue(output, "subset requires -o, --output");
+	if (subsetOptions.text === void 0 && subsetOptions.unicodes.length === 0 && !basicText) throw new Error("subset requires --text, --text-file, --unicodes, or --basic-text");
+	await writeOutput(output, subsetWithCoverage(await readFile(input), {
+		basicText,
+		missingGlyphs: subsetOptions.missingGlyphs,
+		text: subsetOptions.text,
+		unicodes: subsetOptions.unicodes
+	}));
+}
+async function coverageCommand(args) {
+	const json = readFlag(args, ["--json"]);
+	const basicText = readFlag(args, ["-b", "--basic-text"]);
+	const options = await subsetOptionsFromArgs(args);
+	assertNoUnexpectedArgs(args);
+	const [input] = args;
+	requireValue(input, "coverage requires an input font");
+	if (options.text === void 0 && options.unicodes.length === 0 && !basicText) throw new Error("coverage requires --text, --text-file, --unicodes, or --basic-text");
+	const report = analyzeCoverage(await readFile(input), {
+		basicText,
+		text: options.text,
+		unicodes: options.unicodes
+	});
+	if (json) {
+		process.stdout.write(`${JSON.stringify(report, void 0, 2)}\n`);
+		return;
+	}
+	process.stdout.write(`coverage: ${report.coveragePercent.toFixed(2)}% (${report.supported.length}/${report.requested.length})\nrequested: ${report.requested.length}\nsupported: ${report.supported.length}\nmissing: ${report.missing.length}\n`);
+	const warning = missingGlyphMessage(report);
+	if (warning !== void 0) process.stdout.write(`${warning}\n`);
+}
+async function convertCommand(args) {
+	const output = readOption(args, ["-o", "--output"]);
+	const format = readOption(args, ["-f", "--format"]);
+	const variationCoordinates = parseVariations(readOptions(args, ["--variation"]));
+	assertNoUnexpectedArgs(args);
+	const [input] = args;
+	requireValue(input, "convert requires an input font");
+	requireValue(output, "convert requires -o, --output");
+	requireValue(format, "convert requires -f, --format");
+	await writeOutput(output, convertFont(await readFile(input), format, { variationCoordinates }));
+}
+async function benchCommand(args) {
+	const json = readFlag(args, ["--json"]);
+	const basicText = readFlag(args, ["-b", "--basic-text"]);
+	const subsetOptions = await subsetOptionsFromArgs(args);
+	assertNoUnexpectedArgs(args);
+	const [input] = args;
+	requireValue(input, "bench requires an input font");
+	if (subsetOptions.text === void 0 && subsetOptions.unicodes.length === 0 && !basicText) throw new Error("bench requires --text, --text-file, --unicodes, or --basic-text");
+	const contents = await readFile(input);
+	const startedAt = process.hrtime.bigint();
+	const subset = subsetWithCoverage(contents, {
+		basicText,
+		missingGlyphs: subsetOptions.missingGlyphs,
+		text: subsetOptions.text,
+		unicodes: subsetOptions.unicodes
+	});
+	const elapsedMs = Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6);
+	const report = {
+		elapsedMs,
+		inputBytes: contents.byteLength,
+		operation: "subset",
+		outputBytes: subset.byteLength
+	};
+	if (json) process.stdout.write(`${JSON.stringify(report)}\n`);
+	else process.stdout.write(`fontmin-rs bench subset completed in ${elapsedMs} ms\ninput: ${report.inputBytes} bytes\noutput: ${report.outputBytes} bytes\n`);
+}
+async function buildCommand(args) {
+	const showTime = readFlag(args, ["-T", "--show-time"]);
+	const silent = readFlag(args, ["--silent"]);
+	const startedAt = showTime && !silent ? process.hrtime.bigint() : void 0;
+	emitWarnings = !silent;
+	try {
+		await runBuildCommand(args);
+		reportShowTime(startedAt);
+	} finally {
+		emitWarnings = true;
+	}
+}
+async function runBuildCommand(args) {
+	const configPath = readOption(args, ["-c", "--config"]);
+	const cache = readFlag(args, ["--cache"]);
+	const noCache = readFlag(args, ["--no-cache"]);
+	const noOriginal = readFlag(args, ["--no-original"]);
+	readFlag(args, ["-d", "--deflate-woff"]);
+	const cssGlyph = readFlag(args, ["--css-glyph"]);
+	const cssUnicodeRanges = parseUnicodeRanges(readOptions(args, ["--css-unicode-range"]));
+	const deliverySlices = parseDeliverySlices(readOptions(args, ["--delivery-slice"]));
+	const outDir = readOption(args, ["-o", "--out-dir"]);
+	const formats = readOption(args, ["--formats"]);
+	const preset = readOption(args, ["--preset"]);
+	const basicText = readFlag(args, ["-b", "--basic-text"]);
+	const fontFamily = readOption(args, ["--font-family"]);
+	const fontPath = readOption(args, ["--font-path"]);
+	const variationCoordinates = parseVariations(readOptions(args, ["--variation"]));
+	const subsetOptions = await subsetOptionsFromArgs(args);
+	assertNoUnknownOptions(args);
+	if (cache && noCache) throw new Error("build accepts only one of --cache or --no-cache");
+	const cacheOverride = cacheOverrideFromFlags(cache, noCache);
+	if (configPath !== void 0) {
+		if (isIconfontPreset(preset)) {
+			await buildIconfontConfigCommand(configPath, {
+				fontFamily,
+				fontPath,
+				formats,
+				inputs: [...args],
+				cacheOverride,
+				cssUnicodeRanges,
+				deliverySlices,
+				outDir,
+				variationCoordinates
+			});
+			return;
+		}
+		await buildConfigCommand(configPath, {
+			basicText,
+			cacheOverride,
+			cssGlyph,
+			cssUnicodeRanges,
+			deliverySlices,
+			fontFamily,
+			fontPath,
+			formats,
+			inputs: [...args],
+			noOriginal,
+			outDir,
+			preset,
+			subsetOptions,
+			variationCoordinates
+		});
+		return;
+	}
+	if (args.length === 0) {
+		const foundConfigPath = await findConfig();
+		if (isIconfontPreset(preset)) {
+			await buildIconfontConfigCommand(foundConfigPath, {
+				fontFamily,
+				fontPath,
+				formats,
+				cacheOverride,
+				cssUnicodeRanges,
+				deliverySlices,
+				outDir,
+				variationCoordinates
+			});
+			return;
+		}
+		await buildConfigCommand(foundConfigPath, {
+			basicText,
+			cacheOverride,
+			cssGlyph,
+			cssUnicodeRanges,
+			deliverySlices,
+			fontFamily,
+			fontPath,
+			formats,
+			noOriginal,
+			outDir,
+			preset,
+			subsetOptions,
+			variationCoordinates
+		});
+		return;
+	}
+	const inputPatterns = [...args];
+	const [input] = inputPatterns;
+	requireValue(input, "build requires an input font");
+	requireValue(outDir, "build requires -o, --out-dir");
+	if (isIconfontPreset(preset)) {
+		if (formats !== void 0) throw new Error("build accepts only one of --formats or --preset");
+		const inputs = await expandInputPaths(inputPatterns, process.cwd());
+		const cacheOptions = normalizeCacheOptions(void 0, process.cwd(), cacheOverride);
+		await buildIconfontCommand(inputs, outDir, fontFamily, fontPath ?? "./", [], {}, cacheOptions, cssUnicodeRanges);
+		return;
+	}
+	const inputs = await expandInputPaths(inputPatterns, process.cwd());
+	const outputFormats = filterOriginalOutput(outputFormatsFromArgs(formats, preset), noOriginal);
+	const cacheOptions = normalizeCacheOptions(void 0, process.cwd(), cacheOverride);
+	if (outputFormats.length === 0) throw new Error("build requires at least one non-original output format");
+	assertCssHasFontOutput(outputFormats);
+	await mkdir(outDir, { recursive: true });
+	for (const input of inputs) await buildDirectInput(input, outDir, {
+		basicText,
+		cacheOptions,
+		cssGlyph,
+		cssUnicodeRanges,
+		deliverySlices,
+		fontFamily,
+		fontPath,
+		outputFormats,
+		subsetOptions,
+		variationCoordinates
+	});
+}
+async function buildDirectInput(input, outDir, { basicText, cacheOptions, cssGlyph, cssUnicodeRanges, deliverySlices: deliverySlices$1, fontFamily, fontPath, outputFormats, subsetOptions, variationCoordinates }) {
+	const baseName = basename(input, extname(input));
+	const shouldSubset = !(subsetOptions.text === void 0 && subsetOptions.unicodes.length === 0 && !basicText);
+	const plugins = [normalizeToTtfPlugin(variationCoordinates)];
+	if (shouldSubset) plugins.push(glyph({
+		basicText,
+		missingGlyphs: subsetOptions.missingGlyphs,
+		text: subsetOptions.text,
+		unicodes: subsetOptions.unicodes
+	}));
+	if (deliverySlices$1.length > 0) plugins.push(deliverySlices(deliverySlices$1));
+	await optimize({
+		cache: cacheOptions,
+		css: {
+			fontFamily: fontFamily ?? baseName,
+			fontPath: fontPath ?? "./",
+			glyph: cssGlyph,
+			unicodeRanges: cssUnicodeRanges
+		},
+		input: [input],
+		outDir,
+		outputs: outputFormats,
+		plugins
+	});
+}
+function normalizeToTtfPlugin(variationCoordinates = {}) {
+	return {
+		name: "fontmin:normalize-to-ttf",
+		native: {
+			kind: "builtin",
+			name: "normalizeToTtf",
+			options: { variationCoordinates }
+		}
+	};
+}
+function reportShowTime(startedAt) {
+	if (startedAt === void 0) return;
+	const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1e6;
+	process.stdout.write(`fontmin-rs build completed in ${Math.round(elapsedMs)} ms\n`);
+}
+async function buildIconfontCommand(inputs, outDir, fontFamily, fontPath, outputs = [], css = {}, cacheOptions = normalizeCacheOptions(void 0, process.cwd()), cssUnicodeRanges = css.unicodeRanges ?? []) {
+	if (inputs.length === 0) throw new Error("build requires at least one input font");
+	const family = fontFamily ?? "iconfont";
+	const fileName = outputFileName(outputs, "ttf", "iconfont.ttf");
+	const cssFileName = outputFileName(outputs, "css", `${basename(fileName, extname(fileName))}.${css.target ?? "css"}`);
+	await optimize({
+		cache: cacheOptions,
+		css: {
+			...css,
+			asFileName: css.asFileName ?? true,
+			fontFamily: family,
+			fontPath,
+			glyph: true,
+			unicodeRanges: cssUnicodeRanges
+		},
+		input: inputs,
+		outDir,
+		outputs: [{
+			fileName,
+			format: "ttf"
+		}, {
+			fileName: cssFileName,
+			format: "css"
+		}],
+		plugins: [svgs2ttf({ fontName: family })]
+	});
+}
+async function buildConfigCommand(configPath, { basicText, cacheOverride, cssGlyph, cssUnicodeRanges = [], deliverySlices = [], fontFamily, fontPath, formats, inputs: inputOverrides = [], noOriginal, outDir: outDirOverride, preset, subsetOptions, variationCoordinates = {} } = {}) {
+	const resolvedConfigPath = resolve(configPath);
+	const config = await loadConfig(resolvedConfigPath);
+	const cwd = typeof config.cwd === "string" ? resolve(config.cwd) : dirname(resolvedConfigPath);
+	const inputs = inputOverrides.length > 0 ? inputOverrides : config.input ?? [];
+	const outDir = resolve(cwd, outDirOverride ?? config.outDir ?? "build");
+	const outputFormats = outputFormatsForConfig(config.outputs, {
+		formats,
+		noOriginal,
+		preset
+	});
+	const cacheOptions = normalizeCacheOptions(config.cache, cwd, cacheOverride);
+	const resolvedVariationCoordinates = {
+		...config.otf?.variationCoordinates,
+		...variationCoordinates
+	};
+	if (inputs.length === 0) throw new Error("build config requires at least one input");
+	const inputPaths = await expandInputPaths(inputs, cwd);
+	if (fontFamily !== void 0 || fontPath !== void 0 || cssGlyph === true || cssUnicodeRanges.length > 0) config.css = {
+		...config.css,
+		...cssGlyph === true && { glyph: true },
+		...cssUnicodeRanges.length > 0 && { unicodeRanges: cssUnicodeRanges },
+		...fontFamily !== void 0 && { fontFamily },
+		...fontPath !== void 0 && { fontPath }
+	};
+	if (deliverySlices.length > 0) config.delivery = { slices: deliverySlices };
+	applySubsetOverrides(config, {
+		basicText,
+		subsetOptions
+	});
+	if (config.clean === true) await cleanOutputDirectory(cwd, outDir, [resolvedConfigPath, ...inputPaths]);
+	await mkdir(outDir, { recursive: true });
+	for (const inputPath of inputPaths) await buildConfigInput(inputPath, outDir, outputFormats, config, cwd, cacheOptions, resolvedVariationCoordinates);
+}
+async function buildIconfontConfigCommand(configPath, { cacheOverride, cssUnicodeRanges = [], deliverySlices = [], fontFamily, fontPath, formats, inputs: inputOverrides = [], outDir: outDirOverride }) {
+	if (formats !== void 0) throw new Error("build accepts only one of --formats or --preset");
+	const resolvedConfigPath = resolve(configPath);
+	const config = await loadConfig(resolvedConfigPath);
+	const cwd = typeof config.cwd === "string" ? resolve(config.cwd) : dirname(resolvedConfigPath);
+	const outDir = resolve(cwd, outDirOverride ?? config.outDir ?? "build");
+	const inputs = await expandConfigInputPaths(inputOverrides.length > 0 ? inputOverrides : config.input ?? [], cwd);
+	const css = config.css ?? {};
+	const cacheOptions = normalizeCacheOptions(config.cache, cwd, cacheOverride);
+	if (cssUnicodeRanges.length > 0) css.unicodeRanges = cssUnicodeRanges;
+	if (deliverySlices.length > 0) config.delivery = { slices: deliverySlices };
+	if (config.clean === true) await cleanOutputDirectory(cwd, outDir, [resolvedConfigPath, ...inputs]);
+	await buildIconfontCommand(inputs, outDir, fontFamily ?? css.fontFamily, fontPath ?? css.fontPath ?? "./", config.outputs ?? [], css, cacheOptions, css.unicodeRanges);
+}
+function expandConfigInputPaths(inputs, cwd) {
+	return expandInputPaths(inputs, cwd);
+}
+async function expandInputPaths(inputs, cwd) {
+	if (inputs.length === 0) throw new Error("build config requires at least one input");
+	const paths = [];
+	for (const input of inputs) {
+		if (typeof input !== "string") throw new TypeError("build config input entries must be file paths");
+		paths.push(...await expandInputPath(input, cwd));
+	}
+	return paths;
+}
+function outputFileName(outputs, format, fallback) {
+	const output = outputs.find((output) => output?.format === format);
+	if (typeof output?.fileName === "string") return output.fileName;
+	if (typeof output?.ext === "string") return `${basename(fallback, extname(fallback))}.${normalizeExtension(output.ext)}`;
+	return fallback;
+}
+function applySubsetOverrides(config, { basicText, subsetOptions } = {}) {
+	if (subsetOptions === void 0 || subsetOptions.text === void 0 && subsetOptions.unicodes.length === 0 && basicText !== true && subsetOptions.missingGlyphs === void 0) return;
+	config.subset = {
+		...config.subset,
+		...subsetOptions.text !== void 0 && { text: subsetOptions.text },
+		...subsetOptions.unicodes.length > 0 && { unicodes: subsetOptions.unicodes },
+		...basicText === true && { basicText },
+		...subsetOptions.missingGlyphs !== void 0 && { missingGlyphs: subsetOptions.missingGlyphs }
+	};
+}
+async function buildConfigInput(input, outDir, outputFormats, config, cwd, cacheOptions, variationCoordinates) {
+	const subset = await resolveSubsetTextFile(config.subset ?? {}, cwd);
+	const baseName = basename(input, extname(input));
+	const slices = normalizeDeliverySlices(config.delivery?.slices ?? []);
+	const plugins = [normalizeToTtfPlugin(variationCoordinates)];
+	if (hasSubsetRequest(subset)) plugins.push(glyph(subset));
+	if (slices.length > 0) plugins.push(deliverySlices(slices));
+	if (Array.isArray(config.plugins)) plugins.push(...config.plugins);
+	await optimize({
+		cache: cacheOptions,
+		css: {
+			...config.css,
+			fontFamily: config.css?.fontFamily ?? baseName
+		},
+		cwd,
+		input: [input],
+		outDir,
+		outputs: outputConfigsForFormats(config.outputs, outputFormats),
+		plugins,
+		preserveOriginal: config.preserveOriginal,
+		runtime: config.runtime
+	});
+}
+function hasSubsetRequest(subset) {
+	return subset.text !== void 0 || (subset.unicodes?.length ?? 0) > 0 || (subset.unicodeRanges?.length ?? 0) > 0 || subset.basicText === true;
+}
+function outputConfigsForFormats(outputs, formats) {
+	return formats.map((format) => {
+		const configuredOutput = outputs?.find((output) => {
+			return (typeof output === "string" ? output : output.format) === format;
+		});
+		if (typeof configuredOutput === "object" && configuredOutput !== null) return configuredOutput;
+		return format;
+	});
+}
+function normalizeCacheOptions(options, cwd, override) {
+	const configuredDir = typeof options === "object" && options !== null && typeof options.dir === "string" ? options.dir : DEFAULT_CACHE_DIR;
+	if (override === true) return {
+		dir: resolve(cwd, configuredDir),
+		enabled: true
+	};
+	if (override === false || options === void 0 || options === false) return {
+		dir: resolve(cwd, configuredDir),
+		enabled: false
+	};
+	if (options === true) return {
+		dir: resolve(cwd, DEFAULT_CACHE_DIR),
+		enabled: true
+	};
+	return {
+		dir: resolve(cwd, options.dir ?? DEFAULT_CACHE_DIR),
+		enabled: options.enabled ?? true
+	};
+}
+function cacheOverrideFromFlags(cache, noCache) {
+	if (cache) return true;
+	if (noCache) return false;
+}
+async function inspectCommand(args) {
+	const json = readFlag(args, ["--json"]);
+	assertNoUnexpectedArgs(args);
+	const [input] = args;
+	requireValue(input, "inspect requires an input font");
+	const info = inspect(await readFile(input));
+	if (json) process.stdout.write(`${JSON.stringify(info, void 0, 2)}\n`);
+	else process.stdout.write(`${input}: ${info.format}, ${info.size} bytes, ${info.metadata.glyphCount} glyphs\n`);
+}
+async function initCommand() {
+	try {
+		await writeFile(INIT_CONFIG_FILE, DEFAULT_INIT_CONFIG, { flag: "wx" });
+	} catch (error) {
+		if (hasErrorCode(error, "EEXIST")) throw new Error(`${INIT_CONFIG_FILE} already exists`, { cause: error });
+		throw error;
+	}
+	process.stdout.write(`created ${INIT_CONFIG_FILE}\n`);
+}
+async function subsetOptionsFromArgs(args) {
+	const subset = await resolveSubsetTextFile({
+		text: readOption(args, ["-t", "--text"]),
+		textFile: readOption(args, ["--text-file"]),
+		unicodes: parseUnicodes(readOption(args, ["--unicodes"]))
+	}, process.cwd());
+	return {
+		...subset,
+		missingGlyphs: parseMissingGlyphPolicy(readOption(args, ["--missing-glyphs"])),
+		unicodes: subset.unicodes ?? []
+	};
+}
+function subsetWithCoverage(contents, options) {
+	const policy = options.missingGlyphs ?? "warn";
+	if (policy === "warn") {
+		const warning = missingGlyphMessage(analyzeCoverage(contents, options));
+		if (warning !== void 0 && emitWarnings) process.stderr.write(`warning: ${warning}\n`);
+	}
+	return subsetTtf(contents, {
+		...options,
+		missingGlyphs: policy === "warn" ? "ignore" : policy
+	});
+}
+function missingGlyphMessage(report) {
+	if (report.missing.length === 0) return;
+	const visible = report.missing.slice(0, 16).map((codePoint) => `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`).join(", ");
+	const remaining = report.missing.length - 16;
+	return `missing glyphs for requested Unicode code points: ${visible}${remaining > 0 ? `, and ${remaining} more` : ""}`;
+}
+function parseMissingGlyphPolicy(value) {
+	if (value === void 0) return;
+	const policy = value.trim().toLowerCase();
+	if (policy === "ignore" || policy === "warn" || policy === "error") return policy;
+	throw new Error(`missing glyph policy must be \`ignore\`, \`warn\`, or \`error\`: ${value}`);
+}
+async function resolveSubsetTextFile(subset, cwd) {
+	if (subset.textFile === void 0) return subset;
+	const fileText = await readFile(resolve(cwd, subset.textFile), "utf8");
+	return {
+		...subset,
+		text: subset.text === void 0 ? fileText : `${subset.text}${fileText}`
+	};
+}
+async function expandInputPath(input, cwd) {
+	if (!isGlobPattern(input)) return [resolve(cwd, input)];
+	const matches = await glob(input, {
+		absolute: true,
+		cwd,
+		onlyFiles: true
+	});
+	if (matches.length === 0) throw new Error(`fontmin-rs input glob matched no files: ${input}`);
+	return matches.sort((left, right) => left.localeCompare(right));
+}
+function isGlobPattern(path) {
+	return /[*?[\]{}]/u.test(path);
+}
+function hasErrorCode(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+async function cleanOutputDirectory(cwd, outDir, protectedPaths) {
+	const root = resolve(cwd);
+	const target = resolve(outDir);
+	const targetIsInsideRoot = pathContains(root, target) && target !== root;
+	const targetContainsInput = protectedPaths.some((path) => pathContains(target, resolve(path)));
+	if (target === parse(target).root || pathContains(target, root) || targetContainsInput) throw new Error(`refusing to clean output directory ${target} because it is the project directory, an input ancestor, or a filesystem root`);
+	try {
+		const [realRoot, realTarget, ...realProtectedPaths] = await Promise.all([
+			realpath(root),
+			realpath(target),
+			...protectedPaths.map((path) => realpath(resolve(path)))
+		]);
+		if (realTarget === parse(realTarget).root || pathContains(realTarget, realRoot) || realProtectedPaths.some((path) => pathContains(realTarget, path)) || targetIsInsideRoot && !pathContains(realRoot, realTarget)) throw new Error(`refusing to clean output directory ${target} because its resolved location is unsafe for project ${root}`);
+	} catch (error) {
+		if (!hasErrorCode(error, "ENOENT")) throw error;
+	}
+	await rm(target, {
+		recursive: true,
+		force: true
+	});
+}
+function pathContains(parent, candidate) {
+	const childPath = relative(parent, candidate);
+	return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute(childPath);
+}
+function normalizeExtension(extension) {
+	const normalized = extension.replace(/^\.+/u, "");
+	if (normalized.length === 0 || normalized === ".." || normalized.includes("/") || normalized.includes("\\")) throw new Error(`output extension must be a file extension: ${extension}`);
+	return normalized;
+}
+function outputFormatsFromConfig(outputs) {
+	if (outputs === void 0) return [
+		"eot",
+		"woff",
+		"woff2",
+		"svg",
+		"css"
+	];
+	return parseFormats(outputs.map((output) => typeof output === "string" ? output : output.format).join(","));
+}
+function outputFormatsForConfig(outputs, { formats, noOriginal, preset }) {
+	const filtered = filterOriginalOutput(formats === void 0 && preset === void 0 ? outputFormatsFromConfig(outputs) : outputFormatsFromArgs(formats, preset), noOriginal);
+	if (filtered.length === 0) throw new Error("build requires at least one non-original output format");
+	assertCssHasFontOutput(filtered);
+	return filtered;
+}
+function assertCssHasFontOutput(formats) {
+	if (formats.includes("css") && formats.every((format) => format === "css")) throw new Error("build CSS output requires at least one font format");
+}
+function outputFormatsFromArgs(formats, preset) {
+	if (formats !== void 0 && preset !== void 0) throw new Error("build accepts only one of --formats or --preset");
+	if (formats !== void 0) return parseFormats(formats);
+	if (preset !== void 0) return outputFormatsFromPreset(preset);
+	throw new Error("build requires --formats or --preset");
+}
+function outputFormatsFromPreset(value) {
+	const preset = value.trim().toLowerCase();
+	if (preset === "compat") return [
+		"eot",
+		"svg",
+		"woff",
+		"woff2",
+		"css"
+	];
+	if (preset === "modern-web") return [
+		"woff2",
+		"woff",
+		"css"
+	];
+	if (preset === "iconfont") return ["ttf", "css"];
+	throw new Error(`unsupported preset \`${preset}\``);
+}
+function isIconfontPreset(value) {
+	return value?.trim().toLowerCase() === "iconfont";
+}
+function filterOriginalOutput(formats, noOriginal) {
+	return noOriginal ? formats.filter((format) => format !== "ttf") : formats;
+}
+function parseUnicodeRanges(values) {
+	return values.map((value) => parseUnicodeRange(value));
+}
+function formatUnicodeEndpoint(codePoint) {
+	return codePoint.toString(16).toUpperCase().padStart(4, "0");
+}
+function parseUnicodeRange(value) {
+	const match = /^u\+(?<start>[0-9a-f]{1,6})(?:-(?<end>[0-9a-f]{1,6}))?$/iu.exec(value);
+	if (match?.groups === void 0) throw new Error(`invalid Unicode range: ${value}`);
+	const start = Number.parseInt(match.groups.start, 16);
+	const end = Number.parseInt(match.groups.end ?? match.groups.start, 16);
+	if (start > end || end > 1114111 || start <= 57343 && end >= 55296) throw new Error(`invalid Unicode range: ${value}`);
+	return start === end ? `U+${formatUnicodeEndpoint(start)}` : `U+${formatUnicodeEndpoint(start)}-${formatUnicodeEndpoint(end)}`;
+}
+function parseDeliverySlices(values) {
+	const slices = [];
+	for (const value of values) {
+		const separator = value.indexOf(":");
+		if (separator === -1) throw new Error(`delivery slice must use NAME:RANGE[,RANGE...]: ${value}`);
+		const name = value.slice(0, separator);
+		const unicodeRanges = value.slice(separator + 1).split(",");
+		const existing = slices.find((slice) => slice.name === name);
+		if (existing === void 0) slices.push({
+			name,
+			unicodeRanges
+		});
+		else existing.unicodeRanges.push(...unicodeRanges);
+	}
+	return normalizeDeliverySlices(slices);
+}
+function normalizeDeliverySlices(values) {
+	if (!Array.isArray(values)) throw new TypeError("delivery slices must be an array");
+	const names = /* @__PURE__ */ new Set();
+	return values.map((value, index) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`delivery slice ${index + 1} must be an object`);
+		const { name, unicodeRanges } = value;
+		if (typeof name !== "string" || name.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(name)) throw new Error(`invalid delivery slice name: ${name}`);
+		if (names.has(name)) throw new Error(`duplicate delivery slice name: ${name}`);
+		if (!Array.isArray(unicodeRanges) || unicodeRanges.length === 0) throw new Error(`delivery slice \`${name}\` requires at least one Unicode range`);
+		names.add(name);
+		return {
+			name,
+			unicodeRanges: parseUnicodeRanges(unicodeRanges)
+		};
+	});
+}
+function parseUnicodes(value) {
+	if (value === void 0) return [];
+	const unicodes = value.split(",").map((item) => parseUnicodeCodePoint(item));
+	if (unicodes.length === 0) throw new Error("expected at least one unicode code point");
+	return unicodes;
+}
+function parseUnicodeCodePoint(value) {
+	const item = value.trim();
+	if (item.length === 0) throw new Error("empty unicode code point in --unicodes");
+	let digits = item;
+	let radix = 10;
+	if (/^(?:0x|u\+)/iu.test(item)) {
+		digits = item.slice(2);
+		radix = 16;
+	}
+	if (!(radix === 16 ? /^[0-9a-f]+$/iu : /^[0-9]+$/u).test(digits)) throw new Error(`invalid unicode code point \`${item}\``);
+	const codePoint = Number.parseInt(digits, radix);
+	if (!Number.isInteger(codePoint) || codePoint > 4294967295) throw new Error(`invalid unicode code point \`${item}\``);
+	return codePoint;
+}
+function parseFormats(value) {
+	const formats = value.split(",").map((format) => format.trim().toLowerCase()).filter((format) => format.length > 0);
+	if (formats.length === 0) throw new Error("expected at least one output format");
+	for (const format of formats) if (format !== "ttf" && format !== "woff" && format !== "woff2" && format !== "eot" && format !== "svg" && format !== "css") throw new Error(`unsupported output format \`${format}\``);
+	return formats;
+}
+function convertFont(contents, format, options = {}) {
+	const normalized = format.toLowerCase();
+	if (normalized === "ttf") {
+		if (isTtf(contents)) return contents;
+		if (isWoff(contents)) return woffToTtf(contents);
+		if (isWoff2(contents)) return woff2ToTtf(contents);
+		if (isEot(contents)) return eotToTtf(contents);
+		if (isOtf(contents)) return otfToTtf(contents, { variationCoordinates: options.variationCoordinates ?? {} });
+		throw new Error("unsupported input format for TTF conversion");
+	}
+	const ttf = convertFont(contents, "ttf", options);
+	if (normalized === "woff") return ttfToWoff(ttf);
+	if (normalized === "woff2") return ttfToWoff2(ttf);
+	if (normalized === "eot") return ttfToEot(ttf);
+	if (normalized === "svg") return ttfToSvg(ttf);
+	throw new Error(`unsupported output format \`${format}\``);
+}
+function isTtf(contents) {
+	return contents[0] === 0 && contents[1] === 1 && contents[2] === 0 && contents[3] === 0 || contents.subarray(0, 4).toString("ascii") === "true";
+}
+function isOtf(contents) {
+	return contents.subarray(0, 4).toString("ascii") === "OTTO";
+}
+function isWoff(contents) {
+	return contents.subarray(0, 4).toString("ascii") === "wOFF";
+}
+function isWoff2(contents) {
+	return contents.subarray(0, 4).toString("ascii") === "wOF2";
+}
+function isEot(contents) {
+	return contents.byteLength >= 12 && (contents[8] === 1 && contents[9] === 0 && contents[10] === 2 && contents[11] === 0 || contents[8] === 2 && contents[9] === 0 && contents[10] === 2 && contents[11] === 0);
+}
+function readOption(args, names) {
+	const index = args.findIndex((arg) => names.includes(arg));
+	if (index === -1) return;
+	const [name] = args.splice(index, 1);
+	const [value] = args.splice(index, 1);
+	if (value === void 0 || value.startsWith("-")) throw new Error(`${name} requires a value`);
+	return value;
+}
+function readOptions(args, names) {
+	const values = [];
+	while (args.some((arg) => names.includes(arg))) values.push(readOption(args, names));
+	return values;
+}
+function readFlag(args, names) {
+	const index = args.findIndex((arg) => names.includes(arg));
+	if (index === -1) return false;
+	args.splice(index, 1);
+	return true;
+}
+function assertNoUnknownOptions(args) {
+	const option = args.find((arg) => arg.startsWith("-"));
+	if (option !== void 0) throw new Error(`unknown option \`${option}\``);
+}
+function assertNoUnexpectedArgs(args, maximumPositionals = 1) {
+	assertNoUnknownOptions(args);
+	if (args.length > maximumPositionals) throw new Error(`unexpected argument \`${args[maximumPositionals]}\``);
+}
+function parseVariations(values) {
+	const coordinates = {};
+	for (const value of values) {
+		const separator = value.indexOf("=");
+		if (separator === -1) throw new Error(`invalid variation \`${value}\`; expected TAG=VALUE`);
+		const tag = value.slice(0, separator);
+		const rawNumber = value.slice(separator + 1);
+		if (tag.length !== 4 || [...tag].some((character) => (character.codePointAt(0) ?? 128) > 127)) throw new Error(`invalid variation axis \`${tag}\`; expected four ASCII characters`);
+		if (Object.hasOwn(coordinates, tag)) throw new Error(`duplicate variation axis \`${tag}\``);
+		const number = Number(rawNumber);
+		if (rawNumber.length === 0 || !Number.isFinite(number)) throw new Error(`invalid variation value \`${rawNumber}\` for axis \`${tag}\``);
+		coordinates[tag] = number;
+	}
+	return coordinates;
+}
+function requireValue(value, message) {
+	if (value === void 0 || value.length === 0) throw new Error(message);
+}
+async function writeOutput(output, contents) {
+	await mkdir(dirname(output), { recursive: true });
+	await writeFile(output, contents);
+}
+function usage(stream) {
+	stream.write(`Usage:
+  fontmin-rs subset <INPUT> -o|--output <OUTPUT> (-t|--text <TEXT> | --text-file <FILE> | --unicodes <LIST> | -b|--basic-text) [--missing-glyphs <ignore|warn|error>]
+  fontmin-rs coverage <INPUT> (-t|--text <TEXT> | --text-file <FILE> | --unicodes <LIST> | -b|--basic-text) [--json]
+  fontmin-rs convert <INPUT> -f|--format <ttf|woff|woff2|eot|svg> -o|--output <OUTPUT> [--variation <TAG=VALUE>]...
+  fontmin-rs build <INPUT...> [-c|--config <CONFIG>] [-o|--out-dir <OUT_DIR>] [-t|--text <TEXT>] [--text-file <FILE>] [--unicodes <LIST>] [-b|--basic-text] [--missing-glyphs <ignore|warn|error>] [-d|--deflate-woff] [-T|--show-time] [--silent] [--cache] [--no-cache] [--css-glyph] [--css-unicode-range <RANGE>]... [--delivery-slice <NAME:RANGE[,RANGE...]>]... [--variation <TAG=VALUE>]... [--formats <FORMATS>] [--preset <compat|modern-web|iconfont>] [--no-original] [--font-family <FONT_FAMILY>] [--font-path <FONT_PATH>]
+  fontmin-rs bench <INPUT> [-t|--text <TEXT>] [--text-file <FILE>] [--unicodes <LIST>] [-b|--basic-text] [--json]
+  fontmin-rs inspect <INPUT> [--json]
+  fontmin-rs init
+  fontmin-rs doctor
+`);
+}
+//#endregion
+export { runCli };