@rzl-zone/build-tools 0.0.5

package/dist/index.js

@@ -0,0 +1,1641 @@
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.5`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+
+import { S as toStringSet, _ as isUndefined, a as isError, d as isNumber, g as isString, h as isSet, i as isBoolean, l as isNonEmptyString, m as isRegExp, n as flattenStrings, p as isPlainObject, r as isArray, v as normalizeSpaces, x as toObjectSet, y as safeStableStringify } from "./helper-BdjaR8Yv.js";
+import { a as resolvePatternOptions, i as defaultPatternOptions, n as fsExtra, o as sourceOfPatternOptions, r as ICONS, t as fastGlob } from "./server-CWrDd29Y.js";
+import { t as CommandIdentity } from "./identity-BJ0QX7AJ.js";
+import { a as joinInline, i as formatOptionValue, l as picocolors, n as EOL, o as joinLines, s as joinLinesLoose, u as plural } from "./client-XhkdKJ4d.js";
+import { n as getPackageJson, t as generatePackageBanner } from "./package-banner-BzheZbxy.js";
+import "@rzl-zone/node-only";
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import path from "node:path";
+import * as acorn from "acorn";
+import { ChildProcess, spawn } from "node:child_process";
+function isLogLevel(value) {
+	return typeof value === "string" && value in LOG_LEVEL_PRIORITY;
+}
+const DEFAULT_LOG_LEVEL = "info";
+const VERBOSE_LOG = ["info", "debug"];
+const LOG_LEVEL_PRIORITY = Object.freeze({
+	silent: 0,
+	error: 1,
+	info: 2,
+	debug: 3
+});
+function resolveLogVerbosity(options, fallback = DEFAULT_LOG_LEVEL) {
+	const input = options?.logLevel;
+	if (isLogLevel(input)) return input;
+	return isLogLevel(fallback) ? fallback : DEFAULT_LOG_LEVEL;
+}
+function canLog(current, target, fallbackIfInvalid = DEFAULT_LOG_LEVEL) {
+	const fallbackLog = isLogLevel(fallbackIfInvalid) ? fallbackIfInvalid : DEFAULT_LOG_LEVEL;
+	const resolvedCurrent = isLogLevel(current) ? current : fallbackLog;
+	return (isString(target) ? [target] : isArray(target) ? target : [fallbackLog]).some((level) => LOG_LEVEL_PRIORITY[resolvedCurrent] >= LOG_LEVEL_PRIORITY[level]);
+}
+const DEFAULT_CLEAN_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedCleanPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_CLEAN_PATTERN_POLICY);
+const DEFAULT_CLEAN_OPTION = {
+	removeSourceMap: false,
+	removeRegion: true,
+	removeAdjacentEmptyLines: false,
+	patternOptions: resolvedCleanPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const USE_STRICT_RE = /^['"]use strict['"];?\s*$/gm;
+const SHEBANG_RE = /^#![^\r\n]*\r?\n/;
+const BANNER_RE = /^(?:\/\*![\s\S]*?\*\/\s*)+/;
+const JS_OUTPUT_FILE_RE = /\.(?:js|mjs|cjs|esm\.js|module\.js)$/i;
+const TS_DECLARATION_FILE_RE = /\.d\.(?:ts|mts|cts)$/i;
+const REGION_RE = /^[ \t]*\/\/\s*#(?:end)?region\b.*$/i;
+const SOURCE_PATH_RE = /^[ \t]*\/\/\s*(?:\.\.\/|\.\/)*[^ \n]*?(?:src|node_modules)\//;
+const ESLINT_RE = /^[ \t]*\/\/\s*eslint/;
+const SOURCE_MAP_RE = /^[ \t]*\/\/[#@]\s*sourceMappingURL=\S+\s*$/;
+const IMPORTANT_COMMENT = /^!|@license|@preserve|@copyright|@cc_on|@__(PURE|INLINE|NOINLINE|NO_SIDE_EFFECTS)__/;
+const EMPTY_LINE_RE = /^\s*$/;
+function shouldRemoveDocRuntime(commentText) {
+	const text = commentText.trim();
+	const hasRemoveDocRuntime = /[@]removeDocRuntime\b/.test(text);
+	const hasKeepDocRuntime = /[@]keepDocRuntime\b/.test(text);
+	if (hasRemoveDocRuntime && hasKeepDocRuntime) return true;
+	if (hasKeepDocRuntime) return false;
+	if (hasRemoveDocRuntime) return true;
+}
+const NON_COMMENTABLE_FILE_RE = /(?:^|[\\/])(?:package-lock\.json|composer\.lock|bun\.lockb)$|\.(?:json|map|webmanifest|har|geojson|topojson|tsbuildinfo)$/i;
+function hasExecutableCode(content) {
+	const { body } = extractAndHoistBanner(content.trim());
+	const { rest } = extractDirectives(body);
+	return isNonEmptyString(rest);
+}
+const defaultCommentOptions = {
+	removeRegion: true,
+	removeSourceMap: false
+};
+const isTargetComment = (line, options = defaultCommentOptions) => {
+	if (!isNonEmptyString(line)) return false;
+	if (SOURCE_PATH_RE.test(line)) return true;
+	if (ESLINT_RE.test(line)) return true;
+	if (options.removeRegion && REGION_RE.test(line)) return true;
+	if (options.removeSourceMap && SOURCE_MAP_RE.test(line)) return true;
+	return false;
+};
+const isAdjacentToTarget = (arr, index, options = defaultCommentOptions) => {
+	return isTargetComment(arr[index - 1], options) || isTargetComment(arr[index + 1], options);
+};
+function detectModuleKindFromContent(code) {
+	let hasImport = false;
+	let hasExport = false;
+	let hasModuleExports = false;
+	let hasExportsMutation = false;
+	let hasRequire = false;
+	let hasDefine = false;
+	let hasUMDEnvCheck = false;
+	let hasTopLevelIIFE = false;
+	const ast = parse(code, {
+		sourceType: "unambiguous",
+		plugins: ["typescript", "jsx"]
+	});
+	(traverseImport.default ?? traverseImport)(ast, {
+		Program(path) {
+			for (const node of path.node.body) {
+				if (t.isExpressionStatement(node) && t.isCallExpression(node.expression) && (t.isFunctionExpression(node.expression.callee) || t.isArrowFunctionExpression(node.expression.callee))) hasTopLevelIIFE = true;
+				if (t.isVariableDeclaration(node)) {
+					for (const decl of node.declarations) if (decl.init && t.isCallExpression(decl.init) && (t.isFunctionExpression(decl.init.callee) || t.isArrowFunctionExpression(decl.init.callee))) hasTopLevelIIFE = true;
+				}
+			}
+		},
+		ImportDeclaration() {
+			hasImport = true;
+		},
+		ExportNamedDeclaration() {
+			hasExport = true;
+		},
+		ExportDefaultDeclaration() {
+			hasExport = true;
+		},
+		AssignmentExpression(path) {
+			const left = path.node.left;
+			if (t.isMemberExpression(left)) {
+				if (t.isIdentifier(left.object) && t.isIdentifier(left.property)) {
+					if (left.object.name === "module" && left.property.name === "exports") hasModuleExports = true;
+					if (left.object.name === "exports") hasExportsMutation = true;
+				}
+			}
+		},
+		CallExpression(path) {
+			const { callee, arguments: args } = path.node;
+			if (args.length > 0 && t.isIdentifier(args[0]) && args[0].name === "exports") hasExportsMutation = true;
+			if (t.isIdentifier(callee)) {
+				if (callee.name === "require") hasRequire = true;
+				if (callee.name === "define") hasDefine = true;
+			}
+		},
+		UnaryExpression(path) {
+			if (path.node.operator === "typeof" && t.isIdentifier(path.node.argument) && (path.node.argument.name === "exports" || path.node.argument.name === "module")) hasUMDEnvCheck = true;
+		}
+	});
+	const isCJS = hasModuleExports || hasExportsMutation;
+	if (hasUMDEnvCheck && (hasDefine || isCJS)) return "umd";
+	if (isCJS) return "cjs";
+	if (hasExport || hasImport) return "esm";
+	if (hasTopLevelIIFE && !isCJS && !hasImport && !hasExport) return "iife";
+	if (hasRequire) return "cjs";
+	return "esm";
+}
+function extractAndHoistBanner(content) {
+	let rest = content;
+	let shebang = "";
+	let banner = "";
+	const shebangMatch = rest.match(SHEBANG_RE);
+	if (shebangMatch && shebangMatch.index === 0) {
+		shebang = shebangMatch[0];
+		rest = rest.slice(shebang.length);
+	}
+	const bannerMatch = rest.match(BANNER_RE);
+	if (bannerMatch && bannerMatch.index === 0) {
+		banner = bannerMatch[0];
+		rest = rest.slice(banner.length);
+	}
+	return {
+		shebang,
+		banner,
+		body: rest.replace(/^\s+/, "")
+	};
+}
+function extractDirectives(code) {
+	const match = code.match(/^((?:(?:"use\s+\w+"|'use\s+\w+');\s*)+)/);
+	return {
+		directives: match?.[1] ?? "",
+		rest: code.slice(match?.[1]?.length ?? 0)
+	};
+}
+function stripUseStrict(content, { trimStart = true, trimEnd = false } = {}) {
+	const result = content.replace(USE_STRICT_RE, "");
+	if (trimStart) result.trimStart();
+	if (trimEnd) result.trimEnd();
+	return result;
+}
+const sourceOf = (value, defaultValue) => {
+	return Object.is(value, defaultValue) ? "default" : "overridden";
+};
+const BUILD_LOGGER = {
+	SOURCE_OF: sourceOf,
+	OPTIONS(label, value, source, isRequired) {
+		const sourceLabel = !isRequired && source ? source === "default" ? picocolors.blueBright(` (${source})`) : picocolors.yellowBright(` (${source})`) : "";
+		console.log(picocolors.dim("  - ") + normalizeSpaces(picocolors.bold(label || "`⚠️ Label Unset!!!`") + picocolors.dim(": ") + formatOptionValue(value) + picocolors.italic(sourceLabel)));
+	},
+	SECTION(title, options = {}) {
+		const { icon = ICONS.config, indent = "" } = options;
+		console.log(picocolors.bold(`${indent}${picocolors.whiteBright(icon)} ${picocolors.underline(picocolors.cyanBright(title || "`⚠️ Unset Title!!!`"))}:`));
+	},
+	NEW_LINE(value = "") {
+		return console.log(value);
+	},
+	ON_STARTING: (options) => {
+		const { actionName, textDirectAction = "to" } = options;
+		console.log(picocolors.bold(`${picocolors.whiteBright(ICONS.start)} ${picocolors.cyanBright("Starting")} ${normalizeSpaces(`${textDirectAction} ${picocolors.underline(picocolors.blueBright(actionName))}`)}.`));
+	},
+	ON_FINISH: (options) => {
+		const { actionName, count, typeCount = "file", progress, textSuccess = "Success" } = options;
+		console.log(picocolors.bold(`${picocolors.greenBright(ICONS.success)} ${picocolors.greenBright(textSuccess)} ${normalizeSpaces(`${picocolors.underline(picocolors.blueBright(actionName))} (${picocolors.yellowBright(`${isNonEmptyString(progress) ? progress : count} ${typeCount}${count > 1 ? "(s)" : ""}`)}`)}).`));
+	},
+	ON_SKIPPING: (options) => {
+		const { actionName, reasonEndText, reasonSkipAction = "nothing left", reasonTitle = "because", reasonType = "files", textDirectAction = "to" } = options;
+		console.log(picocolors.bold(`${picocolors.yellowBright(ICONS.warn)} ${picocolors.yellowBright("Skipping")} ${normalizeSpaces(`${picocolors.underline(picocolors.blueBright(actionName))} ${picocolors.white(reasonTitle)} ${picocolors.redBright(reasonSkipAction)} ${reasonType} ${textDirectAction} ${picocolors.redBright(reasonEndText)}`)}.`));
+	},
+	ON_ERROR: (options) => {
+		const { actionName, textDirectAction = "to", error } = options;
+		const errorMsg = isError(error) ? error.message : "Something went wrong";
+		console.error(picocolors.bold(`${picocolors.redBright(ICONS.error)} ${picocolors.redBright("Error")} ${normalizeSpaces(`${textDirectAction} ${picocolors.underline(picocolors.blueBright(actionName))},`)} ${joinLines("because: ", "", `  ${picocolors.bold(picocolors.red(ICONS.arrowRight))} ${picocolors.inverse(picocolors.red(normalizeSpaces(errorMsg)))}`)}`));
+	},
+	ON_PROCESS: (options) => {
+		const { actionName, count, nameDirect, textDirectFolder = "in" } = options;
+		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.magentaBright(textDirectFolder)} ${picocolors.bold(picocolors.underline(picocolors.blue(nameDirect)))}.`)}`)}`);
+	},
+	ON_PROCESS_COPY: (options) => {
+		const { actionName, count, copyTo, copyFrom, textFrom = "from", textArrow = "➔" } = options;
+		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.yellow(textFrom)} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyFrom)))}' ${picocolors.bold(picocolors.gray(textArrow))} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyTo)))}'.`)}`)}`);
+	},
+	ON_PROCESS_COPY_ERROR: (options) => {
+		const { actionName, count, errorReason, copyFrom, index, indexKey, textFrom = "from", textReason = "because" } = options;
+		const errorReasonText = isError(errorReason) ? errorReason.message : String(errorReason);
+		const atIndexText = isNumber(index) ? picocolors.blueBright(` (at${isNonEmptyString(indexKey) ? ` '${indexKey}' ` : " "}index: ${picocolors.magentaBright(index)}) `) : " ";
+		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.redBright(actionName)} ${picocolors.yellow(textFrom)} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyFrom)))}'${atIndexText}${picocolors.bold(picocolors.gray(textReason))} ${picocolors.redBright(errorReasonText)}.`)}`)}`);
+	},
+	ON_PROCESS_REFERENCING: (options) => {
+		const { actionName, count, referenceTo, referenceFrom, textFrom = "from", textArrow = "➔" } = options;
+		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.magentaBright(textFrom)} ${picocolors.bold(picocolors.underline(picocolors.cyanBright(referenceFrom)))} ${picocolors.bold(picocolors.gray(textArrow))} ${picocolors.bold(picocolors.underline(picocolors.blueBright(referenceTo)))}.`)}`)}`);
+	}
+};
+function stripLineArtifacts(line, options) {
+	let out = line.replace(/^[ \t]*\/\/\s*(?:\.\.\/|\.\/)*[^ \n]*?(?:src|node_modules)\/[^\n]*\n?/gm, "").replace(/\/\/\s*eslint[^\n]*/g, "");
+	if (options.removeSourceMap) out = out.replace(/^[ \t]*\/\/[#@]\s*sourceMappingURL\s*=\s*\S+/gm, "");
+	out = out.replace(/(^[ \t]*\/\/[#@]\s*sourceMappingURL\s*=\s*\S+)(?:\r?\n\1)+/gm, "$1");
+	return out;
+}
+function splitLines(content) {
+	return content.split(/\r\n|\n/);
+}
+function fileHasTarget(lines, options) {
+	return lines.some((line, i, arr) => {
+		if (isTargetComment(line, options)) return true;
+		if (options.removeAdjacentEmptyLines && EMPTY_LINE_RE.test(line) && isAdjacentToTarget(arr, i, options)) return true;
+		return false;
+	});
+}
+function cleanBuildArtifactsCore(lines, options) {
+	const seenSourceMap = /* @__PURE__ */ new Set();
+	return lines.filter((line, i, arr) => {
+		if (SOURCE_MAP_RE.test(line)) {
+			const key = line.trim();
+			if (seenSourceMap.has(key)) return false;
+			seenSourceMap.add(key);
+			if (options.removeSourceMap) return false;
+			return true;
+		}
+		if (options.removeRegion && REGION_RE.test(line)) return false;
+		if (isTargetComment(line, options)) return false;
+		if (options.removeAdjacentEmptyLines && EMPTY_LINE_RE.test(line) && isAdjacentToTarget(arr, i, options)) return false;
+		return true;
+	}).map((line) => stripLineArtifacts(line, options));
+}
+async function runCleanBuildArtifacts({ patterns: pattern, options, fileTest, logAction }) {
+	if (!isPlainObject(options)) options = DEFAULT_CLEAN_OPTION;
+	else options = {
+		...DEFAULT_CLEAN_OPTION,
+		...options
+	};
+	const { patternOptions, logLevel: loggerLevel, removeAdjacentEmptyLines, removeRegion, removeSourceMap } = options;
+	try {
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(logAction.title, ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_CLEAN_PATTERN_POLICY);
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_CLEAN_OPTION.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.removeSourceMap", removeSourceMap, BUILD_LOGGER.SOURCE_OF(removeSourceMap, DEFAULT_CLEAN_OPTION.removeSourceMap));
+			BUILD_LOGGER.OPTIONS("options.removeRegion", removeRegion, BUILD_LOGGER.SOURCE_OF(removeRegion, DEFAULT_CLEAN_OPTION.removeRegion));
+			BUILD_LOGGER.OPTIONS("options.removeAdjacentEmptyLines", removeAdjacentEmptyLines, BUILD_LOGGER.SOURCE_OF(removeAdjacentEmptyLines, DEFAULT_CLEAN_OPTION.removeAdjacentEmptyLines));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_CLEAN_OPTION.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({
+				...logAction.onStart,
+				actionName: logAction.actionName
+			});
+		}
+		let count = 0;
+		for (const filePath of files) {
+			if (!new RegExp(fileTest).test(filePath)) continue;
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			const lines = splitLines(content);
+			if (!fileHasTarget(lines, options)) continue;
+			const finalContent = cleanBuildArtifactsCore(lines, options).join(EOL);
+			if (finalContent === content) continue;
+			count++;
+			try {
+				await fsExtra.promises.writeFile(filePath, finalContent, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+				...logAction.onProcess,
+				actionName: logAction.actionName,
+				count,
+				nameDirect: filePath
+			});
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: logAction.actionName,
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			...logAction.onSkipping,
+			actionName: logAction.actionName,
+			reasonEndText: logAction.onSkipping?.reasonEndText ?? "cleaning"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			...logAction.onError,
+			actionName: logAction.actionName,
+			error
+		});
+	}
+}
+const commandCjbaIdentity = new CommandIdentity({ defaultCommandName: "clean-js-build-artifacts" });
+const cleanJsBuildArtifacts = async (pattern, options = {}) => {
+	const logLevel = resolveLogVerbosity(options, DEFAULT_CLEAN_OPTION.logLevel);
+	return await runCleanBuildArtifacts({
+		patterns: pattern,
+		options: {
+			...options,
+			logLevel
+		},
+		fileTest: JS_OUTPUT_FILE_RE,
+		logAction: {
+			actionName: "Cleaning JS Build Artifacts",
+			title: isNonEmptyString(options.__commandTitle) ? options.__commandTitle : commandCjbaIdentity.utility()
+		}
+	});
+};
+const commandCtbaIdentity = new CommandIdentity({ defaultCommandName: "clean-types-build-artifacts" });
+const cleanTypesBuildArtifacts = async (pattern, options = {}) => {
+	const logLevel = resolveLogVerbosity(options, DEFAULT_CLEAN_OPTION.logLevel);
+	return await runCleanBuildArtifacts({
+		patterns: pattern,
+		options: {
+			...options,
+			logLevel
+		},
+		fileTest: TS_DECLARATION_FILE_RE,
+		logAction: {
+			actionName: "Cleaning Types Build Artifacts",
+			title: isNonEmptyString(options.__commandTitle) ? options.__commandTitle : commandCtbaIdentity.utility()
+		}
+	});
+};
+const DEFAULT_CFTD_OPTIONS = {
+	fileName: void 0,
+	outputRoot: "dist",
+	absoluteTarget: false,
+	ignoreMissingSourceError: false
+};
+const validateItem = (item, index) => {
+	const indexText = isNumber(index) ? ` at index ${index}` : "";
+	if (!isPlainObject(item)) throw new TypeError(`Invalid item${indexText}: must be a 'plain object'!`);
+	if (!isNonEmptyString(item.source) && !isNonEmptyString(item.target)) throw new TypeError(`Invalid item${indexText}: 'source' and 'target' must be 'non-empty string'!`);
+	if (!isNonEmptyString(item.source)) throw new TypeError(`Invalid item${indexText}: 'source' must be 'non-empty string'!`);
+	if (!isNonEmptyString(item.target)) throw new TypeError(`Invalid item${indexText}: 'target' must be 'non-empty string'!`);
+	if (!isUndefined(item.fileName) && !isNonEmptyString(item.fileName)) throw new TypeError(`Invalid item${indexText}: 'fileName' must be 'non-empty string' if provided!`);
+	if (!isUndefined(item.outputRoot) && !isNonEmptyString(item.outputRoot)) throw new TypeError(`Invalid item${indexText}: 'outputRoot' must be 'non-empty string' if provided!`);
+	if (!isUndefined(item.absoluteTarget) && !isBoolean(item.absoluteTarget)) throw new TypeError(`Invalid item${indexText}: 'absoluteTarget' must be a 'boolean' if provided!`);
+};
+function buildCopySummary(successCount, errorCount, duplicateCount, label) {
+	return picocolors.bold(joinLinesLoose(joinInline(picocolors.yellowBright("⚠"), picocolors.blueBright(label) + picocolors.gray(" -"), picocolors.whiteBright(successCount > 0 ? "Some" : "All"), picocolors.whiteBright("files"), picocolors.redBright("failed to copy") + ":"), successCount < 1 ? false : `  ${picocolors.greenBright("✔")} ${picocolors.greenBright(successCount)} ${plural(successCount, "file")} copied.`, errorCount < 1 ? false : `  ${picocolors.redBright("✖")} ${picocolors.redBright(errorCount)} ${plural(errorCount, "file")} failed.`, duplicateCount < 1 ? false : `  ${picocolors.yellowBright("⚠")} ${picocolors.yellowBright(duplicateCount)} ${plural(duplicateCount, "duplicate operation")} skipped.`));
+}
+function buildOperationKey(item) {
+	return [
+		item.source,
+		item.target,
+		item.fileName ?? "",
+		item.outputRoot ?? DEFAULT_CFTD_OPTIONS.outputRoot,
+		item.absoluteTarget ? 1 : 0
+	].join("|");
+}
+function createCopyFileToDestParameterSet(items) {
+	return new Set(isArray(items) ? items : [items]);
+}
+const commandCftdIdentity = new CommandIdentity({ defaultCommandName: "copy-file-to-dest" });
+async function copyFileToDest(parameter, options = {}) {
+	const loggerLevel = resolveLogVerbosity(options);
+	try {
+		const { __commandTitle } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandCftdIdentity.utility(), ""));
+		if (isArray(parameter) || isSet(parameter)) {
+			let i = 0;
+			for (const item of parameter) validateItem(item, i++);
+		} else if (isPlainObject(parameter)) validateItem(parameter);
+		else throw new TypeError("Parameter argument must be a 'plain object', 'array of plain objects' or an 'set of plain objects'!");
+		const list = [...toObjectSet(parameter)];
+		const uniqueLists = [];
+		const seenOperations = /* @__PURE__ */ new Set();
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			list.forEach((item, i) => {
+				const { source, target, fileName = DEFAULT_CFTD_OPTIONS.fileName, outputRoot = DEFAULT_CFTD_OPTIONS.outputRoot, absoluteTarget = DEFAULT_CFTD_OPTIONS.absoluteTarget, ignoreMissingSourceError = DEFAULT_CFTD_OPTIONS.ignoreMissingSourceError } = item;
+				const defaultFileName = fileName ?? path.basename(source);
+				const indexText = list.length > 1 ? `[${i}]` : "";
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.source`, source, "overridden", true);
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.target`, target, "overridden", true);
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.fileName`, fileName || defaultFileName, BUILD_LOGGER.SOURCE_OF(fileName, DEFAULT_CFTD_OPTIONS.fileName));
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.outputRoot`, outputRoot, BUILD_LOGGER.SOURCE_OF(outputRoot, DEFAULT_CFTD_OPTIONS.outputRoot));
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.absoluteTarget`, absoluteTarget, BUILD_LOGGER.SOURCE_OF(absoluteTarget, DEFAULT_CFTD_OPTIONS.absoluteTarget));
+				BUILD_LOGGER.OPTIONS(`options.copy${indexText}.ignoreMissingSourceError`, ignoreMissingSourceError, BUILD_LOGGER.SOURCE_OF(ignoreMissingSourceError, DEFAULT_CFTD_OPTIONS.ignoreMissingSourceError));
+				if (i < list.length - 1) console.log(picocolors.gray("  =========================================================================="));
+			});
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_LOG_LEVEL));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({
+				actionName: "Copy File",
+				textDirectAction: "action:"
+			});
+		}
+		let count = 0;
+		let errorCount = 0;
+		let duplicateCount = 0;
+		for (let index = 0; index < list.length; index++) {
+			const item = list[index];
+			const key = buildOperationKey(item);
+			if (seenOperations.has(key)) {
+				duplicateCount++;
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_SKIPPING({
+					actionName: "Copy File",
+					reasonType: "",
+					textDirectAction: "at",
+					reasonSkipAction: "duplicate operation",
+					reasonEndText: item.source + " " + picocolors.blueBright(`('parameter' index: ${picocolors.magentaBright(index)})`)
+				});
+				continue;
+			}
+			seenOperations.add(key);
+			uniqueLists.push({
+				item,
+				index
+			});
+		}
+		const procCwd = process.cwd();
+		for (let i = 0; i < uniqueLists.length; i++) {
+			const uniqList = uniqueLists[i];
+			count++;
+			const { source, target, fileName = DEFAULT_CFTD_OPTIONS.fileName, outputRoot = DEFAULT_CFTD_OPTIONS.outputRoot, absoluteTarget = DEFAULT_CFTD_OPTIONS.absoluteTarget, ignoreMissingSourceError = DEFAULT_CFTD_OPTIONS.ignoreMissingSourceError } = uniqList.item;
+			const absSource = path.resolve(procCwd, source);
+			if (!await fsExtra.pathExists(absSource)) {
+				if (ignoreMissingSourceError) continue;
+				errorCount++;
+				if (loggerLevel !== "silent") BUILD_LOGGER.ON_PROCESS_COPY_ERROR({
+					copyFrom: source,
+					index: uniqList.index,
+					indexKey: "parameter",
+					count: loggerLevel === "error" ? errorCount : count,
+					actionName: "Failed to Copy File",
+					errorReason: "the source file was not found"
+				});
+			} else {
+				const absTargetDir = path.resolve(procCwd, absoluteTarget ? "" : outputRoot, target);
+				const absTargetFile = path.join(absTargetDir, fileName ?? path.basename(source));
+				await fsExtra.ensureDir(absTargetDir);
+				await fsExtra.copy(absSource, absTargetFile);
+				const relSrc = path.relative(procCwd, absSource).replace(/\\/g, "/");
+				const relDest = path.relative(procCwd, absTargetFile).replace(/\\/g, "/");
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS_COPY({
+					actionName: "File copied",
+					count,
+					copyFrom: relSrc,
+					copyTo: relDest
+				});
+			}
+		}
+		const successCount = count - errorCount;
+		if ((errorCount > 0 || duplicateCount > 0) && loggerLevel !== "silent" && !canLog(loggerLevel, VERBOSE_LOG)) console.log(buildCopySummary(successCount, errorCount, duplicateCount, "[Copy File to Dest]"));
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0 && errorCount === 0 && duplicateCount === 0) BUILD_LOGGER.ON_FINISH({
+			textSuccess: "Successfully",
+			actionName: "copied",
+			count
+		});
+		else if (successCount > 0) console.log(buildCopySummary(successCount, errorCount, duplicateCount, "[Copy File to Dest]"));
+		else if (successCount === 0 && errorCount !== 0) BUILD_LOGGER.ON_SKIPPING({
+			actionName: "\"Copy File\"",
+			reasonSkipAction: "failed",
+			reasonEndText: `${count > 1 ? "all " : ""}files`,
+			reasonType: "to",
+			textDirectAction: "copy"
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "\"Copy File\"",
+			reasonSkipAction: errorCount > 0 ? "nothing found" : "nothing",
+			reasonEndText: "copy"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Copying File",
+			error
+		});
+	}
+}
+const DEFAULT_ECI_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedEciPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_ECI_PATTERN_POLICY);
+const DEFAULT_ECI_OPTIONS = {
+	cssImportPath: [],
+	dedupe: true,
+	sort: false,
+	minify: false,
+	patternOptions: resolvedEciPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+function inlineCssImports(code) {
+	return code.replace(/((?:import\s+["'][^"']+\.css["'];\s*\n?|require\(["'][^"']+\.css["']\);\s*\n?){2,})/g, (block) => block.split(/\n+/).map((l) => l.trim()).join(""));
+}
+function createCssStatements(kind, cssImports) {
+	return cssImports.map((p) => kind === "cjs" ? `require("${p}");` : `import "${p}";`);
+}
+function getMissingCssStatements(body, cssImports, kind, dedupe) {
+	const cleanedBody = body;
+	const cssStatements = createCssStatements(kind, cssImports);
+	return {
+		missing: dedupe ? cssStatements.filter((stmt) => !cleanedBody.includes(stmt)) : cssStatements,
+		cleanedBody
+	};
+}
+function injectCssSmart({ shebang, banner, directives, rest, cssStatements, kind, minify }) {
+	let out = minify ? shebang.trim() + EOL : shebang;
+	out += minify ? banner.trim() + EOL : banner;
+	let finalDirectives = stripUseStrict(directives, {
+		trimEnd: minify,
+		trimStart: minify
+	});
+	if (kind === "cjs") finalDirectives = `"use strict";${EOL}` + finalDirectives.trimStart();
+	out += finalDirectives;
+	out += cssStatements.join(EOL) + (minify ? "" : EOL);
+	out += rest.replace(/^\n+/, minify ? "" : EOL);
+	return out.trimStart();
+}
+function normalizeCssImports(input) {
+	return flattenStrings(isArray(input) ? input : [input]).map((s) => s.trim()).filter(Boolean);
+}
+const commandEciIdentity = new CommandIdentity({ defaultCommandName: "ensure-css-import" });
+const ensureCssImport = async (pattern, options) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_ECI_OPTIONS.logLevel);
+	try {
+		const { patternOptions = DEFAULT_ECI_OPTIONS.patternOptions, cssImportPath, dedupe = DEFAULT_ECI_OPTIONS.dedupe, sort = DEFAULT_ECI_OPTIONS.sort, minify = DEFAULT_ECI_OPTIONS.minify, __commandTitle } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandEciIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_ECI_PATTERN_POLICY);
+		let cssImports = normalizeCssImports(cssImportPath);
+		if (cssImports.length === 0) throw new Error("`cssImportPath` option must not be empty.");
+		if (dedupe) cssImports = Array.from(new Set(cssImports));
+		if (sort) cssImports.sort();
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_ECI_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.cssImportPath", cssImports, BUILD_LOGGER.SOURCE_OF(cssImports, DEFAULT_ECI_OPTIONS.cssImportPath), true);
+			BUILD_LOGGER.OPTIONS("options.dedupe", dedupe, BUILD_LOGGER.SOURCE_OF(dedupe, DEFAULT_ECI_OPTIONS.dedupe));
+			BUILD_LOGGER.OPTIONS("options.sort", sort, BUILD_LOGGER.SOURCE_OF(sort, DEFAULT_ECI_OPTIONS.sort));
+			BUILD_LOGGER.OPTIONS("options.minify", minify, BUILD_LOGGER.SOURCE_OF(minify, DEFAULT_ECI_OPTIONS.minify));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_ECI_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Ensuring CSS Import" });
+		}
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		let count = 0;
+		for (const filePath of files) {
+			if (!JS_OUTPUT_FILE_RE.test(filePath)) continue;
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			const { banner, body, shebang } = extractAndHoistBanner(content);
+			const kind = detectModuleKindFromContent(content);
+			const { missing, cleanedBody } = getMissingCssStatements(body, cssImports, kind, dedupe);
+			if (missing.length === 0) continue;
+			const { directives, rest } = extractDirectives(cleanedBody);
+			let updated = injectCssSmart({
+				shebang,
+				banner,
+				directives,
+				rest,
+				kind,
+				minify: options.minify,
+				cssStatements: missing
+			});
+			if (options.minify) updated = inlineCssImports(updated);
+			if (updated !== content) {
+				try {
+					await fsExtra.promises.writeFile(filePath, updated, "utf8");
+				} catch (err) {
+					if (err.code === "ENOENT") continue;
+					throw err;
+				}
+				count++;
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+					actionName: "CSS Import",
+					count,
+					nameDirect: filePath
+				});
+			}
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Ensuring CSS Import",
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Ensuring CSS Import",
+			reasonType: "file",
+			reasonEndText: "check"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Ensuring CSS Import",
+			error
+		});
+	}
+};
+const DEFAULT_EFN_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedEfnPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_EFN_PATTERN_POLICY);
+const DEFAULT_EFN_OPTIONS = {
+	patternOptions: resolvedEfnPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const commandEfnIdentity = new CommandIdentity({ defaultCommandName: "ensure-final-newline" });
+const ensureFinalNewline = async (pattern, options = {}) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_EFN_OPTIONS.logLevel);
+	try {
+		const { __commandTitle, patternOptions = DEFAULT_EFN_OPTIONS.patternOptions } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandEfnIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_EFN_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_EFN_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_EFN_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Ensuring Final Newline" });
+		}
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		let count = 0;
+		for (const filePath of files) {
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			const normalized = content.replace(/(\r?\n)*$/, EOL);
+			if (normalized === content) continue;
+			try {
+				await fsExtra.promises.writeFile(filePath, normalized, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			count++;
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+				actionName: "Final Newline",
+				count,
+				nameDirect: filePath
+			});
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Ensuring Final Newline",
+			count
+		});
+		else if (files.length < 1) BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Ensuring Final Newline",
+			reasonSkipAction: `no files found matching the pattern${picocolors.reset(",")}`,
+			reasonType: "",
+			textDirectAction: "no need to fix",
+			reasonEndText: "end of file (EOF)"
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Ensuring Final Newline",
+			reasonSkipAction: `all files are valid${picocolors.reset(",")}`,
+			reasonType: "",
+			textDirectAction: "no need to fix",
+			reasonEndText: "end of file (EOF)"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Ensuring Final Newline",
+			error
+		});
+	}
+};
+const DEFAULT_GRI_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedGriPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_GRI_PATTERN_POLICY);
+const DEFAULT_GRI_OPTIONS = {
+	outDir: "dist/.references",
+	outFileName: "index.d.ts",
+	inputDirReference: "dist",
+	withExportTypes: false,
+	banner: true,
+	onlyDeclarations: true,
+	patternOptions: resolvedGriPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+function normalizeRelative(from, to) {
+	return path.relative(from, to).replace(/\\/g, "/").replace(/^([^./])/, "./$1");
+}
+const resolveExportModulePath = (relativePath) => {
+	const parsed = path.parse(relativePath);
+	let baseName = parsed.name;
+	if (baseName.endsWith(".d")) baseName = baseName.slice(0, -2);
+	return path.join(parsed.dir, baseName).replace(/\\/g, "/");
+};
+const validateOut = ({ outDir, outFileName, inputDirReference }) => {
+	const normalizePath = (value) => {
+		const trimmed = value.trim();
+		return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+	};
+	const normalizeFileName = (value) => {
+		const trimmed = value.trim();
+		if (trimmed.includes("/") || trimmed.includes("\\")) throw new Error(`Invalid outFileName: "${value}"`);
+		return trimmed;
+	};
+	return {
+		outDir: normalizePath(outDir),
+		inputDirReference: normalizePath(inputDirReference),
+		outFileName: normalizeFileName(outFileName)
+	};
+};
+const resolveBanner = async (banner) => {
+	if (banner === false) return "";
+	if (banner === true) return await generatePackageBanner() + EOL;
+	const resolved = await banner;
+	return isNonEmptyString(resolved) ? resolved : "";
+};
+const commandGriIdentity = new CommandIdentity({ defaultCommandName: "generate-reference-index" });
+const generateReferenceIndex = async (pattern, options = {}) => {
+	let _withExportTypes = DEFAULT_GRI_OPTIONS.withExportTypes;
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_GRI_OPTIONS.logLevel);
+	try {
+		const { __commandTitle, patternOptions = DEFAULT_GRI_OPTIONS.patternOptions, outDir: _outDir = DEFAULT_GRI_OPTIONS.outDir, outFileName: _outFileName = DEFAULT_GRI_OPTIONS.outFileName, inputDirReference: _inputDirReference = DEFAULT_GRI_OPTIONS.inputDirReference, withExportTypes = DEFAULT_GRI_OPTIONS.withExportTypes, banner = DEFAULT_GRI_OPTIONS.banner, onlyDeclarations = DEFAULT_GRI_OPTIONS.onlyDeclarations } = options;
+		_withExportTypes = withExportTypes;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandGriIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_GRI_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("outDir", _outDir, sourceOf(_outDir, DEFAULT_GRI_OPTIONS.outDir));
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_GRI_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.outFileName", _outFileName, sourceOf(_outFileName, DEFAULT_GRI_OPTIONS.outFileName));
+			BUILD_LOGGER.OPTIONS("options.inputDirReference", _inputDirReference, sourceOf(_inputDirReference, DEFAULT_GRI_OPTIONS.inputDirReference));
+			BUILD_LOGGER.OPTIONS("options.withExportTypes", withExportTypes, sourceOf(withExportTypes, DEFAULT_GRI_OPTIONS.withExportTypes));
+			BUILD_LOGGER.OPTIONS("options.banner", banner, sourceOf(banner, DEFAULT_GRI_OPTIONS.banner));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_GRI_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Generating References" });
+		}
+		let files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		if (onlyDeclarations) files = files.filter((file) => TS_DECLARATION_FILE_RE.test(file));
+		const { inputDirReference, outDir, outFileName } = validateOut({
+			outDir: _outDir,
+			outFileName: _outFileName,
+			inputDirReference: _inputDirReference
+		});
+		const outDirAbs = path.resolve(outDir);
+		const outFileAbs = path.join(outDirAbs, outFileName);
+		const outFileNormalize = path.relative(process.cwd(), outFileAbs).replace(/\\/g, "/");
+		const lines = /* @__PURE__ */ new Set();
+		let referenceCount = 0;
+		const inputDirRefAbs = path.resolve(inputDirReference);
+		const reference = files.map((f, i) => {
+			const referencedAbs = path.resolve(f);
+			if (!referencedAbs.startsWith(inputDirRefAbs + path.sep) || referencedAbs === outFileAbs) return;
+			const referencePath = normalizeRelative(path.dirname(outFileAbs), referencedAbs);
+			const displayPath = `${inputDirReference}/${path.relative(inputDirRefAbs, referencedAbs).replace(/\\/g, "/")}`;
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS_REFERENCING({
+				actionName: "Generated Reference",
+				count: i + 1,
+				referenceFrom: displayPath,
+				referenceTo: outFileNormalize
+			});
+			referenceCount++;
+			return `/// <reference path="${referencePath}" />`;
+		}).filter(Boolean);
+		if (Array.isArray(reference) && reference.length > 0) {
+			lines.add("//! References Paths:");
+			lines.add(reference.join(EOL));
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (referenceCount > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Generating Reference",
+			count: files.length,
+			typeCount: "reference"
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Generating References",
+			reasonEndText: "referencing",
+			reasonType: "references"
+		});
+		if (withExportTypes) {
+			if (canLog(loggerLevel, VERBOSE_LOG)) {
+				console.log(picocolors.bold(picocolors.magentaBright(`${EOL}=======================================================================================${EOL}`)));
+				BUILD_LOGGER.ON_STARTING({ actionName: "Adding Exported Types" });
+			}
+			const exportLines = /* @__PURE__ */ new Set();
+			let exportCount = 0;
+			files.forEach((f) => {
+				const referencedAbs = path.resolve(f);
+				if (!referencedAbs.startsWith(inputDirRefAbs + path.sep) || referencedAbs === outFileAbs) return;
+				const exportModulePath = resolveExportModulePath(path.relative(inputDirRefAbs, referencedAbs).replace(/\\/g, "/"));
+				const line = `export * from "${normalizeRelative(path.dirname(outFileAbs), path.resolve(inputDirReference, exportModulePath))}";`;
+				if (!exportLines.has(line)) {
+					exportCount++;
+					const displayPath = `${inputDirReference}/${path.relative(inputDirRefAbs, referencedAbs).replace(/\\/g, "/")}`;
+					if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS_REFERENCING({
+						actionName: "Exported Type",
+						count: exportCount,
+						referenceFrom: displayPath,
+						referenceTo: outFileNormalize
+					});
+					exportLines.add(line);
+				}
+			});
+			if (exportLines.size > 0) {
+				if (referenceCount > 0) lines.add("");
+				lines.add("//! Exported Types:");
+				lines.add([...exportLines].join(EOL));
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_FINISH({
+					actionName: "Adding Exported Types",
+					count: exportLines.size,
+					typeCount: "type"
+				});
+			} else if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_SKIPPING({
+				actionName: "Adding Exported Types",
+				reasonEndText: "exporting",
+				reasonType: "types"
+			});
+		}
+		await fsExtra.ensureDir(outDirAbs);
+		if (lines.size === 0) {
+			const action = withExportTypes ? "reference and type export" : "reference";
+			lines.add(`// No files matched the given patterns and input dir references, skipping ${action} generation.`);
+		}
+		await fsExtra.promises.writeFile(outFileAbs, await resolveBanner(banner) + [...lines].join(EOL) + EOL);
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Generating References" + (_withExportTypes ? " and Adding Exported Types" : ""),
+			error
+		});
+	}
+};
+const DEFAULT_IB_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedIbPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_IB_PATTERN_POLICY);
+const DEFAULT_IB_OPTIONS = {
+	replaceBanner: false,
+	removeDuplicate: true,
+	bannerPosition: "after-existing",
+	patternOptions: resolvedIbPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const commandIbIdentity = new CommandIdentity({ defaultCommandName: "inject-banner" });
+const injectBanner = async (pattern, bannerText, options = {}) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_LOG_LEVEL);
+	try {
+		const { __commandTitle, removeDuplicate = DEFAULT_IB_OPTIONS.removeDuplicate, bannerPosition = DEFAULT_IB_OPTIONS.bannerPosition, replaceBanner = DEFAULT_IB_OPTIONS.replaceBanner, patternOptions = DEFAULT_IB_OPTIONS.patternOptions } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandIbIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const banners = toStringSet(bannerText, { parameterKey: "bannerText" });
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_IB_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_IB_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.removeDuplicate", removeDuplicate, BUILD_LOGGER.SOURCE_OF(removeDuplicate, DEFAULT_IB_OPTIONS.removeDuplicate));
+			BUILD_LOGGER.OPTIONS("options.replaceBanner", replaceBanner, BUILD_LOGGER.SOURCE_OF(replaceBanner, DEFAULT_IB_OPTIONS.replaceBanner));
+			BUILD_LOGGER.OPTIONS("options.bannerPosition", bannerPosition, BUILD_LOGGER.SOURCE_OF(bannerPosition, DEFAULT_IB_OPTIONS.bannerPosition));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_IB_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Injecting Banner" });
+		}
+		if (banners.size === 0) {
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_SKIPPING({
+				actionName: "Inject Banner",
+				reasonSkipAction: "empty bannerText",
+				reasonType: "parameter",
+				reasonEndText: "injecting"
+			});
+			return;
+		}
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		let count = 0;
+		for (const filePath of files) {
+			if (NON_COMMENTABLE_FILE_RE.test(filePath)) continue;
+			let original;
+			try {
+				original = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			if (!isNonEmptyString(original)) continue;
+			if (!hasExecutableCode(original)) continue;
+			const { body, shebang, banner: existingBanner } = extractAndHoistBanner(original);
+			const bannerRegex = new RegExp(BANNER_RE.source, "g");
+			const newBlocks = [...banners];
+			if (newBlocks.length === 0) continue;
+			const existingBlocks = existingBanner ? [...existingBanner.matchAll(bannerRegex)].map((m) => m[0]) : [];
+			let finalBlocks = [];
+			if (replaceBanner) {
+				const replaceRegex = isRegExp(replaceBanner) ? replaceBanner : BANNER_RE;
+				if (existingBanner && new RegExp(replaceRegex.source, replaceRegex.flags.replace("g", "")).test(existingBanner)) finalBlocks = [...newBlocks];
+				else finalBlocks = bannerPosition === "top" ? [...newBlocks, ...existingBlocks] : [...existingBlocks, ...newBlocks];
+			} else finalBlocks = bannerPosition === "top" ? [...newBlocks, ...existingBlocks] : [...existingBlocks, ...newBlocks];
+			if (removeDuplicate) {
+				const seen = /* @__PURE__ */ new Set();
+				finalBlocks = finalBlocks.filter((block) => {
+					const normalized = block.trim();
+					if (seen.has(normalized)) return false;
+					seen.add(normalized);
+					return true;
+				});
+			}
+			let content = shebang + finalBlocks.map((text) => {
+				if (!text || !isNonEmptyString(text)) return "";
+				return text.replace(/\r\n/g, EOL).replace(/\n+$/, "") + EOL + EOL;
+			}).join("") + body;
+			try {
+				await fsExtra.promises.writeFile(filePath, content, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			count++;
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+				actionName: "Banner Injected " + picocolors.cyanBright(replaceBanner ? "(replace mode)" : "(preserve mode)"),
+				count,
+				nameDirect: filePath
+			});
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Inject Banner",
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Inject Banner",
+			reasonEndText: "injecting"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Inject Banner",
+			error
+		});
+	}
+};
+const DEFAULT_ID_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedIdPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_ID_PATTERN_POLICY);
+const DEFAULT_ID_OPTIONS = {
+	patternOptions: resolvedIdPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const commandIdIdentity = new CommandIdentity({ defaultCommandName: "inject-directive" });
+const injectDirective = async (pattern, directive, options = {}) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_ID_OPTIONS.logLevel);
+	try {
+		const { __commandTitle, patternOptions = DEFAULT_ID_OPTIONS.patternOptions } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandIdIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_ID_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("directive", directive, BUILD_LOGGER.SOURCE_OF(directive, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_ID_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_ID_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Inject Directive" });
+		}
+		const directives = [...toStringSet(directive)];
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		let count = 0;
+		for (const filePath of files) {
+			if (!JS_OUTPUT_FILE_RE.test(filePath)) continue;
+			let original;
+			try {
+				original = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			if (!isNonEmptyString(original) || !hasExecutableCode(original)) continue;
+			const { body, banner, shebang } = extractAndHoistBanner(original);
+			const { directives: extractedDirectives, rest } = extractDirectives(body);
+			const existing = new Set(extractedDirectives);
+			let injectLines;
+			if (detectModuleKindFromContent(rest) === "cjs") {
+				injectLines ??= [];
+				injectLines.push(`"use strict";`);
+			}
+			for (const d of directives) {
+				const dTrim = d.trim();
+				if (!dTrim || dTrim === "use strict") continue;
+				const line = `"${dTrim}";`;
+				if (!existing.has(line)) {
+					injectLines ??= [];
+					injectLines.push(line);
+				}
+			}
+			if (!injectLines?.length) continue;
+			const finalDirective = injectLines.join(EOL) + EOL + stripUseStrict(extractedDirectives);
+			const content = shebang + banner + finalDirective + rest;
+			try {
+				await fsExtra.promises.writeFile(filePath, content, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			count++;
+			if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+				actionName: "Directive Injected " + picocolors.cyanBright("(`" + injectLines.join("`, `") + "`)"),
+				count,
+				nameDirect: filePath
+			});
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Inject Directive",
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Inject Directive",
+			reasonEndText: "injecting"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Inject Directive",
+			error
+		});
+	}
+};
+const DEFAULT_NJBN_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedNjbnPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_NJBN_PATTERN_POLICY);
+const DEFAULT_NJBN_OPTIONS = {
+	patternOptions: resolvedNjbnPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const commandNjbnIdentity = new CommandIdentity({ defaultCommandName: "normalize-js-build-newlines" });
+const normalizeJsBuildNewlines = async (pattern, options = {}) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_NJBN_OPTIONS.logLevel);
+	try {
+		const { __commandTitle, patternOptions = DEFAULT_NJBN_OPTIONS.patternOptions } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandNjbnIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_NJBN_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_NJBN_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_NJBN_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Normalize New Lines" });
+		}
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		const filesToClean = /* @__PURE__ */ new Set();
+		for (const filePath of files) {
+			if (!JS_OUTPUT_FILE_RE.test(filePath)) continue;
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			if (!/(\r?\n){3,}/.test(content)) continue;
+			filesToClean.add(filePath);
+		}
+		let count = 0;
+		for (const [, filePath] of filesToClean.entries()) {
+			count++;
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			const finalContent = content.replace(/(\r?\n){3,}/g, EOL);
+			if (finalContent !== content) {
+				try {
+					await fsExtra.promises.writeFile(filePath, finalContent, "utf8");
+				} catch (err) {
+					if (err.code === "ENOENT") continue;
+					throw err;
+				}
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+					actionName: "New Line Normalized",
+					count,
+					nameDirect: filePath
+				});
+			}
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (filesToClean.size > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Normalize New Lines",
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Normalize New Lines",
+			reasonEndText: "normalize"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Normalize New Lines",
+			error
+		});
+	}
+};
+const DEFAULT_SJC_PATTERN_POLICY = {
+	filesOnly: true,
+	forceUnique: true
+};
+const resolvedSjcPatternOption = resolvePatternOptions(defaultPatternOptions, DEFAULT_SJC_PATTERN_POLICY);
+const DEFAULT_SJC_OPTIONS = {
+	removeSourceMap: false,
+	sourceType: "module",
+	removeRegion: true,
+	ecmaVersion: "latest",
+	patternOptions: resolvedSjcPatternOption,
+	logLevel: DEFAULT_LOG_LEVEL
+};
+const VALID_SOURCE_TYPE = new Set([
+	"module",
+	"script",
+	"commonjs"
+]);
+const VALID_ECMA_VERSION = new Set([
+	"latest",
+	3,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	2015,
+	2016,
+	2017,
+	2018,
+	2019,
+	2020,
+	2021,
+	2022,
+	2023,
+	2024,
+	2025,
+	2026
+]);
+const REGION_COMMENT_RE = /^#(?:end)?region\b/i;
+const SOURCE_MAP_COMMENT_RE = /^[#@]\s*sourceMappingURL=/;
+function normalizeNewlines(code) {
+	return code.replace(/[ \t]+\n/g, EOL).replace(/\n\s*\n+/g, EOL);
+}
+function stripComments(code, { removeRegion, removeSourceMap, sourceType, ecmaVersion }) {
+	const comments = [];
+	if (sourceType == null || !VALID_SOURCE_TYPE.has(sourceType)) sourceType = DEFAULT_SJC_OPTIONS.sourceType;
+	if (ecmaVersion == null || !VALID_ECMA_VERSION.has(ecmaVersion)) ecmaVersion = DEFAULT_SJC_OPTIONS.ecmaVersion;
+	try {
+		acorn.parse(code, {
+			sourceType,
+			ecmaVersion,
+			allowHashBang: true,
+			onComment(block, text, start, end) {
+				if (!block) {
+					const value = text.trim();
+					if (!REGION_COMMENT_RE.test(value) && !SOURCE_MAP_COMMENT_RE.test(value)) return;
+				}
+				const value = text.trim();
+				const forceRemove = shouldRemoveDocRuntime(value);
+				if (forceRemove === true) {
+					comments.push([start, end]);
+					return;
+				}
+				if (forceRemove === false) return;
+				if (IMPORTANT_COMMENT.test(value)) return;
+				if (SOURCE_MAP_COMMENT_RE.test(value)) {
+					if (removeSourceMap) comments.push([start, end]);
+					return;
+				}
+				if (REGION_COMMENT_RE.test(value)) {
+					if (removeRegion) comments.push([start, end]);
+					return;
+				}
+				if (block) comments.push([start, end]);
+			}
+		});
+	} catch {
+		return code;
+	}
+	if (!comments.length) return code;
+	const parts = [];
+	let last = 0;
+	for (const [start, end] of comments) {
+		parts.push(code.slice(last, start));
+		last = end;
+	}
+	parts.push(code.slice(last));
+	const lines = parts.join("").split(/\r?\n/);
+	const seenSourceMap = /* @__PURE__ */ new Set();
+	return lines.filter((line) => {
+		if (SOURCE_MAP_RE.test(line)) {
+			const key = line.trim();
+			if (seenSourceMap.has(key)) return false;
+			seenSourceMap.add(key);
+			if (removeSourceMap) return false;
+			return true;
+		}
+		if (removeRegion && REGION_RE.test(line)) return false;
+		if (isTargetComment(line, {
+			removeSourceMap,
+			removeRegion
+		})) return false;
+		return true;
+	}).map((line) => {
+		let out = line.replace(/^[ \t]*\/\/\s*(?:\.\.\/|\.\/)*[^ \n]*?(?:src|node_modules)\/[^\n]*\n?/gm, "").replace(/\/\/\s*eslint[^\n]*/g, "");
+		out = out.replace(/(\/\/[#@]\s*sourceMappingURL=[^\r\n]*)(?:\r?\n\1)+/g, "$1");
+		return out;
+	}).join(EOL);
+}
+const commandSjcIdentity = new CommandIdentity({ defaultCommandName: "strip-js-comments" });
+const stripJsComments = async (pattern, options = {}) => {
+	const loggerLevel = resolveLogVerbosity(options, DEFAULT_SJC_OPTIONS.logLevel);
+	try {
+		const { patternOptions = DEFAULT_SJC_OPTIONS.patternOptions, removeSourceMap = DEFAULT_SJC_OPTIONS.removeSourceMap, removeRegion = DEFAULT_SJC_OPTIONS.removeRegion, sourceType = DEFAULT_SJC_OPTIONS.sourceType, ecmaVersion = DEFAULT_SJC_OPTIONS.ecmaVersion, __commandTitle } = options;
+		if (canLog(loggerLevel, VERBOSE_LOG)) console.log(joinLinesLoose(isNonEmptyString(__commandTitle) ? __commandTitle : commandSjcIdentity.utility(), ""));
+		const patterns = [...toStringSet(pattern)];
+		const cleanPatternOptions = resolvePatternOptions(patternOptions, DEFAULT_SJC_PATTERN_POLICY);
+		if (canLog(loggerLevel, VERBOSE_LOG)) {
+			BUILD_LOGGER.SECTION("Options", { icon: "⚙️ " });
+			BUILD_LOGGER.OPTIONS("pattern", patterns, BUILD_LOGGER.SOURCE_OF(patterns, void 0), true);
+			BUILD_LOGGER.OPTIONS("options.patternOptions", cleanPatternOptions, sourceOfPatternOptions(cleanPatternOptions, DEFAULT_SJC_OPTIONS.patternOptions));
+			BUILD_LOGGER.OPTIONS("options.removeSourceMap", removeSourceMap, BUILD_LOGGER.SOURCE_OF(removeSourceMap, DEFAULT_SJC_OPTIONS.removeSourceMap));
+			BUILD_LOGGER.OPTIONS("options.removeRegion", removeRegion, BUILD_LOGGER.SOURCE_OF(removeRegion, DEFAULT_SJC_OPTIONS.removeRegion));
+			BUILD_LOGGER.OPTIONS("options.sourceType", sourceType, BUILD_LOGGER.SOURCE_OF(sourceType, DEFAULT_SJC_OPTIONS.sourceType));
+			BUILD_LOGGER.OPTIONS("options.ecmaVersion", ecmaVersion, BUILD_LOGGER.SOURCE_OF(ecmaVersion, DEFAULT_SJC_OPTIONS.ecmaVersion));
+			BUILD_LOGGER.OPTIONS("options.logLevel", loggerLevel, BUILD_LOGGER.SOURCE_OF(loggerLevel, DEFAULT_SJC_OPTIONS.logLevel));
+			BUILD_LOGGER.NEW_LINE();
+			BUILD_LOGGER.ON_STARTING({ actionName: "Stripping JS Comments" });
+		}
+		const files = (await fastGlob(patterns, cleanPatternOptions)).sort();
+		let count = 0;
+		for (const filePath of files) {
+			if (!JS_OUTPUT_FILE_RE.test(filePath)) continue;
+			let content;
+			try {
+				content = await fsExtra.promises.readFile(filePath, "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			let output = content;
+			if (!/\/[/*]/.test(content)) continue;
+			output = stripComments(content, {
+				removeRegion,
+				removeSourceMap,
+				sourceType,
+				ecmaVersion
+			});
+			output = normalizeNewlines(output).trim() + EOL;
+			if (output !== content) {
+				try {
+					await fsExtra.promises.writeFile(filePath, output, "utf8");
+				} catch (err) {
+					if (err.code === "ENOENT") continue;
+					throw err;
+				}
+				count++;
+				if (canLog(loggerLevel, VERBOSE_LOG)) BUILD_LOGGER.ON_PROCESS({
+					actionName: "JS Comment Stripping",
+					count,
+					nameDirect: filePath
+				});
+			}
+		}
+		if (canLog(loggerLevel, VERBOSE_LOG)) if (count > 0) BUILD_LOGGER.ON_FINISH({
+			actionName: "Stripping JS Comments",
+			count
+		});
+		else BUILD_LOGGER.ON_SKIPPING({
+			actionName: "Stripping JS Comments",
+			reasonType: "file",
+			reasonEndText: "processing"
+		});
+	} catch (error) {
+		if (loggerLevel !== "silent") BUILD_LOGGER.ON_ERROR({
+			actionName: "Stripping JS Comments",
+			error
+		});
+	}
+};
+function runCommand(command, argsOrOptions = [], maybeOptions = {}) {
+	assertValidCommand(command);
+	let args;
+	let options;
+	if (Array.isArray(argsOrOptions)) {
+		args = argsOrOptions;
+		options = maybeOptions;
+	} else {
+		args = [];
+		options = argsOrOptions;
+	}
+	return new Promise((resolve, reject) => {
+		const { shell = true, stdio = "inherit", argv0: _argv0, useColors = true, ...restOption } = options;
+		const { child, setupLifecycle, cmdStringPlain } = spawnWithLifecycle(command, args, {
+			...restOption,
+			stdio,
+			useColors,
+			shell
+		}, { rejectOnNonZero: true });
+		setupLifecycle({
+			onSuccess: (code) => {
+				if (code === 0) resolve(child);
+				else reject(/* @__PURE__ */ new Error(`${cmdStringPlain} exited with code ${code}`));
+			},
+			onError: reject
+		});
+	});
+}
+function normalizeChunk(chunk) {
+	if (typeof chunk === "string") return chunk;
+	if (Buffer.isBuffer(chunk)) return chunk.toString("utf8");
+	return String(chunk);
+}
+function runCommandCapture(command, argsOrOptions = [], maybeOptions = {}) {
+	assertValidCommand(command);
+	let args;
+	let options;
+	if (Array.isArray(argsOrOptions)) {
+		args = argsOrOptions;
+		options = maybeOptions;
+	} else {
+		args = [];
+		options = argsOrOptions;
+	}
+	const { shell = true, signal, timeout, forceKill, useColors = true, argv0: _argv0, ...restOption } = options;
+	return new Promise((resolve, reject) => {
+		const { child, setupLifecycle } = spawnWithLifecycle(command, args, {
+			...restOption,
+			stdio: "pipe",
+			shell,
+			signal,
+			timeout,
+			forceKill,
+			useColors
+		}, { rejectOnNonZero: false });
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += normalizeChunk(chunk);
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += normalizeChunk(chunk);
+		});
+		setupLifecycle({
+			onSuccess: (code) => {
+				resolve({
+					stdout: stdout.trimEnd(),
+					stderr: stderr.trimEnd(),
+					exitCode: code,
+					ok: code === 0
+				});
+			},
+			onError: reject
+		});
+	});
+}
+function formatCommand(command, args, { useColors = true } = {}) {
+	const hasArgs = args.length > 0;
+	const argsString = hasArgs ? args.map((a) => safeStableStringify(a)).join(" ") : "";
+	if (useColors) {
+		const cmd = picocolors.cyanBright(command);
+		return hasArgs ? `${cmd} ${picocolors.gray(argsString)}` : cmd;
+	}
+	return hasArgs ? `${command} ${argsString}` : command;
+}
+function assertValidCommand(command, { useColors = true } = {}) {
+	if (typeof command !== "string") {
+		const errorMsg = `Invalid command: expected a string, received ${safeStableStringify(command)}`;
+		throw new TypeError(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+	}
+	const trimmed = command.trim();
+	if (trimmed.length === 0) {
+		const errorMsg = "Invalid command: command cannot be empty";
+		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+	}
+	const hasSpace = trimmed.includes(" ");
+	const hasQuotes = /['"`]/.test(trimmed);
+	const hasShellOps = /[|&;<>(){}$]/.test(trimmed);
+	if (hasSpace || hasQuotes || hasShellOps) {
+		const [cmd, ...rest] = trimmed.split(/\s+/);
+		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Do not pass a full shell command.", `Use arguments instead: runCommand("${cmd}", ${safeStableStringify(rest)})`);
+		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+	}
+}
+function stripInternalStack(lines) {
+	const blacklist = [
+		"at new Promise (<anonymous>)",
+		"Timeout.",
+		"ChildProcess.",
+		"node:events:",
+		"createProcessError",
+		"formatError",
+		"spawnWithLifecycle",
+		"setupLifecycle",
+		"node:internal"
+	];
+	return lines.filter((line) => {
+		if (blacklist.some((key) => line.includes(key))) return false;
+		const isFileFrame = line.includes("/build-tools/dist/");
+		const hasFunctionName = /\bat\s+\S+\s+\(/.test(line);
+		if (isFileFrame && !hasFunctionName) return false;
+		return true;
+	});
+}
+function createProcessError(message, { reason, exitCode, signal, command }, baseStack) {
+	const error = new CommandProcessError(message, {
+		reason,
+		exitCode,
+		signal,
+		command
+	});
+	const currentStack = error.stack?.split(EOL) ?? [];
+	const base = baseStack?.split(EOL) ?? [];
+	const [currentHead, ...currentRest] = currentStack;
+	const [, ...baseRest] = base;
+	const cleanedCurrent = stripInternalStack(currentRest);
+	const cleanedBase = stripInternalStack(baseRest);
+	command = command.trim();
+	error.stack = [
+		currentHead,
+		...cleanedCurrent,
+		...cleanedBase.length ? [...cleanedBase] : []
+	].join(EOL);
+	Object.defineProperties(error, {
+		reason: {
+			value: reason,
+			enumerable: false
+		},
+		exitCode: {
+			value: exitCode,
+			enumerable: false
+		},
+		signal: {
+			value: signal,
+			enumerable: false
+		},
+		command: {
+			value: command,
+			enumerable: false
+		}
+	});
+	error.stack += joinLinesLoose("", "meta:", ` reason: ${formatOptionValue(reason)}`, ` exitCode: ${formatOptionValue(exitCode ?? null)}`, ` signal: ${formatOptionValue(signal ?? null)}`, ` command: ${formatOptionValue(command)}`);
+	return error;
+}
+var CommandProcessError = class extends Error {
+	reason;
+	exitCode;
+	signal;
+	command;
+	constructor(message, meta) {
+		super(message);
+		this.name = "CommandProcessError";
+		this.reason = meta.reason;
+		this.exitCode = meta.exitCode;
+		this.signal = meta.signal;
+		this.command = meta.command;
+	}
+};
+function isCommandProcessError(err) {
+	return err instanceof CommandProcessError;
+}
+function spawnWithLifecycle(command, args, options, config) {
+	const { useColors = true, timeout, forceKill, signal: abortSignal, ...restOption } = options;
+	const baseStack = (/* @__PURE__ */ new Error()).stack;
+	const cmdString = formatCommand(command, args, { useColors });
+	const cmdStringPlain = formatCommand(command, args, { useColors: false });
+	const formatError = config?.formatError ?? ((msg, meta) => {
+		const metaCommand = meta.command.trim();
+		const argsString = meta.args.length > 0 ? meta.args.map((a) => safeStableStringify(a).trim()).join(" ") : "";
+		if (meta.useColors) {
+			const cmd = picocolors.magentaBright(metaCommand);
+			const args = argsString ? picocolors.yellowBright(argsString) : "";
+			return createProcessError(`${cmd}${args ? " " + args : ""} ${picocolors.redBright(msg)}`, {
+				...meta,
+				command: `${metaCommand} ${argsString}`
+			}, baseStack);
+		}
+		return createProcessError(`${metaCommand}${isNonEmptyString(argsString) ? " " + argsString : ""} ${msg}`, {
+			...meta,
+			command: `${metaCommand} ${argsString}`
+		}, baseStack);
+	});
+	const rejectOnNonZero = config?.rejectOnNonZero ?? false;
+	const child = spawn(command, [...args], restOption);
+	let finished = false;
+	const kill = () => {
+		try {
+			if (process.platform === "win32") if (forceKill && child.pid) spawn("taskkill", [
+				"/pid",
+				String(child.pid),
+				"/f",
+				"/t"
+			]);
+			else child.kill();
+			else child.kill("SIGTERM");
+		} catch {}
+	};
+	return {
+		child,
+		kill,
+		cmdString,
+		cmdStringPlain,
+		setupLifecycle({ onSuccess, onError }) {
+			const timeoutId = timeout != null ? setTimeout(() => {
+				if (finished) return;
+				kill();
+				fail(formatError(`timed out after ${timeout}ms`, {
+					reason: "timeout",
+					command,
+					args,
+					useColors
+				}));
+			}, timeout) : null;
+			const cleanup = () => {
+				finished = true;
+				if (abortSignal) abortSignal.removeEventListener("abort", onAbort);
+				if (timeoutId) clearTimeout(timeoutId);
+			};
+			const fail = (err) => {
+				if (finished) return;
+				cleanup();
+				onError(err);
+			};
+			const succeed = (code) => {
+				if (finished) return;
+				cleanup();
+				onSuccess(code);
+			};
+			const onAbort = () => {
+				if (finished) return;
+				kill();
+				fail(formatError("aborted by signal", {
+					reason: "abort",
+					command,
+					args,
+					useColors
+				}));
+			};
+			if (abortSignal) {
+				if (abortSignal.aborted) {
+					onAbort();
+					return;
+				}
+				abortSignal.addEventListener("abort", onAbort);
+			}
+			child.once("error", fail);
+			child.once("close", (code, signal) => {
+				if (signal) {
+					fail(formatError(`terminated by ${signal}`, {
+						reason: "signal",
+						signal,
+						exitCode: code ?? void 0,
+						command,
+						args,
+						useColors
+					}));
+					return;
+				}
+				const exitCode = code ?? 0;
+				if (rejectOnNonZero && exitCode !== 0) {
+					fail(formatError(`exited with code ${exitCode}`, {
+						reason: "non-zero exit code",
+						exitCode,
+						command,
+						args,
+						useColors
+					}));
+					return;
+				}
+				succeed(exitCode);
+			});
+		}
+	};
+}
+export { CommandProcessError, DEFAULT_CLEAN_PATTERN_POLICY, DEFAULT_ECI_PATTERN_POLICY, DEFAULT_EFN_PATTERN_POLICY, DEFAULT_GRI_PATTERN_POLICY, DEFAULT_IB_PATTERN_POLICY, DEFAULT_ID_PATTERN_POLICY, DEFAULT_NJBN_PATTERN_POLICY, DEFAULT_SJC_PATTERN_POLICY, cleanJsBuildArtifacts, cleanTypesBuildArtifacts, commandCftdIdentity, commandCjbaIdentity, commandCtbaIdentity, commandEciIdentity, commandEfnIdentity, commandGriIdentity, commandIbIdentity, commandIdIdentity, commandNjbnIdentity, commandSjcIdentity, copyFileToDest, createCopyFileToDestParameterSet, ensureCssImport, ensureFinalNewline, generatePackageBanner, generateReferenceIndex, getPackageJson, injectBanner, injectDirective, isCommandProcessError, normalizeJsBuildNewlines, resolvedCleanPatternOption, resolvedEciPatternOption, resolvedEfnPatternOption, resolvedGriPatternOption, resolvedIbPatternOption, resolvedIdPatternOption, resolvedNjbnPatternOption, resolvedSjcPatternOption, runCommand, runCommandCapture, stripJsComments };
+//# sourceMappingURL=index.js.map