@jsenv/test 3.0.16 → 3.0.18

package/dist/jsenv_test.js

@@ -4,8 +4,8 @@ import { readdir, chmod, stat, lstat, promises, readFile as readFile$1, writeFil
 import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { URL_META, createException } from "./js/exception.js";
-import stringWidth from "string-width";
 import tty from "node:tty";
+import stringWidth from "string-width";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { dirname } from "node:path";
 import crypto from "node:crypto";
@@ -530,599 +530,339 @@ const SIGINT_CALLBACK = {
   },
 };
 
-const LOG_LEVEL_OFF = "off";
-
-const LOG_LEVEL_DEBUG = "debug";
-
-const LOG_LEVEL_INFO = "info";
-
-const LOG_LEVEL_WARN = "warn";
+const createDetailedMessage = (message, details = {}) => {
+  let string = `${message}`;
 
-const LOG_LEVEL_ERROR = "error";
+  Object.keys(details).forEach((key) => {
+    const value = details[key];
+    string += `
+--- ${key} ---
+${
+  Array.isArray(value)
+    ? value.join(`
+`)
+    : value
+}`;
+  });
 
-const createLogger = ({ logLevel = LOG_LEVEL_INFO } = {}) => {
-  if (logLevel === LOG_LEVEL_DEBUG) {
-    return {
-      level: "debug",
-      levels: { debug: true, info: true, warn: true, error: true },
-      debug,
-      info,
-      warn,
-      error,
-    };
-  }
-  if (logLevel === LOG_LEVEL_INFO) {
-    return {
-      level: "info",
-      levels: { debug: false, info: true, warn: true, error: true },
-      debug: debugDisabled,
-      info,
-      warn,
-      error,
-    };
-  }
-  if (logLevel === LOG_LEVEL_WARN) {
-    return {
-      level: "warn",
-      levels: { debug: false, info: false, warn: true, error: true },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn,
-      error,
-    };
-  }
-  if (logLevel === LOG_LEVEL_ERROR) {
-    return {
-      level: "error",
-      levels: { debug: false, info: false, warn: false, error: true },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error,
-    };
-  }
-  if (logLevel === LOG_LEVEL_OFF) {
-    return {
-      level: "off",
-      levels: { debug: false, info: false, warn: false, error: false },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error: errorDisabled,
-    };
-  }
-  throw new Error(`unexpected logLevel.
---- logLevel ---
-${logLevel}
---- allowed log levels ---
-${LOG_LEVEL_OFF}
-${LOG_LEVEL_ERROR}
-${LOG_LEVEL_WARN}
-${LOG_LEVEL_INFO}
-${LOG_LEVEL_DEBUG}`);
+  return string;
 };
 
-const debug = (...args) => console.debug(...args);
-
-const debugDisabled = () => {};
-
-const info = (...args) => console.info(...args);
+// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
+/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
 
-const infoDisabled = () => {};
+const {env} = process$1;
 
-const warn = (...args) => console.warn(...args);
+let flagForceColor;
+if (
+	hasFlag('no-color')
+	|| hasFlag('no-colors')
+	|| hasFlag('color=false')
+	|| hasFlag('color=never')
+) {
+	flagForceColor = 0;
+} else if (
+	hasFlag('color')
+	|| hasFlag('colors')
+	|| hasFlag('color=true')
+	|| hasFlag('color=always')
+) {
+	flagForceColor = 1;
+}
 
-const warnDisabled = () => {};
+function envForceColor() {
+	if ('FORCE_COLOR' in env) {
+		if (env.FORCE_COLOR === 'true') {
+			return 1;
+		}
 
-const error = (...args) => console.error(...args);
+		if (env.FORCE_COLOR === 'false') {
+			return 0;
+		}
 
-const errorDisabled = () => {};
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
 
-/* globals WorkerGlobalScope, DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope */
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
 
-const isBrowser = globalThis.window?.document !== undefined;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3,
+	};
+}
 
-globalThis.process?.versions?.node !== undefined;
+function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== undefined) {
+		flagForceColor = noFlagForceColor;
+	}
 
-globalThis.process?.versions?.bun !== undefined;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
 
-globalThis.Deno?.version?.deno !== undefined;
+	if (forceColor === 0) {
+		return 0;
+	}
 
-globalThis.process?.versions?.electron !== undefined;
+	if (sniffFlags) {
+		if (hasFlag('color=16m')
+			|| hasFlag('color=full')
+			|| hasFlag('color=truecolor')) {
+			return 3;
+		}
 
-globalThis.navigator?.userAgent?.includes('jsdom') === true;
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+	}
 
-typeof WorkerGlobalScope !== 'undefined' && globalThis instanceof WorkerGlobalScope;
+	// Check for Azure DevOps pipelines.
+	// Has to be above the `!streamIsTTY` check.
+	if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+		return 1;
+	}
 
-typeof DedicatedWorkerGlobalScope !== 'undefined' && globalThis instanceof DedicatedWorkerGlobalScope;
+	if (haveStream && !streamIsTTY && forceColor === undefined) {
+		return 0;
+	}
 
-typeof SharedWorkerGlobalScope !== 'undefined' && globalThis instanceof SharedWorkerGlobalScope;
+	const min = forceColor || 0;
 
-typeof ServiceWorkerGlobalScope !== 'undefined' && globalThis instanceof ServiceWorkerGlobalScope;
+	if (env.TERM === 'dumb') {
+		return min;
+	}
 
-// Note: I'm intentionally not DRYing up the other variables to keep them "lazy".
-const platform = globalThis.navigator?.userAgentData?.platform;
+	if (process$1.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = os.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10
+			&& Number(osRelease[2]) >= 10_586
+		) {
+			return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+		}
 
-platform === 'macOS'
-	|| globalThis.navigator?.platform === 'MacIntel' // Even on Apple silicon Macs.
-	|| globalThis.navigator?.userAgent?.includes(' Mac ') === true
-	|| globalThis.process?.platform === 'darwin';
+		return 1;
+	}
 
-platform === 'Windows'
-	|| globalThis.navigator?.platform === 'Win32'
-	|| globalThis.process?.platform === 'win32';
+	if ('CI' in env) {
+		if ('GITHUB_ACTIONS' in env || 'GITEA_ACTIONS' in env) {
+			return 3;
+		}
 
-platform === 'Linux'
-	|| globalThis.navigator?.platform?.startsWith('Linux') === true
-	|| globalThis.navigator?.userAgent?.includes(' Linux ') === true
-	|| globalThis.process?.platform === 'linux';
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
 
-platform === 'Android'
-	|| globalThis.navigator?.platform === 'Android'
-	|| globalThis.navigator?.userAgent?.includes(' Android ') === true
-	|| globalThis.process?.platform === 'android';
+		return min;
+	}
 
-const ESC = '\u001B[';
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
 
-!isBrowser && process$1.env.TERM_PROGRAM === 'Apple_Terminal';
-const isWindows$3 = !isBrowser && process$1.platform === 'win32';
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
 
-isBrowser ? () => {
-	throw new Error('`process.cwd()` only works in Node.js, not the browser.');
-} : process$1.cwd;
+	if (env.TERM === 'xterm-kitty') {
+		return 3;
+	}
 
-const cursorUp = (count = 1) => ESC + count + 'A';
+	if ('TERM_PROGRAM' in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 
-const cursorLeft = ESC + 'G';
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app': {
+				return version >= 3 ? 3 : 2;
+			}
 
-const eraseLines = count => {
-	let clear = '';
+			case 'Apple_Terminal': {
+				return 2;
+			}
+			// No default
+		}
+	}
 
-	for (let i = 0; i < count; i++) {
-		clear += eraseLine + (i < count - 1 ? cursorUp() : '');
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
 	}
 
-	if (count) {
-		clear += cursorLeft;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
 	}
 
-	return clear;
-};
-const eraseLine = ESC + '2K';
-const eraseScreen = ESC + '2J';
-
-const clearTerminal = isWindows$3
-	? `${eraseScreen}${ESC}0f`
-	// 1. Erases the screen (Only done in case `2` is not supported)
-	// 2. Erases the whole screen including scrollback buffer
-	// 3. Moves cursor to the top-left position
-	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	:	`${eraseScreen}${ESC}3J${ESC}H`;
-
-/*
- * see also https://github.com/vadimdemedes/ink
- */
+	if ('COLORTERM' in env) {
+		return 1;
+	}
 
+	return min;
+}
 
-const createDynamicLog = ({
-  stream = process.stdout,
-  clearTerminalAllowed,
-  onVerticalOverflow = () => {},
-  onWriteFromOutside = () => {},
-} = {}) => {
-  const { columns = 80, rows = 24 } = stream;
-  const dynamicLog = {
-    destroyed: false,
-    onVerticalOverflow,
-    onWriteFromOutside,
-  };
+function createSupportsColor(stream, options = {}) {
+	const level = _supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options,
+	});
 
-  let lastOutput = "";
-  let lastOutputFromOutside = "";
-  let clearAttemptResult;
-  let writing = false;
+	return translateLevel(level);
+}
 
-  const getErasePreviousOutput = () => {
-    // nothing to clear
-    if (!lastOutput) {
-      return "";
-    }
-    if (clearAttemptResult !== undefined) {
-      return "";
-    }
+const supportsColor = {
+	stdout: createSupportsColor({isTTY: tty.isatty(1)}),
+	stderr: createSupportsColor({isTTY: tty.isatty(2)}),
+};
 
-    const logLines = lastOutput.split(/\r\n|\r|\n/);
-    let visualLineCount = 0;
-    for (const logLine of logLines) {
-      const width = stringWidth(logLine);
-      if (width === 0) {
-        visualLineCount++;
-      } else {
-        visualLineCount += Math.ceil(width / columns);
-      }
-    }
+// https://github.com/Marak/colors.js/blob/master/lib/styles.js
+// https://stackoverflow.com/a/75985833/2634179
+const RESET = "\x1b[0m";
 
-    if (visualLineCount > rows) {
-      if (clearTerminalAllowed) {
-        clearAttemptResult = true;
-        return clearTerminal;
-      }
-      // the whole log cannot be cleared because it's vertically to long
-      // (longer than terminal height)
-      // readline.moveCursor cannot move cursor higher than screen height
-      // it means we would only clear the visible part of the log
-      // better keep the log untouched
-      clearAttemptResult = false;
-      dynamicLog.onVerticalOverflow();
-      return "";
-    }
+const createAnsi = ({ supported }) => {
+  const ANSI = {
+    supported,
+
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+    BLUE: "\x1b[34m",
+    MAGENTA: "\x1b[35m",
+    CYAN: "\x1b[36m",
+    GREY: "\x1b[90m",
+    color: (text, ANSI_COLOR) => {
+      return ANSI.supported && ANSI_COLOR
+        ? `${ANSI_COLOR}${text}${RESET}`
+        : text;
+    },
 
-    clearAttemptResult = true;
-    return eraseLines(visualLineCount);
+    BOLD: "\x1b[1m",
+    UNDERLINE: "\x1b[4m",
+    STRIKE: "\x1b[9m",
+    effect: (text, ANSI_EFFECT) => {
+      return ANSI.supported && ANSI_EFFECT
+        ? `${ANSI_EFFECT}${text}${RESET}`
+        : text;
+    },
   };
 
-  const update = (string) => {
-    if (dynamicLog.destroyed) {
-      throw new Error("Cannot write log after destroy");
-    }
-    let stringToWrite = string;
-    if (lastOutput) {
-      if (lastOutputFromOutside) {
-        // We don't want to clear logs written by other code,
-        // it makes output unreadable and might erase precious information
-        // To detect this we put a spy on the stream.
-        // The spy is required only if we actually wrote something in the stream
-        // something else than this code has written in the stream
-        // so we just write without clearing (append instead of replacing)
-        lastOutput = "";
-        lastOutputFromOutside = "";
-      } else {
-        stringToWrite = `${getErasePreviousOutput()}${string}`;
-      }
-    }
-    writing = true;
-    stream.write(stringToWrite);
-    lastOutput = string;
-    writing = false;
-    clearAttemptResult = undefined;
-  };
+  return ANSI;
+};
 
-  const clearDuringFunctionCall = (
-    callback,
-    ouputAfterCallback = lastOutput,
-  ) => {
-    // 1. Erase the current log
-    // 2. Call callback (expect to write something on stdout)
-    // 3. Restore the current log
-    // During step 2. we expect a "write from outside" so we uninstall
-    // the stream spy during function call
-    update("");
+const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic;
 
-    writing = true;
-    callback();
-    writing = false;
+const ANSI = createAnsi({
+  supported:
+    processSupportsBasicColor ||
+    // GitHub workflow does support ANSI but "supports-color" returns false
+    // because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+    process.env.GITHUB_WORKFLOW,
+});
 
-    update(ouputAfterCallback);
-  };
+function isUnicodeSupported() {
+	if (process$1.platform !== 'win32') {
+		return process$1.env.TERM !== 'linux'; // Linux console (kernel)
+	}
 
-  const writeFromOutsideEffect = (value) => {
-    if (!lastOutput) {
-      // we don't care if the log never wrote anything
-      // or if last update() wrote an empty string
-      return;
-    }
-    if (writing) {
-      return;
-    }
-    lastOutputFromOutside = value;
-    dynamicLog.onWriteFromOutside(value);
-  };
+	return Boolean(process$1.env.WT_SESSION) // Windows Terminal
+		|| Boolean(process$1.env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
+		|| process$1.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+		|| process$1.env.TERM_PROGRAM === 'Terminus-Sublime'
+		|| process$1.env.TERM_PROGRAM === 'vscode'
+		|| process$1.env.TERM === 'xterm-256color'
+		|| process$1.env.TERM === 'alacritty'
+		|| process$1.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}
 
-  let removeStreamSpy;
-  if (stream === process.stdout) {
-    const removeStdoutSpy = spyStreamOutput(
-      process.stdout,
-      writeFromOutsideEffect,
-    );
-    const removeStderrSpy = spyStreamOutput(
-      process.stderr,
-      writeFromOutsideEffect,
-    );
-    removeStreamSpy = () => {
-      removeStdoutSpy();
-      removeStderrSpy();
-    };
-  } else {
-    removeStreamSpy = spyStreamOutput(stream, writeFromOutsideEffect);
-  }
+// see also https://github.com/sindresorhus/figures
 
-  const destroy = () => {
-    dynamicLog.destroyed = true;
-    if (removeStreamSpy) {
-      removeStreamSpy();
-      removeStreamSpy = null;
-      lastOutput = "";
-      lastOutputFromOutside = "";
-    }
+const createUnicode = ({ supported, ANSI }) => {
+  const UNICODE = {
+    supported,
+    get COMMAND_RAW() {
+      return UNICODE.supported ? `❯` : `>`;
+    },
+    get OK_RAW() {
+      return UNICODE.supported ? `✔` : `√`;
+    },
+    get FAILURE_RAW() {
+      return UNICODE.supported ? `✖` : `×`;
+    },
+    get DEBUG_RAW() {
+      return UNICODE.supported ? `◆` : `♦`;
+    },
+    get INFO_RAW() {
+      return UNICODE.supported ? `ℹ` : `i`;
+    },
+    get WARNING_RAW() {
+      return UNICODE.supported ? `⚠` : `‼`;
+    },
+    get CIRCLE_CROSS_RAW() {
+      return UNICODE.supported ? `ⓧ` : `(×)`;
+    },
+    get COMMAND() {
+      return ANSI.color(UNICODE.COMMAND_RAW, ANSI.GREY); // ANSI_MAGENTA)
+    },
+    get OK() {
+      return ANSI.color(UNICODE.OK_RAW, ANSI.GREEN);
+    },
+    get FAILURE() {
+      return ANSI.color(UNICODE.FAILURE_RAW, ANSI.RED);
+    },
+    get DEBUG() {
+      return ANSI.color(UNICODE.DEBUG_RAW, ANSI.GREY);
+    },
+    get INFO() {
+      return ANSI.color(UNICODE.INFO_RAW, ANSI.BLUE);
+    },
+    get WARNING() {
+      return ANSI.color(UNICODE.WARNING_RAW, ANSI.YELLOW);
+    },
+    get CIRCLE_CROSS() {
+      return ANSI.color(UNICODE.CIRCLE_CROSS_RAW, ANSI.RED);
+    },
+    get ELLIPSIS() {
+      return UNICODE.supported ? `…` : `...`;
+    },
   };
-
-  Object.assign(dynamicLog, {
-    update,
-    destroy,
-    stream,
-    clearDuringFunctionCall,
-  });
-  return dynamicLog;
+  return UNICODE;
 };
 
-// maybe https://github.com/gajus/output-interceptor/tree/v3.0.0 ?
-// the problem with listening data on stdout
-// is that node.js will later throw error if stream gets closed
-// while something listening data on it
-const spyStreamOutput = (stream, callback) => {
-  const originalWrite = stream.write;
-
-  let output = "";
-  let installed = true;
-
-  stream.write = function (...args /* chunk, encoding, callback */) {
-    output += args;
-    callback(output);
-    return originalWrite.call(stream, ...args);
-  };
+const UNICODE = createUnicode({
+  supported: isUnicodeSupported(),
+  ANSI,
+});
 
-  const uninstall = () => {
-    if (!installed) {
-      return;
-    }
-    stream.write = originalWrite;
-    installed = false;
-  };
+const setRoundedPrecision = (
+  number,
+  { decimals = 1, decimalsWhenSmall = decimals } = {},
+) => {
+  return setDecimalsPrecision(number, {
+    decimals,
+    decimalsWhenSmall,
+    transform: Math.round,
+  });
+};
 
-  return () => {
-    uninstall();
-    return output;
-  };
-};
-
-// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
-/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
-	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-	const position = argv.indexOf(prefix + flag);
-	const terminatorPosition = argv.indexOf('--');
-	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-
-const {env} = process$1;
-
-let flagForceColor;
-if (
-	hasFlag('no-color')
-	|| hasFlag('no-colors')
-	|| hasFlag('color=false')
-	|| hasFlag('color=never')
-) {
-	flagForceColor = 0;
-} else if (
-	hasFlag('color')
-	|| hasFlag('colors')
-	|| hasFlag('color=true')
-	|| hasFlag('color=always')
-) {
-	flagForceColor = 1;
-}
-
-function envForceColor() {
-	if ('FORCE_COLOR' in env) {
-		if (env.FORCE_COLOR === 'true') {
-			return 1;
-		}
-
-		if (env.FORCE_COLOR === 'false') {
-			return 0;
-		}
-
-		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-	}
-}
-
-function translateLevel(level) {
-	if (level === 0) {
-		return false;
-	}
-
-	return {
-		level,
-		hasBasic: true,
-		has256: level >= 2,
-		has16m: level >= 3,
-	};
-}
-
-function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
-	const noFlagForceColor = envForceColor();
-	if (noFlagForceColor !== undefined) {
-		flagForceColor = noFlagForceColor;
-	}
-
-	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-
-	if (forceColor === 0) {
-		return 0;
-	}
-
-	if (sniffFlags) {
-		if (hasFlag('color=16m')
-			|| hasFlag('color=full')
-			|| hasFlag('color=truecolor')) {
-			return 3;
-		}
-
-		if (hasFlag('color=256')) {
-			return 2;
-		}
-	}
-
-	// Check for Azure DevOps pipelines.
-	// Has to be above the `!streamIsTTY` check.
-	if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
-		return 1;
-	}
-
-	if (haveStream && !streamIsTTY && forceColor === undefined) {
-		return 0;
-	}
-
-	const min = forceColor || 0;
-
-	if (env.TERM === 'dumb') {
-		return min;
-	}
-
-	if (process$1.platform === 'win32') {
-		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
-		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-		const osRelease = os.release().split('.');
-		if (
-			Number(osRelease[0]) >= 10
-			&& Number(osRelease[2]) >= 10_586
-		) {
-			return Number(osRelease[2]) >= 14_931 ? 3 : 2;
-		}
-
-		return 1;
-	}
-
-	if ('CI' in env) {
-		if ('GITHUB_ACTIONS' in env || 'GITEA_ACTIONS' in env) {
-			return 3;
-		}
-
-		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
-			return 1;
-		}
-
-		return min;
-	}
-
-	if ('TEAMCITY_VERSION' in env) {
-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-	}
-
-	if (env.COLORTERM === 'truecolor') {
-		return 3;
-	}
-
-	if (env.TERM === 'xterm-kitty') {
-		return 3;
-	}
-
-	if ('TERM_PROGRAM' in env) {
-		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-
-		switch (env.TERM_PROGRAM) {
-			case 'iTerm.app': {
-				return version >= 3 ? 3 : 2;
-			}
-
-			case 'Apple_Terminal': {
-				return 2;
-			}
-			// No default
-		}
-	}
-
-	if (/-256(color)?$/i.test(env.TERM)) {
-		return 2;
-	}
-
-	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-		return 1;
-	}
-
-	if ('COLORTERM' in env) {
-		return 1;
-	}
-
-	return min;
-}
-
-function createSupportsColor(stream, options = {}) {
-	const level = _supportsColor(stream, {
-		streamIsTTY: stream && stream.isTTY,
-		...options,
-	});
-
-	return translateLevel(level);
-}
-
-const supportsColor = {
-	stdout: createSupportsColor({isTTY: tty.isatty(1)}),
-	stderr: createSupportsColor({isTTY: tty.isatty(2)}),
-};
-
-const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic;
-// https://github.com/Marak/colors.js/blob/master/lib/styles.js
-// https://stackoverflow.com/a/75985833/2634179
-const RESET = "\x1b[0m";
-
-const ANSI = {
-  supported: processSupportsBasicColor,
-
-  RED: "\x1b[31m",
-  GREEN: "\x1b[32m",
-  YELLOW: "\x1b[33m",
-  BLUE: "\x1b[34m",
-  MAGENTA: "\x1b[35m",
-  CYAN: "\x1b[36m",
-  GREY: "\x1b[90m",
-  color: (text, ANSI_COLOR) => {
-    return ANSI.supported && ANSI_COLOR ? `${ANSI_COLOR}${text}${RESET}` : text;
-  },
-
-  BOLD: "\x1b[1m",
-  UNDERLINE: "\x1b[4m",
-  STRIKE: "\x1b[9m",
-  effect: (text, ANSI_EFFECT) => {
-    return ANSI.supported && ANSI_EFFECT
-      ? `${ANSI_EFFECT}${text}${RESET}`
-      : text;
-  },
-};
-
-// GitHub workflow does support ANSI but "supports-color" returns false
-// because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
-if (
-  process.env.GITHUB_WORKFLOW &&
-  // Check on FORCE_COLOR is to ensure it is prio over GitHub workflow check
-  // in unit test we use process.env.FORCE_COLOR = 'false' to fake
-  // that colors are not supported. Let it have priority
-  process.env.FORCE_COLOR !== "false"
-) {
-  ANSI.supported = true;
-}
-
-const setRoundedPrecision = (
-  number,
-  { decimals = 1, decimalsWhenSmall = decimals } = {},
-) => {
-  return setDecimalsPrecision(number, {
-    decimals,
-    decimalsWhenSmall,
-    transform: Math.round,
-  });
-};
-
-const setPrecision = (
-  number,
-  { decimals = 1, decimalsWhenSmall = decimals } = {},
-) => {
-  return setDecimalsPrecision(number, {
-    decimals,
-    decimalsWhenSmall,
-    transform: parseInt,
-  });
+const setPrecision = (
+  number,
+  { decimals = 1, decimalsWhenSmall = decimals } = {},
+) => {
+  return setDecimalsPrecision(number, {
+    decimals,
+    decimalsWhenSmall,
+    transform: parseInt,
+  });
 };
 
 const setDecimalsPrecision = (
@@ -1292,99 +1032,13 @@ const parseMs = (ms) => {
   };
 };
 
-function isUnicodeSupported() {
-	if (process$1.platform !== 'win32') {
-		return process$1.env.TERM !== 'linux'; // Linux console (kernel)
-	}
-
-	return Boolean(process$1.env.WT_SESSION) // Windows Terminal
-		|| Boolean(process$1.env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
-		|| process$1.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
-		|| process$1.env.TERM_PROGRAM === 'Terminus-Sublime'
-		|| process$1.env.TERM_PROGRAM === 'vscode'
-		|| process$1.env.TERM === 'xterm-256color'
-		|| process$1.env.TERM === 'alacritty'
-		|| process$1.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
-}
-
-// see also https://github.com/sindresorhus/figures
-
-
-const UNICODE = {
-  supported: isUnicodeSupported(),
-
-  get COMMAND_RAW() {
-    return UNICODE.supported ? `❯` : `>`;
-  },
-  get OK_RAW() {
-    return UNICODE.supported ? `✔` : `√`;
-  },
-  get FAILURE_RAW() {
-    return UNICODE.supported ? `✖` : `×`;
-  },
-  get DEBUG_RAW() {
-    return UNICODE.supported ? `◆` : `♦`;
-  },
-  get INFO_RAW() {
-    return UNICODE.supported ? `ℹ` : `i`;
-  },
-  get WARNING_RAW() {
-    return UNICODE.supported ? `⚠` : `‼`;
-  },
-  get CIRCLE_CROSS_RAW() {
-    return UNICODE.supported ? `ⓧ` : `(×)`;
-  },
-  get COMMAND() {
-    return ANSI.color(UNICODE.COMMAND_RAW, ANSI.GREY); // ANSI_MAGENTA)
-  },
-  get OK() {
-    return ANSI.color(UNICODE.OK_RAW, ANSI.GREEN);
-  },
-  get FAILURE() {
-    return ANSI.color(UNICODE.FAILURE_RAW, ANSI.RED);
-  },
-  get DEBUG() {
-    return ANSI.color(UNICODE.DEBUG_RAW, ANSI.GREY);
-  },
-  get INFO() {
-    return ANSI.color(UNICODE.INFO_RAW, ANSI.BLUE);
-  },
-  get WARNING() {
-    return ANSI.color(UNICODE.WARNING_RAW, ANSI.YELLOW);
-  },
-  get CIRCLE_CROSS() {
-    return ANSI.color(UNICODE.CIRCLE_CROSS_RAW, ANSI.RED);
-  },
-  get ELLIPSIS() {
-    return UNICODE.supported ? `…` : `...`;
-  },
+const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
+  return inspectBytes(numberOfBytes, { decimals, short });
 };
 
-const createDetailedMessage = (message, details = {}) => {
-  let string = `${message}`;
-
-  Object.keys(details).forEach((key) => {
-    const value = details[key];
-    string += `
---- ${key} ---
-${
-  Array.isArray(value)
-    ? value.join(`
-`)
-    : value
-}`;
-  });
-
-  return string;
-};
-
-const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
-  return inspectBytes(numberOfBytes, { decimals, short });
-};
-
-const humanizeMemory = (metricValue, { decimals, short } = {}) => {
-  return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
-};
+const humanizeMemory = (metricValue, { decimals, short } = {}) => {
+  return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
+};
 
 const inspectBytes = (
   number,
@@ -1579,6 +1233,361 @@ const fillLeft$1 = (value, biggestValue, char = " ") => {
   return padded;
 };
 
+const LOG_LEVEL_OFF = "off";
+
+const LOG_LEVEL_DEBUG = "debug";
+
+const LOG_LEVEL_INFO = "info";
+
+const LOG_LEVEL_WARN = "warn";
+
+const LOG_LEVEL_ERROR = "error";
+
+const createLogger = ({ logLevel = LOG_LEVEL_INFO } = {}) => {
+  if (logLevel === LOG_LEVEL_DEBUG) {
+    return {
+      level: "debug",
+      levels: { debug: true, info: true, warn: true, error: true },
+      debug,
+      info,
+      warn,
+      error,
+    };
+  }
+  if (logLevel === LOG_LEVEL_INFO) {
+    return {
+      level: "info",
+      levels: { debug: false, info: true, warn: true, error: true },
+      debug: debugDisabled,
+      info,
+      warn,
+      error,
+    };
+  }
+  if (logLevel === LOG_LEVEL_WARN) {
+    return {
+      level: "warn",
+      levels: { debug: false, info: false, warn: true, error: true },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn,
+      error,
+    };
+  }
+  if (logLevel === LOG_LEVEL_ERROR) {
+    return {
+      level: "error",
+      levels: { debug: false, info: false, warn: false, error: true },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error,
+    };
+  }
+  if (logLevel === LOG_LEVEL_OFF) {
+    return {
+      level: "off",
+      levels: { debug: false, info: false, warn: false, error: false },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error: errorDisabled,
+    };
+  }
+  throw new Error(`unexpected logLevel.
+--- logLevel ---
+${logLevel}
+--- allowed log levels ---
+${LOG_LEVEL_OFF}
+${LOG_LEVEL_ERROR}
+${LOG_LEVEL_WARN}
+${LOG_LEVEL_INFO}
+${LOG_LEVEL_DEBUG}`);
+};
+
+const debug = (...args) => console.debug(...args);
+
+const debugDisabled = () => {};
+
+const info = (...args) => console.info(...args);
+
+const infoDisabled = () => {};
+
+const warn = (...args) => console.warn(...args);
+
+const warnDisabled = () => {};
+
+const error = (...args) => console.error(...args);
+
+const errorDisabled = () => {};
+
+/* globals WorkerGlobalScope, DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope */
+
+const isBrowser = globalThis.window?.document !== undefined;
+
+globalThis.process?.versions?.node !== undefined;
+
+globalThis.process?.versions?.bun !== undefined;
+
+globalThis.Deno?.version?.deno !== undefined;
+
+globalThis.process?.versions?.electron !== undefined;
+
+globalThis.navigator?.userAgent?.includes('jsdom') === true;
+
+typeof WorkerGlobalScope !== 'undefined' && globalThis instanceof WorkerGlobalScope;
+
+typeof DedicatedWorkerGlobalScope !== 'undefined' && globalThis instanceof DedicatedWorkerGlobalScope;
+
+typeof SharedWorkerGlobalScope !== 'undefined' && globalThis instanceof SharedWorkerGlobalScope;
+
+typeof ServiceWorkerGlobalScope !== 'undefined' && globalThis instanceof ServiceWorkerGlobalScope;
+
+// Note: I'm intentionally not DRYing up the other variables to keep them "lazy".
+const platform = globalThis.navigator?.userAgentData?.platform;
+
+platform === 'macOS'
+	|| globalThis.navigator?.platform === 'MacIntel' // Even on Apple silicon Macs.
+	|| globalThis.navigator?.userAgent?.includes(' Mac ') === true
+	|| globalThis.process?.platform === 'darwin';
+
+platform === 'Windows'
+	|| globalThis.navigator?.platform === 'Win32'
+	|| globalThis.process?.platform === 'win32';
+
+platform === 'Linux'
+	|| globalThis.navigator?.platform?.startsWith('Linux') === true
+	|| globalThis.navigator?.userAgent?.includes(' Linux ') === true
+	|| globalThis.process?.platform === 'linux';
+
+platform === 'Android'
+	|| globalThis.navigator?.platform === 'Android'
+	|| globalThis.navigator?.userAgent?.includes(' Android ') === true
+	|| globalThis.process?.platform === 'android';
+
+const ESC = '\u001B[';
+
+!isBrowser && process$1.env.TERM_PROGRAM === 'Apple_Terminal';
+const isWindows$3 = !isBrowser && process$1.platform === 'win32';
+
+isBrowser ? () => {
+	throw new Error('`process.cwd()` only works in Node.js, not the browser.');
+} : process$1.cwd;
+
+const cursorUp = (count = 1) => ESC + count + 'A';
+
+const cursorLeft = ESC + 'G';
+
+const eraseLines = count => {
+	let clear = '';
+
+	for (let i = 0; i < count; i++) {
+		clear += eraseLine + (i < count - 1 ? cursorUp() : '');
+	}
+
+	if (count) {
+		clear += cursorLeft;
+	}
+
+	return clear;
+};
+const eraseLine = ESC + '2K';
+const eraseScreen = ESC + '2J';
+
+const clearTerminal = isWindows$3
+	? `${eraseScreen}${ESC}0f`
+	// 1. Erases the screen (Only done in case `2` is not supported)
+	// 2. Erases the whole screen including scrollback buffer
+	// 3. Moves cursor to the top-left position
+	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+	:	`${eraseScreen}${ESC}3J${ESC}H`;
+
+/*
+ * see also https://github.com/vadimdemedes/ink
+ */
+
+
+const createDynamicLog = ({
+  stream = process.stdout,
+  clearTerminalAllowed,
+  onVerticalOverflow = () => {},
+  onWriteFromOutside = () => {},
+} = {}) => {
+  const { columns = 80, rows = 24 } = stream;
+  const dynamicLog = {
+    destroyed: false,
+    onVerticalOverflow,
+    onWriteFromOutside,
+  };
+
+  let lastOutput = "";
+  let lastOutputFromOutside = "";
+  let clearAttemptResult;
+  let writing = false;
+
+  const getErasePreviousOutput = () => {
+    // nothing to clear
+    if (!lastOutput) {
+      return "";
+    }
+    if (clearAttemptResult !== undefined) {
+      return "";
+    }
+
+    const logLines = lastOutput.split(/\r\n|\r|\n/);
+    let visualLineCount = 0;
+    for (const logLine of logLines) {
+      const width = stringWidth(logLine);
+      if (width === 0) {
+        visualLineCount++;
+      } else {
+        visualLineCount += Math.ceil(width / columns);
+      }
+    }
+
+    if (visualLineCount > rows) {
+      if (clearTerminalAllowed) {
+        clearAttemptResult = true;
+        return clearTerminal;
+      }
+      // the whole log cannot be cleared because it's vertically to long
+      // (longer than terminal height)
+      // readline.moveCursor cannot move cursor higher than screen height
+      // it means we would only clear the visible part of the log
+      // better keep the log untouched
+      clearAttemptResult = false;
+      dynamicLog.onVerticalOverflow();
+      return "";
+    }
+
+    clearAttemptResult = true;
+    return eraseLines(visualLineCount);
+  };
+
+  const update = (string) => {
+    if (dynamicLog.destroyed) {
+      throw new Error("Cannot write log after destroy");
+    }
+    let stringToWrite = string;
+    if (lastOutput) {
+      if (lastOutputFromOutside) {
+        // We don't want to clear logs written by other code,
+        // it makes output unreadable and might erase precious information
+        // To detect this we put a spy on the stream.
+        // The spy is required only if we actually wrote something in the stream
+        // something else than this code has written in the stream
+        // so we just write without clearing (append instead of replacing)
+        lastOutput = "";
+        lastOutputFromOutside = "";
+      } else {
+        stringToWrite = `${getErasePreviousOutput()}${string}`;
+      }
+    }
+    writing = true;
+    stream.write(stringToWrite);
+    lastOutput = string;
+    writing = false;
+    clearAttemptResult = undefined;
+  };
+
+  const clearDuringFunctionCall = (
+    callback,
+    ouputAfterCallback = lastOutput,
+  ) => {
+    // 1. Erase the current log
+    // 2. Call callback (expect to write something on stdout)
+    // 3. Restore the current log
+    // During step 2. we expect a "write from outside" so we uninstall
+    // the stream spy during function call
+    update("");
+
+    writing = true;
+    callback();
+    writing = false;
+
+    update(ouputAfterCallback);
+  };
+
+  const writeFromOutsideEffect = (value) => {
+    if (!lastOutput) {
+      // we don't care if the log never wrote anything
+      // or if last update() wrote an empty string
+      return;
+    }
+    if (writing) {
+      return;
+    }
+    lastOutputFromOutside = value;
+    dynamicLog.onWriteFromOutside(value);
+  };
+
+  let removeStreamSpy;
+  if (stream === process.stdout) {
+    const removeStdoutSpy = spyStreamOutput(
+      process.stdout,
+      writeFromOutsideEffect,
+    );
+    const removeStderrSpy = spyStreamOutput(
+      process.stderr,
+      writeFromOutsideEffect,
+    );
+    removeStreamSpy = () => {
+      removeStdoutSpy();
+      removeStderrSpy();
+    };
+  } else {
+    removeStreamSpy = spyStreamOutput(stream, writeFromOutsideEffect);
+  }
+
+  const destroy = () => {
+    dynamicLog.destroyed = true;
+    if (removeStreamSpy) {
+      removeStreamSpy();
+      removeStreamSpy = null;
+      lastOutput = "";
+      lastOutputFromOutside = "";
+    }
+  };
+
+  Object.assign(dynamicLog, {
+    update,
+    destroy,
+    stream,
+    clearDuringFunctionCall,
+  });
+  return dynamicLog;
+};
+
+// maybe https://github.com/gajus/output-interceptor/tree/v3.0.0 ?
+// the problem with listening data on stdout
+// is that node.js will later throw error if stream gets closed
+// while something listening data on it
+const spyStreamOutput = (stream, callback) => {
+  const originalWrite = stream.write;
+
+  let output = "";
+  let installed = true;
+
+  stream.write = function (...args /* chunk, encoding, callback */) {
+    output += args;
+    callback(output);
+    return originalWrite.call(stream, ...args);
+  };
+
+  const uninstall = () => {
+    if (!installed) {
+      return;
+    }
+    stream.write = originalWrite;
+    installed = false;
+  };
+
+  return () => {
+    uninstall();
+    return output;
+  };
+};
+
 const urlToScheme = (url) => {
   const urlString = String(url);
   const colonIndex = urlString.indexOf(":");
@@ -7800,7 +7809,11 @@ const nodeChildProcess = ({
   env = {
     ...env,
     JSENV: true,
-    FORCE_COLOR: supportsColor.stdout,
+    FORCE_COLOR:
+      supportsColor.stdout ||
+      // GitHub workflow does support ANSI but "supports-color" returns false
+      // because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+      process.env.GITHUB_WORKFLOW,
   };
 
   return {
@@ -8275,7 +8288,11 @@ const nodeWorkerThread = ({
   env = {
     ...env,
     JSENV: true,
-    FORCE_COLOR: supportsColor.stdout,
+    FORCE_COLOR:
+      supportsColor.stdout ||
+      // GitHub workflow does support ANSI but "supports-color" returns false
+      // because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+      process.env.GITHUB_WORKFLOW,
   };
 
   return {