react-doctor 0.2.8 → 0.2.10

package/dist/{cli-logger-C35LXalM.js → cli-logger-BRBUS1pE.js}

@@ -22,6 +22,7 @@ import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
 import * as Stream from "effect/Stream";
 import * as Cache from "effect/Cache";
+import { Worker } from "node:worker_threads";
 import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";
@@ -2045,6 +2046,14 @@ var PackageJsonNotFoundError = class extends Error {
 		this.directory = directory;
 	}
 };
+var NotADirectoryError = class extends Error {
+	name = "NotADirectoryError";
+	resolvedPath;
+	constructor(resolvedPath, options) {
+		super(`Resolved scan target "${resolvedPath}" is not a directory. Ensure the path exists and points to a project directory, not a file.`, options);
+		this.resolvedPath = resolvedPath;
+	}
+};
 var AmbiguousProjectError = class extends Error {
 	name = "AmbiguousProjectError";
 	directory;
@@ -2264,11 +2273,13 @@ const FRAMEWORK_DISPLAY_NAMES = {
 	gatsby: "Gatsby",
 	expo: "Expo",
 	"react-native": "React Native",
+	preact: "Preact",
 	unknown: "React"
 };
 const formatFrameworkName = (framework) => FRAMEWORK_DISPLAY_NAMES[framework];
 const detectFramework = (dependencies) => {
 	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
+	if (dependencies.preact && !dependencies.react) return "preact";
 	return "unknown";
 };
 const UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/g;
@@ -2732,6 +2743,13 @@ const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => {
 	}
 	return false;
 };
+const hasPreact = (packageJson) => {
+	return "preact" in {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+};
 const TANSTACK_QUERY_PACKAGES = new Set([
 	"@tanstack/react-query",
 	"@tanstack/query-core",
@@ -2769,7 +2787,8 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 const REACT_DEPENDENCY_NAMES = new Set([
 	"react",
 	"react-native",
-	"next"
+	"next",
+	"preact"
 ]);
 const hasReactDependency = (packageJson) => {
 	const allDependencies = {
@@ -2928,12 +2947,47 @@ const discoverProject = (directory) => {
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
 		hasTanStackQuery: hasTanStackQuery(packageJson),
+		hasPreact: hasPreact(packageJson),
 		hasReactNativeWorkspace,
 		sourceFileCount
 	};
 	cachedProjectInfos.set(directory, projectInfo);
 	return projectInfo;
 };
+const MAJOR_MINOR_PATTERN = /(\d{1,4})\.(\d{1,4})/;
+const MAJOR_ONLY_PATTERN = /(\d{1,4})/;
+const UPPER_BOUND_COMPARATOR_PATTERN = /<=?\s{0,8}\d{1,4}(?:\.\d{1,4}){0,2}(?:-[^\s,|]+)?/g;
+const parseReactMajorMinor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	const trimmed = reactVersion.trim();
+	if (trimmed.length === 0) return null;
+	const lowerBoundsOnly = trimmed.replace(UPPER_BOUND_COMPARATOR_PATTERN, " ").trim();
+	if (lowerBoundsOnly.length === 0) return null;
+	const majorMinorMatch = lowerBoundsOnly.match(MAJOR_MINOR_PATTERN);
+	if (majorMinorMatch) {
+		const major = Number.parseInt(majorMinorMatch[1], 10);
+		const minor = Number.parseInt(majorMinorMatch[2], 10);
+		if (!Number.isFinite(major) || major <= 0) return null;
+		if (!Number.isFinite(minor) || minor < 0) return null;
+		return {
+			major,
+			minor
+		};
+	}
+	const majorOnlyMatch = lowerBoundsOnly.match(MAJOR_ONLY_PATTERN);
+	if (!majorOnlyMatch) return null;
+	const major = Number.parseInt(majorOnlyMatch[1], 10);
+	if (!Number.isFinite(major) || major <= 0) return null;
+	return {
+		major,
+		minor: 0
+	};
+};
+const isReactAtLeast = (detected, required) => {
+	if (detected === null) return true;
+	if (detected.major !== required.major) return detected.major > required.major;
+	return detected.minor >= required.minor;
+};
 const parseTailwindMajorMinor = (tailwindVersion) => {
 	if (typeof tailwindVersion !== "string") return null;
 	const trimmed = tailwindVersion.trim();
@@ -2964,6 +3018,7 @@ const isTailwindAtLeast = (detected, required) => {
 	return detected.minor >= required.minor;
 };
 const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const MILLISECONDS_PER_SECOND = 1e3;
 const SCORE_API_URL = "https://www.react.doctor/api/score";
 const SHARE_BASE_URL = "https://www.react.doctor/share";
 const FETCH_TIMEOUT_MS = 1e4;
@@ -4132,8 +4187,10 @@ const resolveScanTarget = (requestedDirectory) => {
 	const configSourceDirectory = loadedConfig?.sourceDirectory ?? null;
 	const redirectedDirectory = resolveConfigRootDir(userConfig, configSourceDirectory);
 	const directoryAfterRedirect = redirectedDirectory ?? absoluteRequested;
+	const resolvedDirectory = resolveDiagnoseTarget(directoryAfterRedirect) ?? directoryAfterRedirect;
+	if (!isDirectory(resolvedDirectory)) throw existsSync(resolvedDirectory) ? new NotADirectoryError(resolvedDirectory) : new ProjectNotFoundError(resolvedDirectory);
 	return {
-		resolvedDirectory: resolveDiagnoseTarget(directoryAfterRedirect) ?? directoryAfterRedirect,
+		resolvedDirectory,
 		requestedDirectory: absoluteRequested,
 		userConfig,
 		configSourceDirectory,
@@ -4481,6 +4538,49 @@ const collectIgnorePatterns = (rootDirectory) => {
 	return patterns;
 };
 const TSCONFIG_FILENAMES$1 = ["tsconfig.json", "tsconfig.base.json"];
+const DEAD_CODE_WORKER_SCRIPT = `
+const { parentPort, workerData } = require("node:worker_threads");
+
+const normalizeResult = (result) => ({
+  unusedFiles: result.unusedFiles.map((unusedFile) => ({
+    path: unusedFile.path,
+  })),
+  unusedExports: result.unusedExports.map((unusedExport) => ({
+    path: unusedExport.path,
+    name: unusedExport.name,
+    line: unusedExport.line,
+    column: unusedExport.column,
+    isTypeOnly: unusedExport.isTypeOnly,
+  })),
+  unusedDependencies: result.unusedDependencies.map((unusedDependency) => ({
+    name: unusedDependency.name,
+    isDevDependency: unusedDependency.isDevDependency,
+  })),
+  circularDependencies: result.circularDependencies.map((cycle) => ({
+    files: cycle.files,
+  })),
+});
+
+const serializeError = (error) =>
+  error instanceof Error
+    ? { name: error.name, message: error.message, stack: error.stack }
+    : { message: String(error) };
+
+(async () => {
+  try {
+    const { analyze, defineConfig } = await import(workerData.deslopJsModuleSpecifier);
+    const config = {
+      rootDir: workerData.rootDirectory,
+      ...(workerData.tsConfigPath ? { tsConfigPath: workerData.tsConfigPath } : {}),
+      ...(workerData.ignorePatterns.length > 0 ? { ignorePatterns: workerData.ignorePatterns } : {}),
+    };
+    const result = await analyze(defineConfig(config));
+    parentPort.postMessage({ ok: true, result: normalizeResult(result) });
+  } catch (error) {
+    parentPort.postMessage({ ok: false, error: serializeError(error) });
+  }
+})();
+`;
 const resolveTsConfigPath = (rootDirectory) => {
 	for (const filename of TSCONFIG_FILENAMES$1) {
 		const candidate = path.join(rootDirectory, filename);
@@ -4501,16 +4601,180 @@ const toRelativeFilePath = (rootDirectory, filePath) => {
 	const relative = toRelativePath(filePath, rootDirectory);
 	return relative.length > 0 ? relative : filePath.replace(/\\/g, "/");
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseArray = (value, label) => {
+	if (!Array.isArray(value)) throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseString = (value, label) => {
+	if (typeof value !== "string") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseNumber = (value, label) => {
+	if (typeof value !== "number") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseBoolean = (value, label) => {
+	if (typeof value !== "boolean") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseStringArray = (value, label) => {
+	return parseArray(value, label).map((entry, index) => parseString(entry, `${label}[${index}]`));
+};
+const parseUnusedFiles = (value) => {
+	const values = parseArray(value, "unusedFiles");
+	const unusedFiles = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedFiles[${index}].`);
+		unusedFiles.push({ path: parseString(entry.path, `unusedFiles[${index}].path`) });
+	}
+	return unusedFiles;
+};
+const parseUnusedExports = (value) => {
+	const values = parseArray(value, "unusedExports");
+	const unusedExports = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedExports[${index}].`);
+		unusedExports.push({
+			path: parseString(entry.path, `unusedExports[${index}].path`),
+			name: parseString(entry.name, `unusedExports[${index}].name`),
+			line: parseNumber(entry.line, `unusedExports[${index}].line`),
+			column: parseNumber(entry.column, `unusedExports[${index}].column`),
+			isTypeOnly: parseBoolean(entry.isTypeOnly, `unusedExports[${index}].isTypeOnly`)
+		});
+	}
+	return unusedExports;
+};
+const parseUnusedDependencies = (value) => {
+	const values = parseArray(value, "unusedDependencies");
+	const unusedDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedDependencies[${index}].`);
+		unusedDependencies.push({
+			name: parseString(entry.name, `unusedDependencies[${index}].name`),
+			isDevDependency: parseBoolean(entry.isDevDependency, `unusedDependencies[${index}].isDevDependency`)
+		});
+	}
+	return unusedDependencies;
+};
+const parseCircularDependencies = (value) => {
+	const values = parseArray(value, "circularDependencies");
+	const circularDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid circularDependencies[${index}].`);
+		circularDependencies.push({ files: parseStringArray(entry.files, `circularDependencies[${index}].files`) });
+	}
+	return circularDependencies;
+};
+const parseDeadCodeWorkerResult = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid result.");
+	return {
+		unusedFiles: parseUnusedFiles(value.unusedFiles),
+		unusedExports: parseUnusedExports(value.unusedExports),
+		unusedDependencies: parseUnusedDependencies(value.unusedDependencies),
+		circularDependencies: parseCircularDependencies(value.circularDependencies)
+	};
+};
+const parseDeadCodeWorkerError = (value) => {
+	if (!isRecord(value) || typeof value.message !== "string") return { message: "Dead-code worker failed." };
+	return {
+		...typeof value.name === "string" ? { name: value.name } : {},
+		message: value.message,
+		...typeof value.stack === "string" ? { stack: value.stack } : {}
+	};
+};
+const parseDeadCodeWorkerMessage = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid message.");
+	if (value.ok === true) return {
+		ok: true,
+		result: value.result
+	};
+	if (value.ok === false) return {
+		ok: false,
+		error: parseDeadCodeWorkerError(value.error)
+	};
+	throw new Error("Dead-code worker returned an invalid status.");
+};
+const buildDeadCodeWorkerError = (workerError) => {
+	const error = new Error(workerError.message);
+	if (workerError.name !== void 0) error.name = workerError.name;
+	if (workerError.stack !== void 0) error.stack = workerError.stack;
+	return error;
+};
+const createDeadCodeWorker = (input) => {
+	const worker = new Worker(DEAD_CODE_WORKER_SCRIPT, {
+		eval: true,
+		workerData: input
+	});
+	let didSettle = false;
+	return {
+		result: new Promise((resolve, reject) => {
+			const settle = (callback) => {
+				if (didSettle) return;
+				didSettle = true;
+				worker.removeAllListeners();
+				callback();
+			};
+			worker.once("message", (message) => {
+				try {
+					const parsedMessage = parseDeadCodeWorkerMessage(message);
+					if (parsedMessage.ok) {
+						settle(() => resolve(parsedMessage.result));
+						return;
+					}
+					settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
+				} catch (error) {
+					settle(() => reject(error));
+				}
+			});
+			worker.once("error", (error) => {
+				settle(() => reject(error));
+			});
+			worker.once("exit", (exitCode) => {
+				if (exitCode === 0) return;
+				settle(() => reject(/* @__PURE__ */ new Error(`Dead-code worker exited with code ${exitCode}.`)));
+			});
+		}),
+		terminate: () => {
+			didSettle = true;
+			worker.removeAllListeners();
+			return worker.terminate();
+		}
+	};
+};
+const runDeadCodeWorkerWithTimeout = (handle, timeoutMs) => new Promise((resolve, reject) => {
+	let didSettle = false;
+	const timeoutHandle = setTimeout(() => {
+		if (didSettle) return;
+		didSettle = true;
+		handle.terminate?.();
+		reject(/* @__PURE__ */ new Error(`Dead-code worker timed out after ${timeoutMs / MILLISECONDS_PER_SECOND}s.`));
+	}, timeoutMs);
+	timeoutHandle.unref?.();
+	handle.result.then((value) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		resolve(value);
+	}, (error) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		reject(error);
+	});
+});
 const checkDeadCode = async (options) => {
 	const { rootDirectory, userConfig } = options;
 	if (!fs.existsSync(path.join(rootDirectory, "package.json"))) return [];
-	const { analyze, defineConfig } = await import("deslop-js");
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory, userConfig);
-	const result = await analyze(defineConfig({
-		rootDir: rootDirectory,
+	const result = parseDeadCodeWorkerResult(await runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
+		rootDirectory,
 		tsConfigPath: resolveTsConfigPath(rootDirectory),
-		...ignorePatterns.length > 0 ? { ignorePatterns } : {}
-	}));
+		ignorePatterns,
+		deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js")
+	}), options.workerTimeoutMs ?? 12e4));
 	const toRelative = (filePath) => toRelativeFilePath(rootDirectory, filePath);
 	const diagnostics = [];
 	for (const unusedFile of result.unusedFiles) diagnostics.push({
@@ -4614,7 +4878,7 @@ var Files = class Files extends Context.Service()("react-doctor/Files") {
 	* pattern in react-doctor-evals' test layers.
 	*/
 	static layerInMemory = (tree) => {
-		const resolveAbsolute = (filePath, rootDirectory) => Path.isAbsolute(filePath) ? filePath : Path.join(rootDirectory, filePath);
+		const resolveAbsolute = (filePath, rootDirectory) => Path.isAbsolute(filePath) ? filePath : `${rootDirectory}/${filePath}`;
 		return Layer.succeed(Files, Files.of({
 			readLines: (input) => Effect.sync(() => {
 				const absolute = resolveAbsolute(input.filePath, input.rootDirectory);
@@ -4622,17 +4886,17 @@ var Files = class Files extends Context.Service()("react-doctor/Files") {
 				return content === void 0 ? null : content.split("\n");
 			}),
 			listSourceFiles: (rootDirectory) => Effect.sync(() => {
-				const prefix = rootDirectory.endsWith(Path.sep) ? rootDirectory : `${rootDirectory}${Path.sep}`;
+				const prefix = rootDirectory.endsWith("/") ? rootDirectory : `${rootDirectory}/`;
 				const files = [];
 				for (const absolute of tree.keys()) {
 					if (!absolute.startsWith(prefix)) continue;
-					files.push(absolute.slice(prefix.length).split(Path.sep).join("/"));
+					files.push(absolute.slice(prefix.length));
 				}
 				return files;
 			}),
 			isFile: (filePath) => Effect.sync(() => tree.has(filePath)),
 			isDirectory: (filePath) => Effect.sync(() => {
-				const prefix = filePath.endsWith(Path.sep) ? filePath : `${filePath}${Path.sep}`;
+				const prefix = filePath.endsWith("/") ? filePath : `${filePath}/`;
 				for (const absolute of tree.keys()) if (absolute.startsWith(prefix)) return true;
 				return false;
 			})
@@ -5134,7 +5398,15 @@ const buildCapabilities = (project) => {
 	capabilities.add(project.framework);
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
 	const reactMajor = project.reactMajorVersion;
-	if (reactMajor !== null) for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+	if (reactMajor !== null) {
+		for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+		if (reactMajor >= 19) {
+			if (isReactAtLeast(parseReactMajorMinor(project.reactVersion), {
+				major: 19,
+				minor: 2
+			})) capabilities.add("react:19.2");
+		}
+	}
 	if (project.tailwindVersion !== null) {
 		capabilities.add("tailwind");
 		if (isTailwindAtLeast(parseTailwindMajorMinor(project.tailwindVersion), {
@@ -5145,6 +5417,10 @@ const buildCapabilities = (project) => {
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
 	if (project.hasTanStackQuery) capabilities.add("tanstack-query");
 	if (project.hasTypeScript) capabilities.add("typescript");
+	if (project.hasPreact) {
+		capabilities.add("preact");
+		if (project.reactVersion === null) capabilities.add("pure-preact");
+	}
 	return capabilities;
 };
 const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledBy) => {
@@ -5769,7 +6045,7 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule, project);
 		return {
-			filePath: diagnostic.filename,
+			filePath: diagnostic.filename.replaceAll("\\", "/"),
 			plugin,
 			rule,
 			severity: diagnostic.severity,
@@ -6474,17 +6750,6 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		didFail: false,
 		reason: null
 	});
-	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
-	const deadCodeFiber = yield* Effect.forkChild(shouldRunDeadCode ? Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
-		rootDirectory: scanDirectory,
-		userConfig: resolvedConfig.config
-	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
-		yield* Ref.set(deadCodeFailure, {
-			didFail: true,
-			reason: error.message
-		});
-		return Stream.empty;
-	})))))) : Effect.succeed([]));
 	const scanProgress = yield* progressService.start("Scanning...");
 	const scanStartTime = Date.now();
 	let lastReportedTotalFileCount = 0;
@@ -6514,11 +6779,18 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const lintCollected = yield* Stream.runCollect(applyPerElementPipeline(rawLintStream));
 	const lintFailureState = yield* Ref.get(lintFailure);
 	yield* afterLint(lintFailureState.didFail);
-	if (lintFailureState.didFail) {
-		yield* Fiber.interrupt(deadCodeFiber);
-		yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
-	}
-	const deadCodeCollected = lintFailureState.didFail ? [] : yield* Fiber.join(deadCodeFiber);
+	if (lintFailureState.didFail) yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
+	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
+	const deadCodeCollected = lintFailureState.didFail || !shouldRunDeadCode ? [] : yield* scanProgress.update("Analyzing dead code...").pipe(Effect.andThen(Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
+		rootDirectory: scanDirectory,
+		userConfig: resolvedConfig.config
+	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
+		yield* Ref.set(deadCodeFailure, {
+			didFail: true,
+			reason: error.message
+		});
+		return Stream.empty;
+	}))))))));
 	const deadCodeFailureState = yield* Ref.get(deadCodeFailure);
 	const scanElapsedSeconds = ((Date.now() - scanStartTime) / 1e3).toFixed(1);
 	const totalFileCount = lastReportedTotalFileCount || (lintIncludePaths?.length ?? project.sourceFileCount);
@@ -7013,7 +7285,7 @@ var cli_logger_exports = /* @__PURE__ */ __exportAll({ cliLogger: () => cliLogge
 /**
 * Thin synchronous façade over Effect's `Console` module. Used by
 * the imperative CLI helper files (`select-projects`, `run-explain`,
-* `install-skill`, the legacy paths in `cli/commands/inspect.ts`)
+* `install-react-doctor`, the legacy paths in `cli/commands/inspect.ts`)
 * that aren't yet Effect-typed. Every call drains into a single
 * `Console.*` Effect via `Effect.runSync`, so the underlying logging
 * pipeline is identical to the canonical `yield* Console.log(...)`
@@ -7046,4 +7318,4 @@ const cliLogger = {
 //#endregion
 export { isReactDoctorError as A, filterSourceFiles as C, groupBy as D, getDiffInfo as E, runInspect as F, toRelativePath as I, listWorkspacePackages as M, resolveScanTarget as N, highlighter as O, restoreLegacyThrow as P, filterDiagnosticsForSurface as S, formatReactDoctorError as T, Score as _, DeadCode as a, buildJsonReportError as b, LintPartialFailures as c, OXLINT_NODE_REQUIREMENT as d, Progress as f, SKILL_NAME as g, SHARE_BASE_URL as h, Config as i, layerOtlp as j, isMonorepoRoot as k, Linter as l, Reporter as m, cli_logger_exports as n, Files as o, Project as p, CANONICAL_GITHUB_URL as r, Git as s, cliLogger as t, NodeResolver as u, StagedFiles as v, formatErrorChain as w, discoverReactSubprojects as x, buildJsonReport as y };
 
-//# sourceMappingURL=cli-logger-C35LXalM.js.map
+//# sourceMappingURL=cli-logger-BRBUS1pE.js.map