if (value) {

try {

return JSON.parse(value);

} catch {

if (/^\s*[{[]/.test(value)) {

fatal('Could not parse JSON value `' + value + '`');

}

return value;

}

}

if (!value) return undefined;

const parsed = parseJSON(value);

return Array.isArray(parsed) ? parsed : [parsed];

const s = String(value).trim();

// Accept only non-negative whole integers

if (!/^\d+$/.test(s)) {

fatal(`Invalid number for \`--${paramCase(optionName)}: "${value}"\``);

}

const num = Number(s);

return num;

const parser = type === 'int' ? parseValidInt(key) : typeParsers[type];

if (!parser) {

fatal(`No CLI parser for option \`${key}\` (type \`${type}\`)—add the type to \`typeParsers\` in cli.js`);

}

return parser;

if (!minifyFnPromise) {

minifyFnPromise = import('./src/htmlminifier.js').then(m => m.minify);

}

return minifyFnPromise;

try {

return fs.readFileSync(file, { encoding: 'utf8' });

} catch (err) {

fatal('Cannot read ' + file + '\n' + errorMessage(err));

}

const abs = path.resolve(configPath);

const ext = path.extname(configPath).toLowerCase();

if (ext === '.json') {

try { return JSON.parse(readFile(abs).replace(/^\uFEFF/, '')); }

catch (err) { fatal(`Cannot parse config file as JSON: ${errorMessage(err)}`); }

}

if (ext === '.js' || ext === '.mjs') {

// `import()` handles both ESM and CJS .js files—Node resolves the type via the

// nearest package.json `type` field, same as it does for regular module loading

try { const mod = await import(pathToFileURL(abs).href); return 'default' in mod ? mod.default : mod; }

catch (err) { fatal(`Cannot load config file: ${errorMessage(err)}`); }

}

// Unknown extension: Try JSON, then module import

/** @type {unknown} */

let jsonErr;

try { return JSON.parse(readFile(abs).replace(/^\uFEFF/, '')); }

catch (err) { jsonErr = err; }

try { const mod = await import(pathToFileURL(abs).href); return 'default' in mod ? mod.default : mod; }

catch (esmErr) {

fatal(`Cannot read the specified config file.\nAs JSON: ${errorMessage(jsonErr)}\nAs module: ${errorMessage(esmErr)}`);

}

if (typeof value === 'string') return getParser(key, type)(value);

switch (type) {

case 'int':

return getParser(key, type)(String(value));

// A single value is wrapped as its string form is; `null` and `undefined` leave the option unset

case 'regexpArray':

return value == null ? undefined : (Array.isArray(value) ? value : [value]).map(parseRegExp);

case 'jsonArray':

return value == null ? undefined : (Array.isArray(value) ? value : [value]);

default:

return value;

}

/** @type {Record<string, any>} */

const normalized = { ...config };

// Warn about unrecognized config keys—catches typos as well as options removed in earlier versions

Object.keys(normalized).forEach(function (key) {

if (!Object.hasOwn(optionDefinitions, key) && !CONFIG_KEYS_EXTRA.has(key)) {

console.error(`Ignoring unknown or deprecated config option \`${key}\` (see \`--help\` or README for available options)`);

}

});

// Apply parsers to main options

Object.entries(optionDefinitions).forEach(function ([key, { type }]) {

if (key in normalized) {

if (type !== 'boolean' && type !== 'invertedBoolean') {

normalized[key] = parseConfigValue(key, type, normalized[key]);

}

}

});

// Handle `fileExt` in config file

if ('fileExt' in normalized) {

// Support both string (`html,htm`) and array (`["html", "htm"]`) formats

if (Array.isArray(normalized.fileExt)) {

normalized.fileExt = normalized.fileExt.join(',');

}

}

// Handle `ignoreDir` in config file

if ('ignoreDir' in normalized) {

// Support both string (`libs,vendor`) and array (`["libs", "vendor"]`) formats

if (Array.isArray(normalized.ignoreDir)) {

normalized.ignoreDir = normalized.ignoreDir.join(',');

}

}

return normalized;

/** @type {Record<string, any>} */

const options = {};

// Priority order: preset < config < CLI

// 1. Apply preset if specified (CLI `--preset` takes priority over config.preset)

const presetName = programOptions.preset || config.preset;

if (presetName) {

const preset = getPreset(presetName);

if (!preset) {

fatal(`Unknown preset “${presetName}”. Available presets: ${getPresetNames().join(', ')}`);

}

Object.assign(options, preset);

}

// 2. Apply config file options (overrides preset)

mainOptionKeys.forEach(function (key) {

if (key in config) {

options[key] = config[key];

}

});

// 3. Apply CLI options (overrides config and preset)

Object.entries(optionDefinitions).forEach(function ([key, { type }]) {

const ck = commanderOptionKey(key);

if (program.getOptionValueSource(ck) === 'cli') {

const val = programOptions[ck];

// For boolean options whose param-case name starts with `no-`, Commander treats

// the flag as a negation and stores the inverted value under the stripped key;

// invert back so the option definition key gets the intended value

options[key] = (type === 'boolean' && paramCase(key).startsWith('no-')) ? !val : val;

}

});

// 4. Surface minifier diagnostics when verbose

if (programOptions.verbose || programOptions.dry) {

options.log = createLog();

}

return options;

const where = fileLabel ? ` (${fileLabel})` : '';

return (/** @type {unknown} */ message) => {

// The hook carries the minifier’s per-call timing as well, which the run's own

// per-file statistics already cover

if (typeof message === 'string' && message.startsWith('minified in: ')) {

return;

}

// Only `continueOnMinifyError` passes `Error` objects, always after leaving the

// offending content unminified—so say that

if (message instanceof Error) {

console.error(` ${MARK_WARNING}Warning: Minification failed, content left as-is: ${message.message || message}${where}${MARK_RESET}`);

} else if (String(message).startsWith('Warning: ') || String(message).startsWith('HTML Minifier Next: ')) {

console.error(` ${MARK_WARNING}${message}${where}${MARK_RESET}`);

} else {

console.error(` ${message}${where}`);

}

};

const presetName = programOptions.preset || config.preset;

if (presetName) {

console.error(`Using preset: ${presetName}`);

}

const activeOptions = Object.entries(minifierOptions)

.filter(([k]) => program.getOptionValueSource(commanderOptionKey(k)) === 'cli')

.map(([k, v]) => (typeof v === 'boolean' ? (v ? k : `no-${k}`) : k));

if (activeOptions.length > 0) {

console.error('CLI options: ' + activeOptions.join(', '));

}

const saved = originalSize - minifiedSize;

const sign = saved >= 0 ? '-' : '+';

const percentage = originalSize ? ((Math.abs(saved) / originalSize) * 100).toFixed(1) : '0.0';

return { originalSize, minifiedSize, saved, sign, percentage };

let sizes = fileSizesByList.get(files);

if (!sizes) {

sizes = Promise.all(files.map(file => fs.promises.stat(file).then(stat => stat.size, () => 0)));

fileSizesByList.set(files, sizes);

}

return sizes;

const fileCount = files.length;

const requested = programOptions.workers;

const isVerbose = Boolean(programOptions.verbose || programOptions.dry);

// Whether the run went wide is worth saying, since the default weighs the file

// count and the bytes there are to share out, neither of which the caller sees

const inProcess = () => {

if (isVerbose) console.error('Worker threads: none (minifying in-process)');

return null;

};

// `availableParallelism` reports what this process may actually use, which under a

// CPU affinity mask—a container, commonly—is less than the machine’s core count

const isDefault = requested === undefined;

const size = isDefault

? Math.max(1, Math.min(Math.floor(os.availableParallelism() / 2), WORKERS_MAX))

: requested;

// The file count only decides the default; asking for workers outright is the

// caller’s judgment to make, whatever the run looks like

if (size <= 1) {

return inProcess();

}

if (isDefault && fileCount < FILES_PER_RUN_MIN) {

// `stat()` is cheaper than starting workers, and a pooled run reuses the sizes

const sizes = await getFileSizes(files);

// No single file is split across workers, so the largest one sets a floor no

// pool can beat; what the rest carry is the work there is to share out

const parallelBytes = sizes.reduce((sum, byteSize) => sum + byteSize, 0) - Math.max(0, ...sizes);

if (parallelBytes < PARALLEL_BYTES_MIN) {

return inProcess();

}

}

// `log` is a closure over this process’s console and is rebuilt inside the worker;

// anything else unclonable (such as a function from a module config) stays in-process

const { log, ...options } = createOptions();

try {

structuredClone(options);

} catch {

return inProcess();

}

// A pool this small has nothing to share out and still pays for its workers, so an

// explicit request for them lands in-process as `--workers=1` does

const poolSize = Math.min(size, fileCount);

if (poolSize <= 1) {

return inProcess();

}

try {

const { createFilePool } = await import('./src/lib/file-pool.js');

const pool = createFilePool({

options,

size: poolSize,

// `log` is only set when the run asks for diagnostics

onLog: log

? (/** @type {string} */ message, /** @type {boolean} */ isError, /** @type {string} */ file) =>

createLog(path.relative(process.cwd(), file))(isError ? new Error(message) : message)

: undefined

});

if (isVerbose) console.error(`Worker threads: ${poolSize}`);

return pool;

} catch {

return inProcess();

}

const { getCacheStats } = await import('./src/htmlminifier.js');

const cacheStats = getCacheStats();

/** @type {Record<string, string>} */

const labels = { css: 'CSS', js: 'JS', svg: 'SVG' };

/** @type {string[]} */

const lines = [];

for (const [key, { gets, hits, size, limit }] of Object.entries(cacheStats)) {

if (gets === 0) continue;

const misses = gets - hits;

lines.push(` ${labels[key]} cache: ${hits.toLocaleString()} hit${hits === 1 ? '' : 's'}, ${misses.toLocaleString()} miss${misses === 1 ? '' : 'es'}, ${size.toLocaleString()}/${limit.toLocaleString()} entries`);

}

if (lines.length === 0) return;

console.error('Cache stats:');

lines.forEach(line => console.error(line));

const data = await fs.promises.readFile(inputFile, { encoding: 'utf8' }).catch(err => {

fatal('Cannot read ' + inputFile + '\n' + errorMessage(err));

});

let minified;

try {

const minify = await getMinify();

const fileOptions = createOptions();

if (fileOptions.log) {

fileOptions.log = createLog(path.relative(process.cwd(), inputFile));

}

minified = await minify(data, fileOptions);

} catch (err) {

fatal('Minification error on ' + inputFile + '\n' + errorMessage(err));

}

const stats = calculateStats(data, minified);

// Show stats if dry run or verbose mode

if (isDryRun || isVerbose) {

console.error(` ${MARK_SUCCESS}✓${MARK_RESET} ${path.relative(process.cwd(), inputFile)}: ${stats.originalSize.toLocaleString()} → ${stats.minifiedSize.toLocaleString()} bytes (${stats.sign}${Math.abs(stats.saved).toLocaleString()}, ${stats.percentage}%)`);

}

if (isDryRun) {

return { originalSize: stats.originalSize, minifiedSize: stats.minifiedSize, saved: stats.saved };

}

await writeFileAtomic(outputFile, minified).catch(err => {

fatal('Cannot write ' + outputFile + '\n' + err.message);

});

return { originalSize: stats.originalSize, minifiedSize: stats.minifiedSize, saved: stats.saved };

if (!fileExt) return [];

if (fileExt.trim() === '*') return ['*'];

const list = fileExt

.split(',')

.map(ext => ext.trim().replace(/^\.+/, '').toLowerCase())

.filter(ext => ext.length > 0);

return [...new Set(list)];

// Wildcard: process all files

if (fileExtensions.includes('*')) {

return true;

}

const fileExt = path.extname(filename).replace(/^\.+/, '').toLowerCase();

return fileExtensions.includes(fileExt);

if (!patterns) return [];