@jsenv/humanize 1.1.0 → 1.1.1

package/dist/node/jsenv_humanize_node.js

@@ -1,752 +1,1099 @@
-import stringWidth from "string-width";
 import process$1 from "node:process";
 import os from "node:os";
 import tty from "node:tty";
+import stringWidth from "string-width";
 
-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 = !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
-	? `${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 "";
-    }
+({
+	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 &&
+      // 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"),
+});
 
-    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 uninstall = () => {
-    if (!installed) {
-      return;
-    }
-    stream.write = originalWrite;
-    installed = false;
-  };
+const UNICODE = createUnicode({
+  supported: isUnicodeSupported(),
+  ANSI,
+});
 
-  return () => {
-    uninstall();
-    return output;
-  };
-};
+const inspectBoolean = (value) => value.toString();
 
-// 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 inspectNull = () => "null";
 
-const {env} = process$1;
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/rules/numeric-separators-style.js
 
-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;
-		}
+const inspectNumber = (value, { numericSeparator }) => {
+  if (isNegativeZero(value)) {
+    return "-0";
+  }
+  // isNaN
+  // eslint-disable-next-line no-self-compare
+  if (value !== value) {
+    return "NaN";
+  }
+  if (value === Infinity) {
+    return "Infinity";
+  }
+  if (value === -Infinity) {
+    return "-Infinity";
+  }
+  const numberString = String(value);
+  if (!numericSeparator) {
+    return numberString;
+  }
+  const {
+    number,
+    mark = "",
+    sign = "",
+    power = "",
+  } = numberString.match(
+    /^(?<number>.*?)(?:(?<mark>e)(?<sign>[+-])?(?<power>\d+))?$/i,
+  ).groups;
+  const numberWithSeparators = formatNumber(number);
+  const powerWithSeparators = addSeparator(power, {
+    minimumDigits: 5,
+    groupLength: 3,
+  });
+  return `${numberWithSeparators}${mark}${sign}${powerWithSeparators}`;
+};
 
-		if (env.FORCE_COLOR === 'false') {
-			return 0;
-		}
+// Use this and instead of Object.is(value, -0)
+// because in some corner cases firefox returns false
+// for Object.is(-0, -0)
+const isNegativeZero = (value) => {
+  return value === 0 && 1 / value === -Infinity;
+};
 
-		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-	}
-}
+const formatNumber = (numberString) => {
+  const parts = numberString.split(".");
+  const [integer, fractional] = parts;
 
-function translateLevel(level) {
-	if (level === 0) {
-		return false;
-	}
+  if (parts.length === 2) {
+    const integerWithSeparators = addSeparator(integer, {
+      minimumDigits: 5,
+      groupLength: 3,
+    });
+    return `${integerWithSeparators}.${fractional}`;
+  }
 
-	return {
-		level,
-		hasBasic: true,
-		has256: level >= 2,
-		has16m: level >= 3,
-	};
-}
+  return addSeparator(integer, {
+    minimumDigits: 5,
+    groupLength: 3,
+  });
+};
 
-function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
-	const noFlagForceColor = envForceColor();
-	if (noFlagForceColor !== undefined) {
-		flagForceColor = noFlagForceColor;
-	}
+const addSeparator = (numberString, { minimumDigits, groupLength }) => {
+  if (numberString[0] === "-") {
+    return `-${groupDigits(numberString.slice(1), {
+      minimumDigits,
+      groupLength,
+    })}`;
+  }
+  return groupDigits(numberString, { minimumDigits, groupLength });
+};
 
-	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+const groupDigits = (digits, { minimumDigits, groupLength }) => {
+  const digitCount = digits.length;
+  if (digitCount < minimumDigits) {
+    return digits;
+  }
 
-	if (forceColor === 0) {
-		return 0;
-	}
+  let digitsWithSeparator = digits.slice(-groupLength);
+  let remainingDigits = digits.slice(0, -groupLength);
+  while (remainingDigits.length) {
+    const group = remainingDigits.slice(-groupLength);
+    remainingDigits = remainingDigits.slice(0, -groupLength);
+    digitsWithSeparator = `${group}_${digitsWithSeparator}`;
+  }
+  return digitsWithSeparator;
+};
 
-	if (sniffFlags) {
-		if (hasFlag('color=16m')
-			|| hasFlag('color=full')
-			|| hasFlag('color=truecolor')) {
-			return 3;
-		}
+// const addSeparatorFromLeft = (value, { minimumDigits, groupLength }) => {
+//   const { length } = value;
+//   if (length < minimumDigits) {
+//     return value;
+//   }
 
-		if (hasFlag('color=256')) {
-			return 2;
-		}
-	}
+//   const parts = [];
+//   for (let start = 0; start < length; start += groupLength) {
+//     const end = Math.min(start + groupLength, length);
+//     parts.push(value.slice(start, end));
+//   }
+//   return parts.join("_");
+// };
 
-	// Check for Azure DevOps pipelines.
-	// Has to be above the `!streamIsTTY` check.
-	if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
-		return 1;
-	}
+const DOUBLE_QUOTE = `"`;
+const SINGLE_QUOTE = `'`;
+const BACKTICK = "`";
 
-	if (haveStream && !streamIsTTY && forceColor === undefined) {
-		return 0;
-	}
+const inspectString = (
+  value,
+  {
+    quote = "auto",
+    canUseTemplateString = false,
+    preserveLineBreaks = false,
+    quoteDefault = DOUBLE_QUOTE,
+  } = {},
+) => {
+  quote =
+    quote === "auto"
+      ? determineQuote(value, { canUseTemplateString, quoteDefault })
+      : quote;
+  if (quote === BACKTICK) {
+    return `\`${escapeTemplateStringSpecialCharacters(value)}\``;
+  }
+  return surroundStringWith(value, { quote, preserveLineBreaks });
+};
 
-	const min = forceColor || 0;
+// https://github.com/mgenware/string-to-template-literal/blob/main/src/main.ts#L1
+const escapeTemplateStringSpecialCharacters = (string) => {
+  string = String(string);
+  let i = 0;
+  let escapedString = "";
+  while (i < string.length) {
+    const char = string[i];
+    i++;
+    escapedString += isTemplateStringSpecialChar(char) ? `\\${char}` : char;
+  }
+  return escapedString;
+};
 
-	if (env.TERM === 'dumb') {
-		return min;
-	}
+const isTemplateStringSpecialChar = (char) =>
+  templateStringSpecialChars.indexOf(char) > -1;
+const templateStringSpecialChars = ["\\", "`", "$"];
 
-	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;
-		}
+const determineQuote = (
+  string,
+  { canUseTemplateString, quoteDefault = DOUBLE_QUOTE } = {},
+) => {
+  const containsDoubleQuote = string.includes(DOUBLE_QUOTE);
+  if (!containsDoubleQuote) {
+    return DOUBLE_QUOTE;
+  }
+  const containsSimpleQuote = string.includes(SINGLE_QUOTE);
+  if (!containsSimpleQuote) {
+    return SINGLE_QUOTE;
+  }
+  if (canUseTemplateString) {
+    const containsBackTick = string.includes(BACKTICK);
+    if (!containsBackTick) {
+      return BACKTICK;
+    }
+  }
+  const doubleQuoteCount = string.split(DOUBLE_QUOTE).length - 1;
+  const singleQuoteCount = string.split(SINGLE_QUOTE).length - 1;
+  if (singleQuoteCount > doubleQuoteCount) {
+    return DOUBLE_QUOTE;
+  }
+  if (doubleQuoteCount > singleQuoteCount) {
+    return SINGLE_QUOTE;
+  }
+  return quoteDefault;
+};
 
-		return 1;
-	}
+const inspectChar = (char, { quote, preserveLineBreaks }) => {
+  const point = char.charCodeAt(0);
+  if (preserveLineBreaks && (char === "\n" || char === "\r")) {
+    return char;
+  }
+  if (
+    char === quote ||
+    point === 92 ||
+    point < 32 ||
+    (point > 126 && point < 160) ||
+    // line separators
+    point === 8232 ||
+    point === 8233
+  ) {
+    const replacement =
+      char === quote
+        ? `\\${quote}`
+        : point === 8232
+          ? "\\u2028"
+          : point === 8233
+            ? "\\u2029"
+            : meta[point];
+    return replacement;
+  }
+  return char;
+};
 
-	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;
-		}
+// https://github.com/jsenv/jsenv-uneval/blob/6c97ef9d8f2e9425a66f2c88347e0a118d427f3a/src/internal/escapeString.js#L3
+// https://github.com/jsenv/jsenv-inspect/blob/bb11de3adf262b68f71ed82b0a37d4528dd42229/src/internal/string.js#L3
+// https://github.com/joliss/js-string-escape/blob/master/index.js
+// http://javascript.crockford.com/remedial.html
+const surroundStringWith = (string, { quote, preserveLineBreaks }) => {
+  let result = "";
+  let last = 0;
+  const lastIndex = string.length;
+  let i = 0;
+  while (i < lastIndex) {
+    const char = string[i];
+    const replacement = inspectChar(char, { quote, preserveLineBreaks });
+    if (char !== replacement) {
+      if (last === i) {
+        result += replacement;
+      } else {
+        result += `${string.slice(last, i)}${replacement}`;
+      }
+      last = i + 1;
+    }
+    i++;
+  }
+  if (last !== lastIndex) {
+    result += string.slice(last);
+  }
+  return `${quote}${result}${quote}`;
+};
 
-		return min;
-	}
+// prettier-ignore
+const meta = [
+  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
+  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F
+  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
+  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
+  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F
+  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F
+  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
+  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
+  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
+  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
+];
 
-	if ('TEAMCITY_VERSION' in env) {
-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-	}
+const inspectSymbol = (value, { nestedHumanize, parenthesis }) => {
+  const symbolDescription = symbolToDescription(value);
+  const symbolDescriptionSource = symbolDescription
+    ? nestedHumanize(symbolDescription)
+    : "";
+  const symbolSource = `Symbol(${symbolDescriptionSource})`;
 
-	if (env.COLORTERM === 'truecolor') {
-		return 3;
-	}
+  if (parenthesis) return `${symbolSource}`;
+  return symbolSource;
+};
 
-	if (env.TERM === 'xterm-kitty') {
-		return 3;
-	}
+const symbolToDescription =
+  "description" in Symbol.prototype
+    ? (symbol) => symbol.description
+    : (symbol) => {
+        const toStringResult = symbol.toString();
+        const openingParenthesisIndex = toStringResult.indexOf("(");
+        const closingParenthesisIndex = toStringResult.indexOf(")");
+        const symbolDescription = toStringResult.slice(
+          openingParenthesisIndex + 1,
+          closingParenthesisIndex,
+        );
+        return symbolDescription;
+      };
 
-	if ('TERM_PROGRAM' in env) {
-		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+const inspectUndefined = () => "undefined";
 
-		switch (env.TERM_PROGRAM) {
-			case 'iTerm.app': {
-				return version >= 3 ? 3 : 2;
-			}
+const inspectBigInt = (value) => {
+  return `${value}n`;
+};
 
-			case 'Apple_Terminal': {
-				return 2;
-			}
-			// No default
-		}
-	}
+const preNewLineAndIndentation = (
+  value,
+  { depth, indentUsingTab, indentSize },
+) => {
+  return `${newLineAndIndent({
+    count: depth + 1,
+    useTabs: indentUsingTab,
+    size: indentSize,
+  })}${value}`;
+};
 
-	if (/-256(color)?$/i.test(env.TERM)) {
-		return 2;
-	}
+const postNewLineAndIndentation = ({ depth, indentUsingTab, indentSize }) => {
+  return newLineAndIndent({
+    count: depth,
+    useTabs: indentUsingTab,
+    size: indentSize,
+  });
+};
 
-	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-		return 1;
-	}
+const newLineAndIndent = ({ count, useTabs, size }) => {
+  if (useTabs) {
+    // eslint-disable-next-line prefer-template
+    return "\n" + "\t".repeat(count);
+  }
+  // eslint-disable-next-line prefer-template
+  return "\n" + " ".repeat(count * size);
+};
 
-	if ('COLORTERM' in env) {
-		return 1;
-	}
+const wrapNewLineAndIndentation = (
+  value,
+  { depth, indentUsingTab, indentSize },
+) => {
+  return `${preNewLineAndIndentation(value, {
+    depth,
+    indentUsingTab,
+    indentSize,
+  })}${postNewLineAndIndentation({ depth, indentUsingTab, indentSize })}`;
+};
 
-	return min;
-}
+const inspectConstructor = (value, { parenthesis, useNew }) => {
+  let formattedString = value;
+  if (parenthesis) {
+    formattedString = `(${value})`;
+  }
+  if (useNew) {
+    formattedString = `new ${formattedString}`;
+  }
+  return formattedString;
+};
 
-function createSupportsColor(stream, options = {}) {
-	const level = _supportsColor(stream, {
-		streamIsTTY: stream && stream.isTTY,
-		...options,
-	});
+const inspectArray = (
+  value,
+  {
+    seen = [],
+    nestedHumanize,
+    depth,
+    indentUsingTab,
+    indentSize,
+    parenthesis,
+    useNew,
+  },
+) => {
+  if (seen.indexOf(value) > -1) {
+    return "Symbol.for('circular')";
+  }
+  seen.push(value);
 
-	return translateLevel(level);
-}
+  let valuesSource = "";
+  let i = 0;
+  const j = value.length;
 
-({
-	stdout: createSupportsColor({isTTY: tty.isatty(1)}),
-	stderr: createSupportsColor({isTTY: tty.isatty(2)}),
-});
+  while (i < j) {
+    const valueSource = value.hasOwnProperty(i)
+      ? nestedHumanize(value[i], { seen })
+      : "";
+    if (i === 0) {
+      valuesSource += valueSource;
+    } else {
+      valuesSource += `,${preNewLineAndIndentation(valueSource, {
+        depth,
+        indentUsingTab,
+        indentSize,
+      })}`;
+    }
+    i++;
+  }
 
-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";
+  let arraySource;
+  if (valuesSource.length) {
+    arraySource = wrapNewLineAndIndentation(valuesSource, {
+      depth,
+      indentUsingTab,
+      indentSize,
+    });
+  } else {
+    arraySource = "";
+  }
 
-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;
-  },
+  arraySource = `[${arraySource}]`;
 
-  BOLD: "\x1b[1m",
-  UNDERLINE: "\x1b[4m",
-  STRIKE: "\x1b[9m",
-  effect: (text, ANSI_EFFECT) => {
-    return ANSI.supported && ANSI_EFFECT
-      ? `${ANSI_EFFECT}${text}${RESET}`
-      : text;
-  },
+  return inspectConstructor(arraySource, { parenthesis, useNew });
 };
 
-// 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 inspectBigIntObject = (value, { nestedHumanize }) => {
+  const bigIntSource = nestedHumanize(value.valueOf());
 
-const startSpinner = ({
-  dynamicLog,
-  frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-  fps = 20,
-  keepProcessAlive = false,
-  stopOnWriteFromOutside = true,
-  stopOnVerticalOverflow = true,
-  render = () => "",
-  effect = () => {},
-  animated = dynamicLog.stream.isTTY,
-}) => {
-  let frameIndex = 0;
-  let interval;
-  let running = true;
+  return `BigInt(${bigIntSource})`;
+};
 
-  const spinner = {
-    message: undefined,
-  };
+const inspectBooleanObject = (
+  value,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const booleanSource = nestedHumanize(value.valueOf());
+  return inspectConstructor(`Boolean(${booleanSource})`, {
+    useNew,
+    parenthesis,
+  });
+};
 
-  const update = (message) => {
-    spinner.message = running
-      ? `${frames[frameIndex]} ${message}\n`
-      : `${message}\n`;
-    return spinner.message;
-  };
-  spinner.update = update;
+const inspectError = (
+  error,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const messageSource = nestedHumanize(error.message);
 
-  let cleanup;
-  if (animated && ANSI.supported) {
-    running = true;
-    cleanup = effect();
-    dynamicLog.update(update(render()));
+  const errorSource = inspectConstructor(
+    `${errorToConstructorName(error)}(${messageSource})`,
+    {
+      useNew,
+      parenthesis,
+    },
+  );
+  return errorSource;
+};
 
-    interval = setInterval(() => {
-      frameIndex = frameIndex === frames.length - 1 ? 0 : frameIndex + 1;
-      dynamicLog.update(update(render()));
-    }, 1000 / fps);
-    if (!keepProcessAlive) {
-      interval.unref();
-    }
-  } else {
-    dynamicLog.update(update(render()));
+const errorToConstructorName = ({ name }) => {
+  if (derivedErrorNameArray.includes(name)) {
+    return name;
   }
+  return "Error";
+};
 
-  const stop = (message) => {
-    running = false;
-    if (interval) {
-      clearInterval(interval);
-      interval = null;
-    }
-    if (cleanup) {
-      cleanup();
-      cleanup = null;
-    }
-    if (dynamicLog && message) {
-      dynamicLog.update(update(message));
-      dynamicLog = null;
-    }
-  };
-  spinner.stop = stop;
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
+const derivedErrorNameArray = [
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+];
 
-  if (stopOnVerticalOverflow) {
-    dynamicLog.onVerticalOverflow = stop;
-  }
-  if (stopOnWriteFromOutside) {
-    dynamicLog.onWriteFromOutside = stop;
+const inspectDate = (value, { nestedHumanize, useNew, parenthesis }) => {
+  const dateSource = nestedHumanize(value.valueOf(), {
+    numericSeparator: false,
+  });
+  return inspectConstructor(`Date(${dateSource})`, { useNew, parenthesis });
+};
+
+const inspectFunction = (
+  value,
+  { showFunctionBody, parenthesis, depth },
+) => {
+  let functionSource;
+  if (showFunctionBody) {
+    functionSource = value.toString();
+  } else {
+    const isArrowFunction = value.prototype === undefined;
+    const head = isArrowFunction
+      ? "() =>"
+      : `function ${depth === 0 ? value.name : ""}()`;
+    functionSource = `${head} {/* hidden */}`;
   }
 
-  return spinner;
+  if (parenthesis) {
+    return `(${functionSource})`;
+  }
+  return functionSource;
 };
 
-const getPrecision = (number) => {
-  if (Math.floor(number) === number) return 0;
-  const [, decimals] = number.toString().split(".");
-  return decimals.length || 0;
+const inspectNumberObject = (
+  value,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const numberSource = nestedHumanize(value.valueOf());
+  return inspectConstructor(`Number(${numberSource})`, { useNew, parenthesis });
 };
 
-const setRoundedPrecision = (
-  number,
-  { decimals = 1, decimalsWhenSmall = decimals } = {},
+const inspectObject = (
+  value,
+  {
+    nestedHumanize,
+    seen = [],
+    depth,
+    indentUsingTab,
+    indentSize,
+    objectConstructor,
+    parenthesis,
+    useNew,
+  },
 ) => {
-  return setDecimalsPrecision(number, {
-    decimals,
-    decimalsWhenSmall,
-    transform: Math.round,
+  if (seen.indexOf(value) > -1) return "Symbol.for('circular')";
+
+  seen.push(value);
+
+  const propertySourceArray = [];
+  Object.getOwnPropertyNames(value).forEach((propertyName) => {
+    const propertyNameAsNumber = parseInt(propertyName, 10);
+    const propertyNameSource = nestedHumanize(
+      Number.isInteger(propertyNameAsNumber)
+        ? propertyNameAsNumber
+        : propertyName,
+    );
+    propertySourceArray.push({
+      nameOrSymbolSource: propertyNameSource,
+      valueSource: nestedHumanize(value[propertyName], { seen }),
+    });
+  });
+  Object.getOwnPropertySymbols(value).forEach((symbol) => {
+    propertySourceArray.push({
+      nameOrSymbolSource: `[${nestedHumanize(symbol)}]`,
+      valueSource: nestedHumanize(value[symbol], { seen }),
+    });
   });
-};
 
-const setPrecision = (
-  number,
-  { decimals = 1, decimalsWhenSmall = decimals } = {},
-) => {
-  return setDecimalsPrecision(number, {
-    decimals,
-    decimalsWhenSmall,
-    transform: parseInt,
+  let propertiesSource = "";
+  propertySourceArray.forEach(({ nameOrSymbolSource, valueSource }, index) => {
+    if (index === 0) {
+      propertiesSource += `${nameOrSymbolSource}: ${valueSource}`;
+    } else {
+      propertiesSource += `,${preNewLineAndIndentation(
+        `${nameOrSymbolSource}: ${valueSource}`,
+        {
+          depth,
+          indentUsingTab,
+          indentSize,
+        },
+      )}`;
+    }
   });
-};
 
-const setDecimalsPrecision = (
-  number,
-  {
-    transform,
-    decimals, // max decimals for number in [-Infinity, -1[]1, Infinity]
-    decimalsWhenSmall, // max decimals for number in [-1,1]
-  } = {},
-) => {
-  if (number === 0) {
-    return 0;
+  let objectSource;
+  if (propertiesSource.length) {
+    objectSource = `${wrapNewLineAndIndentation(propertiesSource, {
+      depth,
+      indentUsingTab,
+      indentSize,
+    })}`;
+  } else {
+    objectSource = "";
   }
-  let numberCandidate = Math.abs(number);
-  if (numberCandidate < 1) {
-    const integerGoal = Math.pow(10, decimalsWhenSmall - 1);
-    let i = 1;
-    while (numberCandidate < integerGoal) {
-      numberCandidate *= 10;
-      i *= 10;
-    }
-    const asInteger = transform(numberCandidate);
-    const asFloat = asInteger / i;
-    return number < 0 ? -asFloat : asFloat;
+
+  if (objectConstructor) {
+    objectSource = `Object({${objectSource}})`;
+  } else {
+    objectSource = `{${objectSource}}`;
   }
-  const coef = Math.pow(10, decimals);
-  const numberMultiplied = (number + Number.EPSILON) * coef;
-  const asInteger = transform(numberMultiplied);
-  const asFloat = asInteger / coef;
-  return number < 0 ? -asFloat : asFloat;
+
+  return inspectConstructor(objectSource, { parenthesis, useNew });
 };
 
-// https://www.codingem.com/javascript-how-to-limit-decimal-places/
-// export const roundNumber = (number, maxDecimals) => {
-//   const decimalsExp = Math.pow(10, maxDecimals)
-//   const numberRoundInt = Math.round(decimalsExp * (number + Number.EPSILON))
-//   const numberRoundFloat = numberRoundInt / decimalsExp
-//   return numberRoundFloat
-// }
+const inspectRegExp = (value) => value.toString();
 
-// export const setPrecision = (number, precision) => {
-//   if (Math.floor(number) === number) return number
-//   const [int, decimals] = number.toString().split(".")
-//   if (precision <= 0) return int
-//   const numberTruncated = `${int}.${decimals.slice(0, precision)}`
-//   return numberTruncated
-// }
+const inspectStringObject = (
+  value,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const stringSource = nestedHumanize(value.valueOf());
 
-const humanizeEllapsedTime = (ms, { short } = {}) => {
-  if (ms < 1000) {
-    return short ? "0s" : "0 second";
-  }
-  const { primary, remaining } = parseMs(ms);
-  if (!remaining) {
-    return inspectEllapsedUnit(primary, short);
-  }
-  return `${inspectEllapsedUnit(primary, short)} and ${inspectEllapsedUnit(
-    remaining,
-    short,
-  )}`;
+  return inspectConstructor(`String(${stringSource})`, { useNew, parenthesis });
 };
-const inspectEllapsedUnit = (unit, short) => {
-  const count =
-    unit.name === "second" ? Math.floor(unit.count) : Math.round(unit.count);
-  let name = unit.name;
-  if (short) {
-    name = unitShort[name];
-    if (count <= 1) {
-      return `${count}${name}`;
-    }
-    return `${count}${name}s`;
-  }
-  if (count <= 1) {
-    return `${count} ${name}`;
+
+// primitives
+
+const humanize = (
+  value,
+  {
+    parenthesis = false,
+    quote = "auto",
+    canUseTemplateString = true,
+    useNew = false,
+    objectConstructor = false,
+    showFunctionBody = false,
+    indentUsingTab = false,
+    indentSize = 2,
+    numericSeparator = true,
+    preserveLineBreaks = false,
+  } = {},
+) => {
+  const scopedHumanize = (scopedValue, scopedOptions) => {
+    const options = {
+      ...scopedOptions,
+      nestedHumanize: (nestedValue, nestedOptions = {}) => {
+        return scopedHumanize(nestedValue, {
+          ...scopedOptions,
+          depth: scopedOptions.depth + 1,
+          ...nestedOptions,
+        });
+      },
+    };
+    return humanizeValue(scopedValue, options);
+  };
+
+  return scopedHumanize(value, {
+    parenthesis,
+    quote,
+    canUseTemplateString,
+    useNew,
+    objectConstructor,
+    showFunctionBody,
+    indentUsingTab,
+    indentSize,
+    numericSeparator,
+    preserveLineBreaks,
+    depth: 0,
+  });
+};
+
+const humanizeMethodSymbol = Symbol.for("inspect");
+
+const humanizeValue = (value, options) => {
+  const customHumanize = value && value[humanizeMethodSymbol];
+  if (customHumanize) {
+    return customHumanize(options);
+  }
+  const primitiveType = primitiveTypeFromValue(value);
+  const primitiveStringifier = primitiveStringifiers[primitiveType];
+  if (primitiveStringifier) {
+    return primitiveStringifier(value, options);
+  }
+  const compositeType = compositeTypeFromObject(value);
+  const compositeStringifier = compositeStringifiers[compositeType];
+  if (compositeStringifier) {
+    return compositeStringifier(value, options);
+  }
+  return inspectConstructor(
+    `${compositeType}(${inspectObject(value, options)})`,
+    {
+      ...options,
+      parenthesis: false,
+    },
+  );
+};
+
+const primitiveTypeFromValue = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (value === undefined) {
+    return "undefined";
+  }
+  return typeof value;
+};
+const primitiveStringifiers = {
+  boolean: inspectBoolean,
+  function: inspectFunction,
+  null: inspectNull,
+  number: inspectNumber,
+  string: inspectString,
+  symbol: inspectSymbol,
+  undefined: inspectUndefined,
+  bigint: inspectBigInt,
+};
+const compositeTypeFromObject = (object) => {
+  if (typeof object === "object" && Object.getPrototypeOf(object) === null) {
+    return "Object";
+  }
+  const toStringResult = toString.call(object);
+  // returns format is '[object ${tagName}]';
+  // and we want ${tagName}
+  const tagName = toStringResult.slice("[object ".length, -1);
+  if (tagName === "Object") {
+    const objectConstructorName = object.constructor.name;
+    if (objectConstructorName !== "Object") {
+      return objectConstructorName;
+    }
+  }
+  return tagName;
+};
+const { toString } = Object.prototype;
+
+const compositeStringifiers = {
+  Array: inspectArray,
+  BigInt: inspectBigIntObject,
+  Boolean: inspectBooleanObject,
+  Error: inspectError,
+  Date: inspectDate,
+  Function: inspectFunction,
+  Number: inspectNumberObject,
+  Object: inspectObject,
+  RegExp: inspectRegExp,
+  String: inspectStringObject,
+};
+
+const getPrecision = (number) => {
+  if (Math.floor(number) === number) return 0;
+  const [, decimals] = number.toString().split(".");
+  return decimals.length || 0;
+};
+
+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 setDecimalsPrecision = (
+  number,
+  {
+    transform,
+    decimals, // max decimals for number in [-Infinity, -1[]1, Infinity]
+    decimalsWhenSmall, // max decimals for number in [-1,1]
+  } = {},
+) => {
+  if (number === 0) {
+    return 0;
+  }
+  let numberCandidate = Math.abs(number);
+  if (numberCandidate < 1) {
+    const integerGoal = Math.pow(10, decimalsWhenSmall - 1);
+    let i = 1;
+    while (numberCandidate < integerGoal) {
+      numberCandidate *= 10;
+      i *= 10;
+    }
+    const asInteger = transform(numberCandidate);
+    const asFloat = asInteger / i;
+    return number < 0 ? -asFloat : asFloat;
+  }
+  const coef = Math.pow(10, decimals);
+  const numberMultiplied = (number + Number.EPSILON) * coef;
+  const asInteger = transform(numberMultiplied);
+  const asFloat = asInteger / coef;
+  return number < 0 ? -asFloat : asFloat;
+};
+
+// https://www.codingem.com/javascript-how-to-limit-decimal-places/
+// export const roundNumber = (number, maxDecimals) => {
+//   const decimalsExp = Math.pow(10, maxDecimals)
+//   const numberRoundInt = Math.round(decimalsExp * (number + Number.EPSILON))
+//   const numberRoundFloat = numberRoundInt / decimalsExp
+//   return numberRoundFloat
+// }
+
+// export const setPrecision = (number, precision) => {
+//   if (Math.floor(number) === number) return number
+//   const [int, decimals] = number.toString().split(".")
+//   if (precision <= 0) return int
+//   const numberTruncated = `${int}.${decimals.slice(0, precision)}`
+//   return numberTruncated
+// }
+
+const humanizeEllapsedTime = (ms, { short } = {}) => {
+  if (ms < 1000) {
+    return short ? "0s" : "0 second";
+  }
+  const { primary, remaining } = parseMs(ms);
+  if (!remaining) {
+    return inspectEllapsedUnit(primary, short);
+  }
+  return `${inspectEllapsedUnit(primary, short)} and ${inspectEllapsedUnit(
+    remaining,
+    short,
+  )}`;
+};
+const inspectEllapsedUnit = (unit, short) => {
+  const count =
+    unit.name === "second" ? Math.floor(unit.count) : Math.round(unit.count);
+  let name = unit.name;
+  if (short) {
+    name = unitShort[name];
+    if (count <= 1) {
+      return `${count}${name}`;
+    }
+    return `${count}${name}s`;
+  }
+  if (count <= 1) {
+    return `${count} ${name}`;
   }
   return `${count} ${name}s`;
 };
@@ -871,1059 +1218,725 @@ 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 humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
+  return inspectBytes(numberOfBytes, { decimals, short });
+};
 
-const UNICODE = {
-  supported: isUnicodeSupported(),
+const humanizeMemory = (metricValue, { decimals, short } = {}) => {
+  return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
+};
 
-  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 createTaskLog = (
-  label,
-  { disabled = false, animated = true, stopOnWriteFromOutside } = {},
+const inspectBytes = (
+  number,
+  { fixedDecimals = false, decimals, short } = {},
 ) => {
-  if (disabled) {
-    return {
-      setRightText: () => {},
-      done: () => {},
-      happen: () => {},
-      fail: () => {},
-    };
+  if (number === 0) {
+    return `0 B`;
   }
-  const startMs = Date.now();
-  const dynamicLog = createDynamicLog();
-  let message = label;
-  const taskSpinner = startSpinner({
-    dynamicLog,
-    render: () => message,
-    stopOnWriteFromOutside,
-    animated,
+  const exponent = Math.min(
+    Math.floor(Math.log10(number) / 3),
+    BYTE_UNITS.length - 1,
+  );
+  const unitNumber = number / Math.pow(1000, exponent);
+  const unitName = BYTE_UNITS[exponent];
+  if (decimals === undefined) {
+    if (unitNumber < 100) {
+      decimals = 1;
+    } else {
+      decimals = 0;
+    }
+  }
+  const unitNumberRounded = setRoundedPrecision(unitNumber, {
+    decimals,
+    decimalsWhenSmall: 1,
   });
-  return {
-    setRightText: (value) => {
-      message = `${label} ${value}`;
-    },
-    done: () => {
-      const msEllapsed = Date.now() - startMs;
-      taskSpinner.stop(
-        `${UNICODE.OK} ${label} (done in ${humanizeDuration(msEllapsed)})`,
-      );
-    },
-    happen: (message) => {
-      taskSpinner.stop(
-        `${UNICODE.INFO} ${message} (at ${new Date().toLocaleTimeString()})`,
-      );
-    },
-    fail: (message = `failed to ${label}`) => {
-      taskSpinner.stop(`${UNICODE.FAILURE} ${message}`);
-    },
-  };
+  const value = fixedDecimals
+    ? unitNumberRounded.toFixed(decimals)
+    : unitNumberRounded;
+  if (short) {
+    return `${value}${unitName}`;
+  }
+  return `${value} ${unitName}`;
 };
 
-const createDetailedMessage = (message, details = {}) => {
-  let string = `${message}`;
+const BYTE_UNITS = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
 
-  Object.keys(details).forEach((key) => {
-    const value = details[key];
-    string += `
---- ${key} ---
-${
-  Array.isArray(value)
-    ? value.join(`
-`)
-    : value
-}`;
+const distributePercentages = (
+  namedNumbers,
+  { maxPrecisionHint = 2 } = {},
+) => {
+  const numberNames = Object.keys(namedNumbers);
+  if (numberNames.length === 0) {
+    return {};
+  }
+  if (numberNames.length === 1) {
+    const firstNumberName = numberNames[0];
+    return { [firstNumberName]: "100 %" };
+  }
+  const numbers = numberNames.map((name) => namedNumbers[name]);
+  const total = numbers.reduce((sum, value) => sum + value, 0);
+  const ratios = numbers.map((number) => number / total);
+  const percentages = {};
+  ratios.pop();
+  ratios.forEach((ratio, index) => {
+    const percentage = ratio * 100;
+    percentages[numberNames[index]] = percentage;
+  });
+  const lowestPercentage = (1 / Math.pow(10, maxPrecisionHint)) * 100;
+  let precision = 0;
+  Object.keys(percentages).forEach((name) => {
+    const percentage = percentages[name];
+    if (percentage < lowestPercentage) {
+      // check the amout of meaningful decimals
+      // and that what we will use
+      const percentageRounded = setRoundedPrecision(percentage);
+      const percentagePrecision = getPrecision(percentageRounded);
+      if (percentagePrecision > precision) {
+        precision = percentagePrecision;
+      }
+    }
   });
+  let remainingPercentage = 100;
 
-  return string;
+  Object.keys(percentages).forEach((name) => {
+    const percentage = percentages[name];
+    const percentageAllocated = setRoundedPrecision(percentage, {
+      decimals: precision,
+    });
+    remainingPercentage -= percentageAllocated;
+    percentages[name] = percentageAllocated;
+  });
+  const lastName = numberNames[numberNames.length - 1];
+  percentages[lastName] = setRoundedPrecision(remainingPercentage, {
+    decimals: precision,
+  });
+  return percentages;
 };
 
-const inspectBoolean = (value) => value.toString();
-
-const inspectNull = () => "null";
+const formatDefault = (v) => v;
 
-// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/rules/numeric-separators-style.js
+const generateContentFrame = ({
+  content,
+  line,
+  column,
 
-const inspectNumber = (value, { numericSeparator }) => {
-  if (isNegativeZero(value)) {
-    return "-0";
-  }
-  // isNaN
-  // eslint-disable-next-line no-self-compare
-  if (value !== value) {
-    return "NaN";
+  linesAbove = 3,
+  linesBelow = 0,
+  lineMaxWidth = 120,
+  lineNumbersOnTheLeft = true,
+  lineMarker = true,
+  columnMarker = true,
+  format = formatDefault,
+} = {}) => {
+  const lineStrings = content.split(/\r?\n/);
+  if (line === 0) line = 1;
+  if (column === undefined) {
+    columnMarker = false;
+    column = 1;
   }
-  if (value === Infinity) {
-    return "Infinity";
+  if (column === 0) column = 1;
+
+  let lineStartIndex = line - 1 - linesAbove;
+  if (lineStartIndex < 0) {
+    lineStartIndex = 0;
   }
-  if (value === -Infinity) {
-    return "-Infinity";
+  let lineEndIndex = line - 1 + linesBelow;
+  if (lineEndIndex > lineStrings.length - 1) {
+    lineEndIndex = lineStrings.length - 1;
   }
-  const numberString = String(value);
-  if (!numericSeparator) {
-    return numberString;
+  if (columnMarker) {
+    // human reader deduce the line when there is a column marker
+    lineMarker = false;
   }
-  const {
-    number,
-    mark = "",
-    sign = "",
-    power = "",
-  } = numberString.match(
-    /^(?<number>.*?)(?:(?<mark>e)(?<sign>[+-])?(?<power>\d+))?$/i,
-  ).groups;
-  const numberWithSeparators = formatNumber(number);
-  const powerWithSeparators = addSeparator(power, {
-    minimumDigits: 5,
-    groupLength: 3,
-  });
-  return `${numberWithSeparators}${mark}${sign}${powerWithSeparators}`;
-};
-
-// Use this and instead of Object.is(value, -0)
-// because in some corner cases firefox returns false
-// for Object.is(-0, -0)
-const isNegativeZero = (value) => {
-  return value === 0 && 1 / value === -Infinity;
-};
-
-const formatNumber = (numberString) => {
-  const parts = numberString.split(".");
-  const [integer, fractional] = parts;
-
-  if (parts.length === 2) {
-    const integerWithSeparators = addSeparator(integer, {
-      minimumDigits: 5,
-      groupLength: 3,
-    });
-    return `${integerWithSeparators}.${fractional}`;
+  if (line - 1 === lineEndIndex) {
+    lineMarker = false; // useless because last line
   }
+  let lineIndex = lineStartIndex;
 
-  return addSeparator(integer, {
-    minimumDigits: 5,
-    groupLength: 3,
-  });
-};
-
-const addSeparator = (numberString, { minimumDigits, groupLength }) => {
-  if (numberString[0] === "-") {
-    return `-${groupDigits(numberString.slice(1), {
-      minimumDigits,
-      groupLength,
-    })}`;
+  let columnsBefore;
+  let columnsAfter;
+  if (column > lineMaxWidth) {
+    columnsBefore = column - Math.ceil(lineMaxWidth / 2);
+    columnsAfter = column + Math.floor(lineMaxWidth / 2);
+  } else {
+    columnsBefore = 0;
+    columnsAfter = lineMaxWidth;
   }
-  return groupDigits(numberString, { minimumDigits, groupLength });
-};
+  let columnMarkerIndex = column - 1 - columnsBefore;
 
-const groupDigits = (digits, { minimumDigits, groupLength }) => {
-  const digitCount = digits.length;
-  if (digitCount < minimumDigits) {
-    return digits;
-  }
+  let source = "";
+  while (lineIndex <= lineEndIndex) {
+    const lineString = lineStrings[lineIndex];
+    const lineNumber = lineIndex + 1;
+    const isLastLine = lineIndex === lineEndIndex;
+    const isMainLine = lineNumber === line;
+    lineIndex++;
 
-  let digitsWithSeparator = digits.slice(-groupLength);
-  let remainingDigits = digits.slice(0, -groupLength);
-  while (remainingDigits.length) {
-    const group = remainingDigits.slice(-groupLength);
-    remainingDigits = remainingDigits.slice(0, -groupLength);
-    digitsWithSeparator = `${group}_${digitsWithSeparator}`;
+    {
+      if (lineMarker) {
+        if (isMainLine) {
+          source += `${format(">", "marker_line")} `;
+        } else {
+          source += "  ";
+        }
+      }
+      if (lineNumbersOnTheLeft) {
+        // fill with spaces to ensure if line moves from 7,8,9 to 10 the display is still great
+        const asideSource = `${fillLeft(lineNumber, lineEndIndex + 1)} |`;
+        source += `${format(asideSource, "line_number_aside")} `;
+      }
+    }
+    {
+      source += truncateLine(lineString, {
+        start: columnsBefore,
+        end: columnsAfter,
+        prefix: "…",
+        suffix: "…",
+        format,
+      });
+    }
+    {
+      if (columnMarker && isMainLine) {
+        source += `\n`;
+        if (lineMarker) {
+          source += "  ";
+        }
+        if (lineNumbersOnTheLeft) {
+          const asideSpaces = `${fillLeft(lineNumber, lineEndIndex + 1)} | `
+            .length;
+          source += " ".repeat(asideSpaces);
+        }
+        source += " ".repeat(columnMarkerIndex);
+        source += format("^", "marker_column");
+      }
+    }
+    if (!isLastLine) {
+      source += "\n";
+    }
   }
-  return digitsWithSeparator;
+  return source;
 };
 
-// const addSeparatorFromLeft = (value, { minimumDigits, groupLength }) => {
-//   const { length } = value;
-//   if (length < minimumDigits) {
-//     return value;
-//   }
-
-//   const parts = [];
-//   for (let start = 0; start < length; start += groupLength) {
-//     const end = Math.min(start + groupLength, length);
-//     parts.push(value.slice(start, end));
-//   }
-//   return parts.join("_");
-// };
-
-const DOUBLE_QUOTE = `"`;
-const SINGLE_QUOTE = `'`;
-const BACKTICK = "`";
+const truncateLine = (line, { start, end, prefix, suffix, format }) => {
+  const lastIndex = line.length;
 
-const inspectString = (
-  value,
-  {
-    quote = "auto",
-    canUseTemplateString = false,
-    preserveLineBreaks = false,
-    quoteDefault = DOUBLE_QUOTE,
-  } = {},
-) => {
-  quote =
-    quote === "auto"
-      ? determineQuote(value, { canUseTemplateString, quoteDefault })
-      : quote;
-  if (quote === BACKTICK) {
-    return `\`${escapeTemplateStringSpecialCharacters(value)}\``;
+  if (line.length === 0) {
+    // don't show any ellipsis if the line is empty
+    // because it's not truncated in that case
+    return "";
   }
-  return surroundStringWith(value, { quote, preserveLineBreaks });
-};
 
-// https://github.com/mgenware/string-to-template-literal/blob/main/src/main.ts#L1
-const escapeTemplateStringSpecialCharacters = (string) => {
-  string = String(string);
-  let i = 0;
-  let escapedString = "";
-  while (i < string.length) {
-    const char = string[i];
-    i++;
-    escapedString += isTemplateStringSpecialChar(char) ? `\\${char}` : char;
-  }
-  return escapedString;
-};
+  const startTruncated = start > 0;
+  const endTruncated = lastIndex > end;
 
-const isTemplateStringSpecialChar = (char) =>
-  templateStringSpecialChars.indexOf(char) > -1;
-const templateStringSpecialChars = ["\\", "`", "$"];
+  let from = startTruncated ? start + prefix.length : start;
+  let to = endTruncated ? end - suffix.length : end;
+  if (to > lastIndex) to = lastIndex;
 
-const determineQuote = (
-  string,
-  { canUseTemplateString, quoteDefault = DOUBLE_QUOTE } = {},
-) => {
-  const containsDoubleQuote = string.includes(DOUBLE_QUOTE);
-  if (!containsDoubleQuote) {
-    return DOUBLE_QUOTE;
-  }
-  const containsSimpleQuote = string.includes(SINGLE_QUOTE);
-  if (!containsSimpleQuote) {
-    return SINGLE_QUOTE;
+  if (start >= lastIndex || from === to) {
+    return "";
   }
-  if (canUseTemplateString) {
-    const containsBackTick = string.includes(BACKTICK);
-    if (!containsBackTick) {
-      return BACKTICK;
-    }
+  let result = "";
+  while (from < to) {
+    result += format(line[from], "char");
+    from++;
   }
-  const doubleQuoteCount = string.split(DOUBLE_QUOTE).length - 1;
-  const singleQuoteCount = string.split(SINGLE_QUOTE).length - 1;
-  if (singleQuoteCount > doubleQuoteCount) {
-    return DOUBLE_QUOTE;
+  if (result.length === 0) {
+    return "";
   }
-  if (doubleQuoteCount > singleQuoteCount) {
-    return SINGLE_QUOTE;
+  if (startTruncated && endTruncated) {
+    return `${format(prefix, "marker_overflow_left")}${result}${format(
+      suffix,
+      "marker_overflow_right",
+    )}`;
   }
-  return quoteDefault;
-};
-
-const inspectChar = (char, { quote, preserveLineBreaks }) => {
-  const point = char.charCodeAt(0);
-  if (preserveLineBreaks && (char === "\n" || char === "\r")) {
-    return char;
+  if (startTruncated) {
+    return `${format(prefix, "marker_overflow_left")}${result}`;
   }
-  if (
-    char === quote ||
-    point === 92 ||
-    point < 32 ||
-    (point > 126 && point < 160) ||
-    // line separators
-    point === 8232 ||
-    point === 8233
-  ) {
-    const replacement =
-      char === quote
-        ? `\\${quote}`
-        : point === 8232
-          ? "\\u2028"
-          : point === 8233
-            ? "\\u2029"
-            : meta[point];
-    return replacement;
+  if (endTruncated) {
+    return `${result}${format(suffix, "marker_overflow_right")}`;
   }
-  return char;
+  return result;
 };
 
-// https://github.com/jsenv/jsenv-uneval/blob/6c97ef9d8f2e9425a66f2c88347e0a118d427f3a/src/internal/escapeString.js#L3
-// https://github.com/jsenv/jsenv-inspect/blob/bb11de3adf262b68f71ed82b0a37d4528dd42229/src/internal/string.js#L3
-// https://github.com/joliss/js-string-escape/blob/master/index.js
-// http://javascript.crockford.com/remedial.html
-const surroundStringWith = (string, { quote, preserveLineBreaks }) => {
-  let result = "";
-  let last = 0;
-  const lastIndex = string.length;
-  let i = 0;
-  while (i < lastIndex) {
-    const char = string[i];
-    const replacement = inspectChar(char, { quote, preserveLineBreaks });
-    if (char !== replacement) {
-      if (last === i) {
-        result += replacement;
-      } else {
-        result += `${string.slice(last, i)}${replacement}`;
-      }
-      last = i + 1;
-    }
-    i++;
-  }
-  if (last !== lastIndex) {
-    result += string.slice(last);
+const fillLeft = (value, biggestValue, char = " ") => {
+  const width = String(value).length;
+  const biggestWidth = String(biggestValue).length;
+  let missingWidth = biggestWidth - width;
+  let padded = "";
+  while (missingWidth--) {
+    padded += char;
   }
-  return `${quote}${result}${quote}`;
+  padded += value;
+  return padded;
 };
 
-// prettier-ignore
-const meta = [
-  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
-  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F
-  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
-  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
-  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F
-  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F
-  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F
-  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F
-  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F
-  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F
-  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
-  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
-  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
-  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
-];
-
-const inspectSymbol = (value, { nestedHumanize, parenthesis }) => {
-  const symbolDescription = symbolToDescription(value);
-  const symbolDescriptionSource = symbolDescription
-    ? nestedHumanize(symbolDescription)
-    : "";
-  const symbolSource = `Symbol(${symbolDescriptionSource})`;
+const LOG_LEVEL_OFF = "off";
 
-  if (parenthesis) return `${symbolSource}`;
-  return symbolSource;
-};
+const LOG_LEVEL_DEBUG = "debug";
 
-const symbolToDescription =
-  "description" in Symbol.prototype
-    ? (symbol) => symbol.description
-    : (symbol) => {
-        const toStringResult = symbol.toString();
-        const openingParenthesisIndex = toStringResult.indexOf("(");
-        const closingParenthesisIndex = toStringResult.indexOf(")");
-        const symbolDescription = toStringResult.slice(
-          openingParenthesisIndex + 1,
-          closingParenthesisIndex,
-        );
-        return symbolDescription;
-      };
+const LOG_LEVEL_INFO = "info";
 
-const inspectUndefined = () => "undefined";
+const LOG_LEVEL_WARN = "warn";
 
-const inspectBigInt = (value) => {
-  return `${value}n`;
-};
+const LOG_LEVEL_ERROR = "error";
 
-const preNewLineAndIndentation = (
-  value,
-  { depth, indentUsingTab, indentSize },
-) => {
-  return `${newLineAndIndent({
-    count: depth + 1,
-    useTabs: indentUsingTab,
-    size: indentSize,
-  })}${value}`;
-};
-
-const postNewLineAndIndentation = ({ depth, indentUsingTab, indentSize }) => {
-  return newLineAndIndent({
-    count: depth,
-    useTabs: indentUsingTab,
-    size: indentSize,
-  });
-};
-
-const newLineAndIndent = ({ count, useTabs, size }) => {
-  if (useTabs) {
-    // eslint-disable-next-line prefer-template
-    return "\n" + "\t".repeat(count);
+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,
+    };
   }
-  // eslint-disable-next-line prefer-template
-  return "\n" + " ".repeat(count * size);
-};
-
-const wrapNewLineAndIndentation = (
-  value,
-  { depth, indentUsingTab, indentSize },
-) => {
-  return `${preNewLineAndIndentation(value, {
-    depth,
-    indentUsingTab,
-    indentSize,
-  })}${postNewLineAndIndentation({ depth, indentUsingTab, indentSize })}`;
-};
-
-const inspectConstructor = (value, { parenthesis, useNew }) => {
-  let formattedString = value;
-  if (parenthesis) {
-    formattedString = `(${value})`;
+  if (logLevel === LOG_LEVEL_INFO) {
+    return {
+      level: "info",
+      levels: { debug: false, info: true, warn: true, error: true },
+      debug: debugDisabled,
+      info,
+      warn,
+      error,
+    };
   }
-  if (useNew) {
-    formattedString = `new ${formattedString}`;
+  if (logLevel === LOG_LEVEL_WARN) {
+    return {
+      level: "warn",
+      levels: { debug: false, info: false, warn: true, error: true },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn,
+      error,
+    };
   }
-  return formattedString;
+  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 inspectArray = (
-  value,
-  {
-    seen = [],
-    nestedHumanize,
-    depth,
-    indentUsingTab,
-    indentSize,
-    parenthesis,
-    useNew,
-  },
-) => {
-  if (seen.indexOf(value) > -1) {
-    return "Symbol.for('circular')";
-  }
-  seen.push(value);
+const debug = (...args) => console.debug(...args);
 
-  let valuesSource = "";
-  let i = 0;
-  const j = value.length;
+const debugDisabled = () => {};
 
-  while (i < j) {
-    const valueSource = value.hasOwnProperty(i)
-      ? nestedHumanize(value[i], { seen })
-      : "";
-    if (i === 0) {
-      valuesSource += valueSource;
-    } else {
-      valuesSource += `,${preNewLineAndIndentation(valueSource, {
-        depth,
-        indentUsingTab,
-        indentSize,
-      })}`;
-    }
-    i++;
-  }
+const info = (...args) => console.info(...args);
 
-  let arraySource;
-  if (valuesSource.length) {
-    arraySource = wrapNewLineAndIndentation(valuesSource, {
-      depth,
-      indentUsingTab,
-      indentSize,
-    });
-  } else {
-    arraySource = "";
-  }
+const infoDisabled = () => {};
 
-  arraySource = `[${arraySource}]`;
+const warn = (...args) => console.warn(...args);
 
-  return inspectConstructor(arraySource, { parenthesis, useNew });
-};
+const warnDisabled = () => {};
 
-const inspectBigIntObject = (value, { nestedHumanize }) => {
-  const bigIntSource = nestedHumanize(value.valueOf());
+const error = (...args) => console.error(...args);
 
-  return `BigInt(${bigIntSource})`;
-};
+const errorDisabled = () => {};
 
-const inspectBooleanObject = (
-  value,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const booleanSource = nestedHumanize(value.valueOf());
-  return inspectConstructor(`Boolean(${booleanSource})`, {
-    useNew,
-    parenthesis,
-  });
-};
+/* globals WorkerGlobalScope, DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope */
 
-const inspectError = (
-  error,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const messageSource = nestedHumanize(error.message);
+const isBrowser = globalThis.window?.document !== undefined;
 
-  const errorSource = inspectConstructor(
-    `${errorToConstructorName(error)}(${messageSource})`,
-    {
-      useNew,
-      parenthesis,
-    },
-  );
-  return errorSource;
-};
+globalThis.process?.versions?.node !== undefined;
 
-const errorToConstructorName = ({ name }) => {
-  if (derivedErrorNameArray.includes(name)) {
-    return name;
-  }
-  return "Error";
-};
+globalThis.process?.versions?.bun !== undefined;
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
-const derivedErrorNameArray = [
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-];
+globalThis.Deno?.version?.deno !== undefined;
 
-const inspectDate = (value, { nestedHumanize, useNew, parenthesis }) => {
-  const dateSource = nestedHumanize(value.valueOf(), {
-    numericSeparator: false,
-  });
-  return inspectConstructor(`Date(${dateSource})`, { useNew, parenthesis });
-};
+globalThis.process?.versions?.electron !== undefined;
 
-const inspectFunction = (
-  value,
-  { showFunctionBody, parenthesis, depth },
-) => {
-  let functionSource;
-  if (showFunctionBody) {
-    functionSource = value.toString();
-  } else {
-    const isArrowFunction = value.prototype === undefined;
-    const head = isArrowFunction
-      ? "() =>"
-      : `function ${depth === 0 ? value.name : ""}()`;
-    functionSource = `${head} {/* hidden */}`;
-  }
+globalThis.navigator?.userAgent?.includes('jsdom') === true;
 
-  if (parenthesis) {
-    return `(${functionSource})`;
-  }
-  return functionSource;
-};
+typeof WorkerGlobalScope !== 'undefined' && globalThis instanceof WorkerGlobalScope;
 
-const inspectNumberObject = (
-  value,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const numberSource = nestedHumanize(value.valueOf());
-  return inspectConstructor(`Number(${numberSource})`, { useNew, parenthesis });
-};
+typeof DedicatedWorkerGlobalScope !== 'undefined' && globalThis instanceof DedicatedWorkerGlobalScope;
 
-const inspectObject = (
-  value,
-  {
-    nestedHumanize,
-    seen = [],
-    depth,
-    indentUsingTab,
-    indentSize,
-    objectConstructor,
-    parenthesis,
-    useNew,
-  },
-) => {
-  if (seen.indexOf(value) > -1) return "Symbol.for('circular')";
+typeof SharedWorkerGlobalScope !== 'undefined' && globalThis instanceof SharedWorkerGlobalScope;
 
-  seen.push(value);
+typeof ServiceWorkerGlobalScope !== 'undefined' && globalThis instanceof ServiceWorkerGlobalScope;
 
-  const propertySourceArray = [];
-  Object.getOwnPropertyNames(value).forEach((propertyName) => {
-    const propertyNameAsNumber = parseInt(propertyName, 10);
-    const propertyNameSource = nestedHumanize(
-      Number.isInteger(propertyNameAsNumber)
-        ? propertyNameAsNumber
-        : propertyName,
-    );
-    propertySourceArray.push({
-      nameOrSymbolSource: propertyNameSource,
-      valueSource: nestedHumanize(value[propertyName], { seen }),
-    });
-  });
-  Object.getOwnPropertySymbols(value).forEach((symbol) => {
-    propertySourceArray.push({
-      nameOrSymbolSource: `[${nestedHumanize(symbol)}]`,
-      valueSource: nestedHumanize(value[symbol], { seen }),
-    });
-  });
+// Note: I'm intentionally not DRYing up the other variables to keep them "lazy".
+const platform = globalThis.navigator?.userAgentData?.platform;
 
-  let propertiesSource = "";
-  propertySourceArray.forEach(({ nameOrSymbolSource, valueSource }, index) => {
-    if (index === 0) {
-      propertiesSource += `${nameOrSymbolSource}: ${valueSource}`;
-    } else {
-      propertiesSource += `,${preNewLineAndIndentation(
-        `${nameOrSymbolSource}: ${valueSource}`,
-        {
-          depth,
-          indentUsingTab,
-          indentSize,
-        },
-      )}`;
-    }
-  });
+platform === 'macOS'
+	|| globalThis.navigator?.platform === 'MacIntel' // Even on Apple silicon Macs.
+	|| globalThis.navigator?.userAgent?.includes(' Mac ') === true
+	|| globalThis.process?.platform === 'darwin';
 
-  let objectSource;
-  if (propertiesSource.length) {
-    objectSource = `${wrapNewLineAndIndentation(propertiesSource, {
-      depth,
-      indentUsingTab,
-      indentSize,
-    })}`;
-  } else {
-    objectSource = "";
-  }
+platform === 'Windows'
+	|| globalThis.navigator?.platform === 'Win32'
+	|| globalThis.process?.platform === 'win32';
 
-  if (objectConstructor) {
-    objectSource = `Object({${objectSource}})`;
-  } else {
-    objectSource = `{${objectSource}}`;
-  }
+platform === 'Linux'
+	|| globalThis.navigator?.platform?.startsWith('Linux') === true
+	|| globalThis.navigator?.userAgent?.includes(' Linux ') === true
+	|| globalThis.process?.platform === 'linux';
 
-  return inspectConstructor(objectSource, { parenthesis, useNew });
-};
+platform === 'Android'
+	|| globalThis.navigator?.platform === 'Android'
+	|| globalThis.navigator?.userAgent?.includes(' Android ') === true
+	|| globalThis.process?.platform === 'android';
 
-const inspectRegExp = (value) => value.toString();
+const ESC = '\u001B[';
 
-const inspectStringObject = (
-  value,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const stringSource = nestedHumanize(value.valueOf());
+!isBrowser && process$1.env.TERM_PROGRAM === 'Apple_Terminal';
+const isWindows = !isBrowser && process$1.platform === 'win32';
 
-  return inspectConstructor(`String(${stringSource})`, { useNew, parenthesis });
+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';
 
-// primitives
+const clearTerminal = isWindows
+	? `${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`;
 
-const humanize = (
-  value,
-  {
-    parenthesis = false,
-    quote = "auto",
-    canUseTemplateString = true,
-    useNew = false,
-    objectConstructor = false,
-    showFunctionBody = false,
-    indentUsingTab = false,
-    indentSize = 2,
-    numericSeparator = true,
-    preserveLineBreaks = false,
-  } = {},
-) => {
-  const scopedHumanize = (scopedValue, scopedOptions) => {
-    const options = {
-      ...scopedOptions,
-      nestedHumanize: (nestedValue, nestedOptions = {}) => {
-        return scopedHumanize(nestedValue, {
-          ...scopedOptions,
-          depth: scopedOptions.depth + 1,
-          ...nestedOptions,
-        });
-      },
-    };
-    return humanizeValue(scopedValue, options);
+/*
+ * 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,
   };
 
-  return scopedHumanize(value, {
-    parenthesis,
-    quote,
-    canUseTemplateString,
-    useNew,
-    objectConstructor,
-    showFunctionBody,
-    indentUsingTab,
-    indentSize,
-    numericSeparator,
-    preserveLineBreaks,
-    depth: 0,
-  });
-};
+  let lastOutput = "";
+  let lastOutputFromOutside = "";
+  let clearAttemptResult;
+  let writing = false;
 
-const humanizeMethodSymbol = Symbol.for("inspect");
+  const getErasePreviousOutput = () => {
+    // nothing to clear
+    if (!lastOutput) {
+      return "";
+    }
+    if (clearAttemptResult !== undefined) {
+      return "";
+    }
 
-const humanizeValue = (value, options) => {
-  const customHumanize = value && value[humanizeMethodSymbol];
-  if (customHumanize) {
-    return customHumanize(options);
-  }
-  const primitiveType = primitiveTypeFromValue(value);
-  const primitiveStringifier = primitiveStringifiers[primitiveType];
-  if (primitiveStringifier) {
-    return primitiveStringifier(value, options);
-  }
-  const compositeType = compositeTypeFromObject(value);
-  const compositeStringifier = compositeStringifiers[compositeType];
-  if (compositeStringifier) {
-    return compositeStringifier(value, options);
-  }
-  return inspectConstructor(
-    `${compositeType}(${inspectObject(value, options)})`,
-    {
-      ...options,
-      parenthesis: false,
-    },
-  );
-};
+    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);
+      }
+    }
 
-const primitiveTypeFromValue = (value) => {
-  if (value === null) {
-    return "null";
-  }
-  if (value === undefined) {
-    return "undefined";
-  }
-  return typeof value;
-};
-const primitiveStringifiers = {
-  boolean: inspectBoolean,
-  function: inspectFunction,
-  null: inspectNull,
-  number: inspectNumber,
-  string: inspectString,
-  symbol: inspectSymbol,
-  undefined: inspectUndefined,
-  bigint: inspectBigInt,
-};
-const compositeTypeFromObject = (object) => {
-  if (typeof object === "object" && Object.getPrototypeOf(object) === null) {
-    return "Object";
-  }
-  const toStringResult = toString.call(object);
-  // returns format is '[object ${tagName}]';
-  // and we want ${tagName}
-  const tagName = toStringResult.slice("[object ".length, -1);
-  if (tagName === "Object") {
-    const objectConstructorName = object.constructor.name;
-    if (objectConstructorName !== "Object") {
-      return objectConstructorName;
+    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 "";
     }
-  }
-  return tagName;
-};
-const { toString } = Object.prototype;
 
-const compositeStringifiers = {
-  Array: inspectArray,
-  BigInt: inspectBigIntObject,
-  Boolean: inspectBooleanObject,
-  Error: inspectError,
-  Date: inspectDate,
-  Function: inspectFunction,
-  Number: inspectNumberObject,
-  Object: inspectObject,
-  RegExp: inspectRegExp,
-  String: inspectStringObject,
-};
+    clearAttemptResult = true;
+    return eraseLines(visualLineCount);
+  };
 
-const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
-  return inspectBytes(numberOfBytes, { decimals, short });
-};
+  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 humanizeMemory = (metricValue, { decimals, short } = {}) => {
-  return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
-};
+  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 inspectBytes = (
-  number,
-  { fixedDecimals = false, decimals, short } = {},
-) => {
-  if (number === 0) {
-    return `0 B`;
-  }
-  const exponent = Math.min(
-    Math.floor(Math.log10(number) / 3),
-    BYTE_UNITS.length - 1,
-  );
-  const unitNumber = number / Math.pow(1000, exponent);
-  const unitName = BYTE_UNITS[exponent];
-  if (decimals === undefined) {
-    if (unitNumber < 100) {
-      decimals = 1;
-    } else {
-      decimals = 0;
+    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 unitNumberRounded = setRoundedPrecision(unitNumber, {
-    decimals,
-    decimalsWhenSmall: 1,
+
+  const destroy = () => {
+    dynamicLog.destroyed = true;
+    if (removeStreamSpy) {
+      removeStreamSpy();
+      removeStreamSpy = null;
+      lastOutput = "";
+      lastOutputFromOutside = "";
+    }
+  };
+
+  Object.assign(dynamicLog, {
+    update,
+    destroy,
+    stream,
+    clearDuringFunctionCall,
   });
-  const value = fixedDecimals
-    ? unitNumberRounded.toFixed(decimals)
-    : unitNumberRounded;
-  if (short) {
-    return `${value}${unitName}`;
-  }
-  return `${value} ${unitName}`;
+  return dynamicLog;
 };
 
-const BYTE_UNITS = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+// 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;
 
-const distributePercentages = (
-  namedNumbers,
-  { maxPrecisionHint = 2 } = {},
-) => {
-  const numberNames = Object.keys(namedNumbers);
-  if (numberNames.length === 0) {
-    return {};
-  }
-  if (numberNames.length === 1) {
-    const firstNumberName = numberNames[0];
-    return { [firstNumberName]: "100 %" };
-  }
-  const numbers = numberNames.map((name) => namedNumbers[name]);
-  const total = numbers.reduce((sum, value) => sum + value, 0);
-  const ratios = numbers.map((number) => number / total);
-  const percentages = {};
-  ratios.pop();
-  ratios.forEach((ratio, index) => {
-    const percentage = ratio * 100;
-    percentages[numberNames[index]] = percentage;
-  });
-  const lowestPercentage = (1 / Math.pow(10, maxPrecisionHint)) * 100;
-  let precision = 0;
-  Object.keys(percentages).forEach((name) => {
-    const percentage = percentages[name];
-    if (percentage < lowestPercentage) {
-      // check the amout of meaningful decimals
-      // and that what we will use
-      const percentageRounded = setRoundedPrecision(percentage);
-      const percentagePrecision = getPrecision(percentageRounded);
-      if (percentagePrecision > precision) {
-        precision = percentagePrecision;
-      }
-    }
-  });
-  let remainingPercentage = 100;
+  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;
+  };
 
-  Object.keys(percentages).forEach((name) => {
-    const percentage = percentages[name];
-    const percentageAllocated = setRoundedPrecision(percentage, {
-      decimals: precision,
-    });
-    remainingPercentage -= percentageAllocated;
-    percentages[name] = percentageAllocated;
-  });
-  const lastName = numberNames[numberNames.length - 1];
-  percentages[lastName] = setRoundedPrecision(remainingPercentage, {
-    decimals: precision,
-  });
-  return percentages;
+  return () => {
+    uninstall();
+    return output;
+  };
 };
 
-const formatDefault = (v) => v;
+const startSpinner = ({
+  dynamicLog,
+  frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  fps = 20,
+  keepProcessAlive = false,
+  stopOnWriteFromOutside = true,
+  stopOnVerticalOverflow = true,
+  render = () => "",
+  effect = () => {},
+  animated = dynamicLog.stream.isTTY,
+}) => {
+  let frameIndex = 0;
+  let interval;
+  let running = true;
 
-const generateContentFrame = ({
-  content,
-  line,
-  column,
+  const spinner = {
+    message: undefined,
+  };
 
-  linesAbove = 3,
-  linesBelow = 0,
-  lineMaxWidth = 120,
-  lineNumbersOnTheLeft = true,
-  lineMarker = true,
-  columnMarker = true,
-  format = formatDefault,
-} = {}) => {
-  const lineStrings = content.split(/\r?\n/);
-  if (line === 0) line = 1;
-  if (column === undefined) {
-    columnMarker = false;
-    column = 1;
-  }
-  if (column === 0) column = 1;
+  const update = (message) => {
+    spinner.message = running
+      ? `${frames[frameIndex]} ${message}\n`
+      : `${message}\n`;
+    return spinner.message;
+  };
+  spinner.update = update;
 
-  let lineStartIndex = line - 1 - linesAbove;
-  if (lineStartIndex < 0) {
-    lineStartIndex = 0;
-  }
-  let lineEndIndex = line - 1 + linesBelow;
-  if (lineEndIndex > lineStrings.length - 1) {
-    lineEndIndex = lineStrings.length - 1;
-  }
-  if (columnMarker) {
-    // human reader deduce the line when there is a column marker
-    lineMarker = false;
-  }
-  if (line - 1 === lineEndIndex) {
-    lineMarker = false; // useless because last line
-  }
-  let lineIndex = lineStartIndex;
+  let cleanup;
+  if (animated && ANSI.supported) {
+    running = true;
+    cleanup = effect();
+    dynamicLog.update(update(render()));
 
-  let columnsBefore;
-  let columnsAfter;
-  if (column > lineMaxWidth) {
-    columnsBefore = column - Math.ceil(lineMaxWidth / 2);
-    columnsAfter = column + Math.floor(lineMaxWidth / 2);
+    interval = setInterval(() => {
+      frameIndex = frameIndex === frames.length - 1 ? 0 : frameIndex + 1;
+      dynamicLog.update(update(render()));
+    }, 1000 / fps);
+    if (!keepProcessAlive) {
+      interval.unref();
+    }
   } else {
-    columnsBefore = 0;
-    columnsAfter = lineMaxWidth;
+    dynamicLog.update(update(render()));
   }
-  let columnMarkerIndex = column - 1 - columnsBefore;
-
-  let source = "";
-  while (lineIndex <= lineEndIndex) {
-    const lineString = lineStrings[lineIndex];
-    const lineNumber = lineIndex + 1;
-    const isLastLine = lineIndex === lineEndIndex;
-    const isMainLine = lineNumber === line;
-    lineIndex++;
 
-    {
-      if (lineMarker) {
-        if (isMainLine) {
-          source += `${format(">", "marker_line")} `;
-        } else {
-          source += "  ";
-        }
-      }
-      if (lineNumbersOnTheLeft) {
-        // fill with spaces to ensure if line moves from 7,8,9 to 10 the display is still great
-        const asideSource = `${fillLeft(lineNumber, lineEndIndex + 1)} |`;
-        source += `${format(asideSource, "line_number_aside")} `;
-      }
-    }
-    {
-      source += truncateLine(lineString, {
-        start: columnsBefore,
-        end: columnsAfter,
-        prefix: "…",
-        suffix: "…",
-        format,
-      });
+  const stop = (message) => {
+    running = false;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
     }
-    {
-      if (columnMarker && isMainLine) {
-        source += `\n`;
-        if (lineMarker) {
-          source += "  ";
-        }
-        if (lineNumbersOnTheLeft) {
-          const asideSpaces = `${fillLeft(lineNumber, lineEndIndex + 1)} | `
-            .length;
-          source += " ".repeat(asideSpaces);
-        }
-        source += " ".repeat(columnMarkerIndex);
-        source += format("^", "marker_column");
-      }
+    if (cleanup) {
+      cleanup();
+      cleanup = null;
     }
-    if (!isLastLine) {
-      source += "\n";
+    if (dynamicLog && message) {
+      dynamicLog.update(update(message));
+      dynamicLog = null;
     }
-  }
-  return source;
-};
-
-const truncateLine = (line, { start, end, prefix, suffix, format }) => {
-  const lastIndex = line.length;
-
-  if (line.length === 0) {
-    // don't show any ellipsis if the line is empty
-    // because it's not truncated in that case
-    return "";
-  }
-
-  const startTruncated = start > 0;
-  const endTruncated = lastIndex > end;
-
-  let from = startTruncated ? start + prefix.length : start;
-  let to = endTruncated ? end - suffix.length : end;
-  if (to > lastIndex) to = lastIndex;
+  };
+  spinner.stop = stop;
 
-  if (start >= lastIndex || from === to) {
-    return "";
-  }
-  let result = "";
-  while (from < to) {
-    result += format(line[from], "char");
-    from++;
-  }
-  if (result.length === 0) {
-    return "";
-  }
-  if (startTruncated && endTruncated) {
-    return `${format(prefix, "marker_overflow_left")}${result}${format(
-      suffix,
-      "marker_overflow_right",
-    )}`;
-  }
-  if (startTruncated) {
-    return `${format(prefix, "marker_overflow_left")}${result}`;
+  if (stopOnVerticalOverflow) {
+    dynamicLog.onVerticalOverflow = stop;
   }
-  if (endTruncated) {
-    return `${result}${format(suffix, "marker_overflow_right")}`;
+  if (stopOnWriteFromOutside) {
+    dynamicLog.onWriteFromOutside = stop;
   }
-  return result;
+
+  return spinner;
 };
 
-const fillLeft = (value, biggestValue, char = " ") => {
-  const width = String(value).length;
-  const biggestWidth = String(biggestValue).length;
-  let missingWidth = biggestWidth - width;
-  let padded = "";
-  while (missingWidth--) {
-    padded += char;
+const createTaskLog = (
+  label,
+  { disabled = false, animated = true, stopOnWriteFromOutside } = {},
+) => {
+  if (disabled) {
+    return {
+      setRightText: () => {},
+      done: () => {},
+      happen: () => {},
+      fail: () => {},
+    };
   }
-  padded += value;
-  return padded;
+  const startMs = Date.now();
+  const dynamicLog = createDynamicLog();
+  let message = label;
+  const taskSpinner = startSpinner({
+    dynamicLog,
+    render: () => message,
+    stopOnWriteFromOutside,
+    animated,
+  });
+  return {
+    setRightText: (value) => {
+      message = `${label} ${value}`;
+    },
+    done: () => {
+      const msEllapsed = Date.now() - startMs;
+      taskSpinner.stop(
+        `${UNICODE.OK} ${label} (done in ${humanizeDuration(msEllapsed)})`,
+      );
+    },
+    happen: (message) => {
+      taskSpinner.stop(
+        `${UNICODE.INFO} ${message} (at ${new Date().toLocaleTimeString()})`,
+      );
+    },
+    fail: (message = `failed to ${label}`) => {
+      taskSpinner.stop(`${UNICODE.FAILURE} ${message}`);
+    },
+  };
 };
 
-export { ANSI, UNICODE, createDetailedMessage, createDynamicLog, createLogger, createTaskLog, determineQuote, distributePercentages, generateContentFrame, humanize, humanizeDuration, humanizeEllapsedTime, humanizeFileSize, humanizeMemory, humanizeMethodSymbol, inspectChar, startSpinner };
+export { ANSI, UNICODE, createDetailedMessage, createDynamicLog, createLogger, createTaskLog, distributePercentages, generateContentFrame, humanize, humanizeDuration, humanizeEllapsedTime, humanizeFileSize, humanizeMemory, humanizeMethodSymbol, startSpinner };