@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/exec.cjs

@@ -0,0 +1,455 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exec_exports = {};
+__export(exec_exports, {
+  appendNodeOption: () => appendNodeOption,
+  buildChildEnv: () => buildChildEnv,
+  exec: () => exec
+});
+module.exports = __toCommonJS(exec_exports);
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_node_child_process = require('node:child_process');
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_cli_utils = require('./cli-utils.cjs');
+function appendNodeOption(existingNodeOptions, option) {
+  const trimmed = (existingNodeOptions ?? "").trim();
+  if (trimmed === "") {
+    return option;
+  }
+  return trimmed.split(/\s+/).includes(option) ? trimmed : `${trimmed} ${option}`;
+}
+function buildChildEnv(baseEnv, allowedNodeEnvironmentFlags) {
+  return {
+    DEBUG_COLORS: "1",
+    ...baseEnv,
+    ...allowedNodeEnvironmentFlags.has("--localstorage-file") && { NODE_OPTIONS: appendNodeOption(baseEnv["NODE_OPTIONS"], LOCAL_STORAGE_NODE_OPTION) }
+  };
+}
+function exec(command, options = {}) {
+  if (Array.isArray(command)) {
+    const batchResult = handleBatchedCommand(command, options);
+    if (batchResult) {
+      return batchResult;
+    }
+    const $arguments = command.filter((part) => typeof part === "string");
+    const commandLine = buildCommandLine($arguments);
+    const maxCommandLength2 = getMaxCommandLength();
+    const effectiveLength2 = getEffectiveCommandLineLength(commandLine);
+    return effectiveLength2 > maxCommandLength2 ? Promise.reject(
+      new Error(
+        `Command line is too long (${String(effectiveLength2)} chars once wrapped for the shell, max ${String(maxCommandLength2)} on ${import_node_process.default.platform}). Consider splitting into smaller batches or use ExecArg.`
+      )
+    ) : execString({
+      command: commandLine,
+      options,
+      rawArguments: $arguments
+    });
+  }
+  const maxCommandLength = getMaxCommandLength();
+  const effectiveLength = getEffectiveCommandLineLength(command);
+  return effectiveLength > maxCommandLength ? Promise.reject(
+    new Error(
+      `Command line is too long (${String(effectiveLength)} chars once wrapped for the shell, max ${String(maxCommandLength)} on ${import_node_process.default.platform}). Consider splitting into smaller batches or use ExecArg.`
+    )
+  ) : execString({
+    command,
+    options
+  });
+}
+function execString(params) {
+  const {
+    command,
+    options = {},
+    rawArguments
+  } = params;
+  const {
+    cwd = import_node_process.default.cwd(),
+    env,
+    isInteractive = false,
+    isQuiet: quiet = false,
+    shouldIgnoreExitCode: ignoreExitCode = false,
+    shouldIncludeDetails = false,
+    stdin = ""
+  } = options;
+  return new Promise((resolve, reject) => {
+    (0, import_debug.getLibDebugger)("Exec")(`Executing command: ${command}`);
+    const child = spawnViaShell((0, import_object_utils.normalizeOptionalProperties)({
+      command,
+      cwd,
+      env,
+      isInteractive,
+      rawArguments
+    }));
+    let stdout = "";
+    let stderr = "";
+    if (!isInteractive) {
+      const {
+        stderr: childStderr,
+        stdin: childStdin,
+        stdout: childStdout
+      } = child;
+      (0, import_type_guards.assertNonNullable)(childStdin, "Child process stdin is not available");
+      (0, import_type_guards.assertNonNullable)(childStdout, "Child process stdout is not available");
+      (0, import_type_guards.assertNonNullable)(childStderr, "Child process stderr is not available");
+      childStdin.write(stdin);
+      childStdin.end();
+      childStdout.on("data", (data) => {
+        if (!quiet) {
+          import_node_process.default.stdout.write(data);
+        }
+        stdout += data.toString("utf-8");
+      });
+      childStdout.on("end", () => {
+        stdout = (0, import_string.trimEnd)({
+          $string: stdout,
+          suffix: "\n"
+        });
+      });
+      childStderr.on("data", (data) => {
+        if (!quiet) {
+          import_node_process.default.stderr.write(data);
+        }
+        stderr += data.toString("utf-8");
+      });
+      childStderr.on("end", () => {
+        stderr = (0, import_string.trimEnd)({
+          $string: stderr,
+          suffix: "\n"
+        });
+      });
+    }
+    child.on("close", (exitCode, exitSignal) => {
+      if (exitCode !== 0 && !ignoreExitCode) {
+        reject(
+          new Error(describeExitFailure({
+            command,
+            exitCode,
+            exitSignal,
+            isInteractive,
+            isQuiet: quiet,
+            stderr,
+            stdout
+          }))
+        );
+        return;
+      }
+      if (!shouldIncludeDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode,
+        exitSignal,
+        stderr,
+        stdout
+      });
+    });
+    child.on("error", (error) => {
+      if (!ignoreExitCode) {
+        reject(new Error(`Could not run command: ${truncateCommand(command)}
+${error.message}`, { cause: error }));
+        return;
+      }
+      if (!shouldIncludeDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode: null,
+        exitSignal: null,
+        stderr,
+        stdout
+      });
+    });
+  });
+}
+const LOCAL_STORAGE_NODE_OPTION = "--localstorage-file=:memory:";
+const MAX_COMMAND_LENGTH_IN_MESSAGE = 500;
+const NTSTATUS_NAMES = /* @__PURE__ */ new Map([
+  ["0xC0000005", "STATUS_ACCESS_VIOLATION"],
+  ["0xC0000017", "STATUS_NO_MEMORY"],
+  ["0xC000001D", "STATUS_ILLEGAL_INSTRUCTION"],
+  ["0xC0000094", "STATUS_INTEGER_DIVIDE_BY_ZERO"],
+  ["0xC00000FD", "STATUS_STACK_OVERFLOW"],
+  ["0xC0000135", "STATUS_DLL_NOT_FOUND"],
+  ["0xC000013A", "STATUS_CONTROL_C_EXIT"],
+  ["0xC0000374", "STATUS_HEAP_CORRUPTION"],
+  ["0xC0000409", "STATUS_STACK_BUFFER_OVERRUN"]
+]);
+const WINDOWS_CHILD_EXPANSION_RESERVE = 2048;
+function buildCommandLine($arguments) {
+  return import_node_process.default.platform === "win32" ? (0, import_cli_utils.toCommandLine)($arguments) : (0, import_cli_utils.toPosixCommandLine)($arguments);
+}
+function describeExitFailure(params) {
+  const { command, exitCode, exitSignal, isInteractive, isQuiet, stderr, stdout } = params;
+  const ntStatus = toNtStatus(exitCode);
+  let status = `exit code ${exitCode === null ? "(null)" : String(exitCode)}`;
+  let abnormalReason = null;
+  if (ntStatus !== null) {
+    const HEX_RADIX = 16;
+    const hex = `0x${ntStatus.toString(HEX_RADIX).toUpperCase()}`;
+    const name = NTSTATUS_NAMES.get(hex);
+    status += ` (NTSTATUS ${name ? `${hex} ${name}` : hex})`;
+    abnormalReason = name === "STATUS_CONTROL_C_EXIT" ? "was interrupted" : "crashed";
+  } else if (exitSignal !== null) {
+    status += `, terminated by signal ${exitSignal}`;
+    abnormalReason = `was killed by ${exitSignal}`;
+  }
+  const lines = [`Command failed with ${status}`, `Command: ${truncateCommand(command)}`];
+  if (abnormalReason !== null) {
+    lines.push(
+      !isInteractive && stdout === "" && stderr === "" ? `The child process ${abnormalReason} before writing anything to stdout or stderr. This is not a failure the tool reported (not a lint finding, not a type error): re-run the command.` : `The child process ${abnormalReason} rather than exiting on its own, so any output it wrote may be incomplete.`
+    );
+  }
+  if (stdout !== "") {
+    lines.push(isQuiet ? `stdout:
+${stdout}` : `stdout: ${String(stdout.split("\n").length)} line(s), printed above.`);
+  }
+  if (stderr !== "") {
+    lines.push(`stderr:
+${stderr}`);
+  }
+  return lines.join("\n");
+}
+async function executeBatches(params) {
+  const { baseCommand, batches, options } = params;
+  const stdoutParts = [];
+  const stderrParts = [];
+  let failure = null;
+  for (const batch of batches) {
+    const batchCommand = `${baseCommand} ${buildCommandLine(batch)}`;
+    const result = await execString({
+      command: batchCommand,
+      options
+    });
+    if (typeof result === "string") {
+      pushIfNotEmpty(stdoutParts, result);
+      continue;
+    }
+    pushIfNotEmpty(stdoutParts, result.stdout);
+    pushIfNotEmpty(stderrParts, result.stderr);
+    if (result.exitCode !== 0 && (failure === null || !isAbnormalTermination(failure) && isAbnormalTermination(result))) {
+      failure = result;
+    }
+  }
+  return options.shouldIncludeDetails ? {
+    // Not `failure?.exitCode ?? 0`: a batch killed by a signal has a `null` code, which `??` would report as success.
+    exitCode: failure === null ? 0 : failure.exitCode,
+    exitSignal: failure?.exitSignal ?? null,
+    stderr: stderrParts.join("\n"),
+    stdout: stdoutParts.join("\n")
+  } : stdoutParts.join("\n");
+}
+function getChildEnv() {
+  return buildChildEnv(import_node_process.default.env, import_node_process.default.allowedNodeEnvironmentFlags);
+}
+function getEffectiveCommandLineLength(commandLine) {
+  if (import_node_process.default.platform !== "win32") {
+    return commandLine.length;
+  }
+  const comspec = import_node_process.default.env["comspec"] ?? "cmd.exe";
+  const CMD_WRAPPER = ' /d /s /c ""';
+  return comspec.length + CMD_WRAPPER.length + (0, import_cli_utils.cmdEscapeCommandLine)(commandLine).length;
+}
+function getMaxBatchCommandLength() {
+  return getMaxCommandLength() - (import_node_process.default.platform === "win32" ? WINDOWS_CHILD_EXPANSION_RESERVE : 0);
+}
+function getMaxCommandLength() {
+  const WINDOWS_MAX_COMMAND_LENGTH = 8191;
+  const UNIX_MAX_COMMAND_LENGTH = 131072;
+  return import_node_process.default.platform === "win32" ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;
+}
+function handleBatchedCommand(parts, options) {
+  const execArguments = parts.filter(isExecArgument);
+  if (execArguments.length === 0) {
+    return void 0;
+  }
+  if (execArguments.length > 1) {
+    return Promise.reject(new Error("Only one ExecArg with batchedArguments is allowed per command"));
+  }
+  const execArgument = execArguments[0];
+  (0, import_type_guards.assertNonNullable)(execArgument);
+  const staticParts = parts.filter((part) => typeof part === "string");
+  const baseCommand = buildCommandLine(staticParts);
+  const maxCommandLength = getMaxBatchCommandLength();
+  const fullCommand = `${baseCommand} ${buildCommandLine([...execArgument.batchedArguments])}`;
+  if (getEffectiveCommandLineLength(fullCommand) <= maxCommandLength) {
+    return execString({
+      command: fullCommand,
+      options
+    });
+  }
+  const batches = [];
+  let currentBatch = [];
+  for (const argument of execArgument.batchedArguments) {
+    const tentative = `${baseCommand} ${buildCommandLine([...currentBatch, argument])}`;
+    if (getEffectiveCommandLineLength(tentative) > maxCommandLength) {
+      if (currentBatch.length === 0) {
+        return Promise.reject(
+          new Error(
+            `Cannot split command into batches: a single argument (${String(argument.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max batch command length (${String(maxCommandLength)}).`
+          )
+        );
+      }
+      batches.push(currentBatch);
+      currentBatch = [argument];
+    } else {
+      currentBatch.push(argument);
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return executeBatches({
+    baseCommand,
+    batches,
+    options
+  });
+}
+function isAbnormalTermination(result) {
+  return result.exitSignal !== null || toNtStatus(result.exitCode) !== null;
+}
+function isExecArgument(part) {
+  return typeof part === "object" && "batchedArguments" in part;
+}
+function pushIfNotEmpty(accumulator, output) {
+  if (output !== "") {
+    accumulator.push(output);
+  }
+}
+function spawnViaShell(params) {
+  const { command, cwd, env: extraEnv, isInteractive = false, rawArguments } = params;
+  const env = {
+    ...getChildEnv(),
+    ...extraEnv
+  };
+  const stdio = isInteractive ? "inherit" : "pipe";
+  if (import_node_process.default.platform === "win32" && command.includes("\n")) {
+    if (!rawArguments) {
+      throw new Error("Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.");
+    }
+    const [program, ...$arguments] = rawArguments;
+    (0, import_type_guards.assertNonNullable)(program, "Command array must not be empty");
+    return (0, import_node_child_process.spawn)(program, $arguments, {
+      cwd,
+      env,
+      stdio
+    });
+  }
+  const shellCommand = import_node_process.default.platform === "win32" ? (0, import_cli_utils.cmdEscapeCommandLine)(command) : command;
+  return (0, import_node_child_process.spawn)(shellCommand, [], {
+    cwd,
+    env,
+    shell: true,
+    stdio
+  });
+}
+function toNtStatus(exitCode) {
+  if (exitCode === null || !Number.isSafeInteger(exitCode)) {
+    return null;
+  }
+  const NTSTATUS_ERROR_START = 3221225472;
+  const NTSTATUS_ERROR_END = 3758096384;
+  const UINT32_RANGE = 4294967296;
+  const unsigned = exitCode < 0 ? exitCode + UINT32_RANGE : exitCode;
+  return unsigned >= NTSTATUS_ERROR_START && unsigned < NTSTATUS_ERROR_END ? unsigned : null;
+}
+function truncateCommand(command) {
+  return command.length > MAX_COMMAND_LENGTH_IN_MESSAGE ? `${command.slice(0, MAX_COMMAND_LENGTH_IN_MESSAGE)}\u2026` : command;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendNodeOption,
+  buildChildEnv,
+  exec
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport { trimEnd } from '@mnaoumov/typescript-lib/string';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\nimport {\n  cmdEscapeCommandLine as commandEscapeCommandLine,\n  toCommandLine,\n  toPosixCommandLine\n} from './cli-utils.ts';\n\n/**\n * A command part: either a plain string or an {@link ExecArgument} with batched arguments.\n */\nexport type CommandPart = ExecArgument | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArgument {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArguments: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOptions {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOptions {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * Additional environment variables for the child process, merged over the inherited environment.\n   *\n   * @default `{}`\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child process's stdio directly to the terminal (`stdio: 'inherit'`) instead\n   * of capturing it. Use for long-running or interactive commands such as dev servers and watch mode.\n   * Because the output is not captured, the resolved stdout is an empty string.\n   *\n   * @default `false`\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   *\n   * @default `false`\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   *\n   * @default `true`\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   *\n   * @default `''`\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOptions {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Parameters for {@link execString}.\n */\ninterface ExecStringParams {\n  /**\n   * The command string.\n   */\n  readonly command: string;\n\n  /**\n   * The exec options.\n   */\n  readonly options?: ExecOptions;\n\n  /**\n   * The original argument array (if available), used by the PowerShell\n   * fallback path to quote arguments with PowerShell-native single quotes.\n   */\n  readonly rawArguments?: string[];\n}\n/**\n * Appends a single `node` CLI option to a `NODE_OPTIONS` string, preserving any options already present.\n *\n * @param existingNodeOptions - The current `NODE_OPTIONS` value (e.g. `process.env.NODE_OPTIONS`), if any.\n * @param option - The `node` CLI option to append (e.g. `--localstorage-file=:memory:`).\n * @returns The combined `NODE_OPTIONS` string. If `option` is already present, the value is returned unchanged.\n */\nexport function appendNodeOption(existingNodeOptions: string | undefined, option: string): string {\n  const trimmed = (existingNodeOptions ?? '').trim();\n  if (trimmed === '') {\n    return option;\n  }\n  return trimmed.split(/\\s+/).includes(option) ? trimmed : `${trimmed} ${option}`;\n}\n\n/**\n * Builds the environment for child processes: the parent environment plus `DEBUG_COLORS`, and \u2014 when\n * the running `node` supports it \u2014 {@link LOCAL_STORAGE_NODE_OPTION} appended to `NODE_OPTIONS`.\n *\n * The support check guards against older `node` (< 22): passing an option `node` does not recognize via\n * `NODE_OPTIONS` makes it exit before running, which would break every spawned tool.\n *\n * @param baseEnv - The parent environment to extend (typically `process.env`).\n * @param allowedNodeEnvironmentFlags - The `node` options accepted via `NODE_OPTIONS` (typically `process.allowedNodeEnvironmentFlags`).\n * @returns The environment to pass to spawned child processes.\n */\nexport function buildChildEnv(baseEnv: NodeJS.ProcessEnv, allowedNodeEnvironmentFlags: ReadonlySet<string>): NodeJS.ProcessEnv {\n  return {\n    DEBUG_COLORS: '1',\n    ...baseEnv,\n    ...(allowedNodeEnvironmentFlags.has('--localstorage-file') && { NODE_OPTIONS: appendNodeOption(baseEnv['NODE_OPTIONS'], LOCAL_STORAGE_NODE_OPTION) })\n  };\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code, the command, stderr, and stdout (or a note that it was\n *         printed), and says when the child crashed or was killed rather than exiting on its own.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code, the command, stderr, and stdout (or a note that it was\n *         printed), and says when the child crashed or was killed rather than exiting on its own.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code, the command, stderr, and stdout (or a note that it was\n *         printed), and says when the child crashed or was killed rather than exiting on its own.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOptions = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const $arguments = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = buildCommandLine($arguments);\n\n    const maxCommandLength = getMaxCommandLength();\n    const effectiveLength = getEffectiveCommandLineLength(commandLine);\n    return effectiveLength > maxCommandLength\n      ? Promise.reject(\n        new Error(\n          `Command line is too long (${String(effectiveLength)} chars once wrapped for the shell, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n        )\n      )\n      : execString({\n        command: commandLine,\n        options,\n        rawArguments: $arguments\n      });\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  const effectiveLength = getEffectiveCommandLineLength(command);\n  return effectiveLength > maxCommandLength\n    ? Promise.reject(\n      new Error(\n        `Command line is too long (${String(effectiveLength)} chars once wrapped for the shell, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n      )\n    )\n    : execString({\n      command,\n      options\n    });\n}\n\n/**\n * Executes a single string command.\n *\n * @param params - The parameters for the execution.\n * @returns A Promise resolving to the result.\n */\nfunction execString(params: ExecStringParams): Promise<ExecResult | string> {\n  const {\n    command,\n    options = {},\n    rawArguments\n  } = params;\n  const {\n    cwd = process.cwd(),\n    env,\n    isInteractive = false,\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawnViaShell(normalizeOptionalProperties<SpawnViaShellParams>({\n      command,\n      cwd,\n      env,\n      isInteractive,\n      rawArguments\n    }));\n\n    let stdout = '';\n    let stderr = '';\n\n    // In interactive mode the child's stdio is inherited by the terminal, so there are no streams to read and nothing is captured.\n    if (!isInteractive) {\n      const {\n        stderr: childStderr,\n        stdin: childStdin,\n        stdout: childStdout\n      } = child;\n      assertNonNullable(childStdin, 'Child process stdin is not available');\n      assertNonNullable(childStdout, 'Child process stdout is not available');\n      assertNonNullable(childStderr, 'Child process stderr is not available');\n\n      childStdin.write(stdin);\n      childStdin.end();\n\n      childStdout.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stdout.write(data);\n        }\n        stdout += data.toString('utf-8');\n      });\n\n      childStdout.on('end', () => {\n        stdout = trimEnd({\n          $string: stdout,\n          suffix: '\\n'\n        });\n      });\n\n      childStderr.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stderr.write(data);\n        }\n        stderr += data.toString('utf-8');\n      });\n\n      childStderr.on('end', () => {\n        stderr = trimEnd({\n          $string: stderr,\n          suffix: '\\n'\n        });\n      });\n    }\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(\n          new Error(describeExitFailure({\n            command,\n            exitCode,\n            exitSignal,\n            isInteractive,\n            isQuiet: quiet,\n            stderr,\n            stdout\n          }))\n        );\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (error) => {\n      if (!ignoreExitCode) {\n        reject(new Error(`Could not run command: ${truncateCommand(command)}\\n${error.message}`, { cause: error }));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * A `node` CLI option (passed via `NODE_OPTIONS`) that provides an in-memory `localStorage` to every\n * spawned `node` process. Node 22+ exposes an experimental Web Storage `localStorage`, but accessing it\n * without `--localstorage-file` emits an `ExperimentalWarning` and leaves `localStorage` unavailable.\n * Pointing it at the special `:memory:` database gives each process a working, non-persistent\n * `localStorage` (no file on disk, no state shared between processes) \u2014 matching the real Obsidian\n * (Electron) runtime and silencing the warning by addressing its root cause rather than suppressing it.\n *\n * It is applied only when the running `node` actually supports it (see {@link buildChildEnv}): passing\n * an option `node` does not recognize via `NODE_OPTIONS` makes it refuse to start, so an older `node`\n * (< 22) must be left untouched.\n */\nconst LOCAL_STORAGE_NODE_OPTION = '--localstorage-file=:memory:';\n\n/**\n * The longest command a failure message quotes before truncating it. A batched command can run to several\n * thousand characters of paths, which would bury the one line of the message that says what went wrong.\n */\nconst MAX_COMMAND_LENGTH_IN_MESSAGE = 500;\n\n/**\n * Names of the Windows NTSTATUS codes a crashed child most often exits with, for the failure message. A code\n * outside this list is still recognized as an NTSTATUS failure (see {@link toNtStatus}) and shown in hex; the\n * name is a courtesy, not the classification.\n */\nconst NTSTATUS_NAMES: ReadonlyMap<string, string> = new Map([\n  ['0xC0000005', 'STATUS_ACCESS_VIOLATION'],\n  ['0xC0000017', 'STATUS_NO_MEMORY'],\n  ['0xC000001D', 'STATUS_ILLEGAL_INSTRUCTION'],\n  ['0xC0000094', 'STATUS_INTEGER_DIVIDE_BY_ZERO'],\n  ['0xC00000FD', 'STATUS_STACK_OVERFLOW'],\n  ['0xC0000135', 'STATUS_DLL_NOT_FOUND'],\n  ['0xC000013A', 'STATUS_CONTROL_C_EXIT'],\n  ['0xC0000374', 'STATUS_HEAP_CORRUPTION'],\n  ['0xC0000409', 'STATUS_STACK_BUFFER_OVERRUN']\n]);\n\n/**\n * Characters held back from the Windows command-line budget when sizing an {@link ExecArgument} batch, to\n * cover expansions that happen INSIDE the command we spawn and are therefore invisible from here.\n *\n * A shimmed `<tool> <args\u2026>` invocation is not one `cmd.exe` command line but a chain of them: the\n * `.bin/<tool>.cmd` shim re-expands `%*` into a fresh `node \u2026 <tool>-cli.js <args\u2026>` line, and each hop\n * re-quotes what it forwards. Every one of those lines is subject to the same 8191 limit, and every one is\n * longer than the line we assembled \u2014 but by how much is the child's business, not ours, so no formula can\n * be right. Only the deliberate slack below can.\n *\n * `2048` is roughly double the overhead measured when this was found, back when every tool was\n * additionally fronted by `npx` and so paid one more re-expansion hop than it does now. Over a repository's\n * 187 markdown paths, a `markdownlint-cli2 \u2026` line **assembled at 7051 chars** \u2014 1140 under the limit \u2014\n * still died with `The command line is too long.`; the same payload split in two runs clean. Note the tool:\n * this is not specific to `linkinator`, it is the shape of every shim-fronted invocation.\n *\n * Over-reserving costs one extra sequential invocation of a command that was already going to be batched;\n * under-reserving costs a lint failure that names nothing wrong with the content. Raise it, never lower it,\n * if the symptom returns.\n */\nconst WINDOWS_CHILD_EXPANSION_RESERVE = 2048;\n\n/**\n * Parameters for {@link describeExitFailure}.\n */\ninterface DescribeExitFailureParams {\n  /**\n   * The command that was executed.\n   */\n  readonly command: string;\n\n  /**\n   * The exit code the child reported, or `null` when it did not exit on its own.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * The signal that terminated the child, if any.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * Whether the child's stdio was attached to the terminal, so nothing was captured.\n   */\n  readonly isInteractive: boolean;\n\n  /**\n   * Whether the child's output was suppressed, so the user has not seen it.\n   */\n  readonly isQuiet: boolean;\n\n  /**\n   * The captured standard error.\n   */\n  readonly stderr: string;\n\n  /**\n   * The captured standard output.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Parameters for {@link executeBatches}.\n */\ninterface ExecuteBatchesParams {\n  /**\n   * The base command without batched args.\n   */\n  readonly baseCommand: string;\n\n  /**\n   * The batches of args.\n   */\n  readonly batches: string[][];\n\n  /**\n   * The exec options.\n   */\n  readonly options: ExecOptions;\n}\n\n/**\n * Parameters for {@link spawnViaShell}.\n */\ninterface SpawnViaShellParams {\n  /**\n   * The command string to execute.\n   */\n  readonly command: string;\n\n  /**\n   * The working directory.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables merged over the inherited child environment.\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child's stdio to the terminal instead of piping it.\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * The original argument array (if available).\n   */\n  readonly rawArguments?: string[];\n}\n\n/**\n * Builds a command-line string from an argument array, quoted for the shell that\n * {@link spawnViaShell} will route through on the current platform.\n *\n * On Windows the command is executed via `cmd.exe`, so it uses the\n * `CommandLineToArgvW` convention ({@link toCommandLine}); {@link spawnViaShell}\n * then applies {@link cmdEscapeCommandLine} on top for `cmd.exe` metacharacters.\n * Elsewhere the command is executed via `sh -c`, so it uses POSIX single-quote\n * quoting ({@link toPosixCommandLine}) and needs no further escaping.\n *\n * The platform branch here MUST stay in sync with the one in {@link spawnViaShell}.\n *\n * @param $arguments - The argument array to quote and join.\n * @returns The quoted command-line string for the current platform's shell.\n */\nfunction buildCommandLine($arguments: string[]): string {\n  return process.platform === 'win32' ? toCommandLine($arguments) : toPosixCommandLine($arguments);\n}\n\n/**\n * Builds the message a failed command rejects with, saying not only THAT it failed but HOW.\n *\n * The message used to be `Command failed with exit code <n>` plus stderr, whatever the code. So a child that\n * crashed before writing a byte and a linter that found real problems read the same, differing only in a\n * number nobody reads as a status: a Windows access violation arrives as `exit code 3221225477` with nothing\n * after it, and whoever reads it goes looking for a finding that does not exist. This is the last point that\n * can tell the two apart \u2014 the `.cmd` shim is spawned directly, so the child's raw code is visible here, while\n * an `npm run` layer further out is known to launder it into a plain `1`.\n *\n * Two signals are read, and their conjunction is what earns the word \"crashed\": the termination was abnormal\n * (an NTSTATUS error code, or a signal), and neither stream carried anything. A tool failing on its own terms\n * says something; a child that died mid-instruction does not. The CAUSE of such a crash is not this\n * function's business, so the message only names it and says what to do.\n *\n * The `Command failed with exit code <n>` prefix is kept, so a caller matching on it still matches.\n *\n * @param params - The parameters describing the failed execution.\n * @returns The failure message.\n */\nfunction describeExitFailure(params: DescribeExitFailureParams): string {\n  const { command, exitCode, exitSignal, isInteractive, isQuiet, stderr, stdout } = params;\n  const ntStatus = toNtStatus(exitCode);\n\n  let status = `exit code ${exitCode === null ? '(null)' : String(exitCode)}`;\n  let abnormalReason: null | string = null;\n  if (ntStatus !== null) {\n    const HEX_RADIX = 16;\n    const hex = `0x${ntStatus.toString(HEX_RADIX).toUpperCase()}`;\n    const name = NTSTATUS_NAMES.get(hex);\n    status += ` (NTSTATUS ${name ? `${hex} ${name}` : hex})`;\n    abnormalReason = name === 'STATUS_CONTROL_C_EXIT' ? 'was interrupted' : 'crashed';\n  } else if (exitSignal !== null) {\n    status += `, terminated by signal ${exitSignal}`;\n    abnormalReason = `was killed by ${exitSignal}`;\n  }\n\n  const lines = [`Command failed with ${status}`, `Command: ${truncateCommand(command)}`];\n\n  if (abnormalReason !== null) {\n    lines.push(\n      !isInteractive && stdout === '' && stderr === ''\n        ? `The child process ${abnormalReason} before writing anything to stdout or stderr. This is not a failure the tool reported (not a lint finding, not a type error): re-run the command.`\n        : `The child process ${abnormalReason} rather than exiting on its own, so any output it wrote may be incomplete.`\n    );\n  }\n\n  if (stdout !== '') {\n    lines.push(isQuiet ? `stdout:\\n${stdout}` : `stdout: ${String(stdout.split('\\n').length)} line(s), printed above.`);\n  }\n\n  if (stderr !== '') {\n    lines.push(`stderr:\\n${stderr}`);\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Executes batched commands sequentially and concatenates their output.\n *\n * `execString` returns a `string` or an {@link ExecResult} depending on `options.shouldIncludeDetails`, so\n * both shapes are unpacked \u2014 reading only the `string` one silently threw away every batch's output in\n * exactly the mode that asked for it.\n *\n * A batch that exits non-zero normally rejects; it only reaches here when `shouldIgnoreExitCode` asked for\n * it to be reported instead. The first such failure is what the aggregate reports, so splitting a command\n * into batches cannot turn a failure into a success \u2014 except that an abnormal termination (a crash, a\n * signal) in a later batch outranks an ordinary failure in an earlier one. Otherwise a crash in batch 2 after\n * real findings in batch 1 would aggregate to the findings' exit code, and a caller classifying the result\n * would never learn that part of the input was not checked at all.\n *\n * Silent batches contribute nothing to the joined output. `execString` already trims each result's trailing\n * newline, so joining empty ones back in would reintroduce exactly the blank-line noise it removed \u2014 a\n * command that printed nothing must aggregate to `''`, not to a run of newlines.\n *\n * @param params - The parameters for the batched execution.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(params: ExecuteBatchesParams): Promise<ExecResult | string> {\n  const { baseCommand, batches, options } = params;\n  const stdoutParts: string[] = [];\n  const stderrParts: string[] = [];\n  let failure: ExecResult | null = null;\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${buildCommandLine(batch)}`;\n    const result = await execString({\n      command: batchCommand,\n      options\n    });\n    if (typeof result === 'string') {\n      pushIfNotEmpty(stdoutParts, result);\n      continue;\n    }\n\n    pushIfNotEmpty(stdoutParts, result.stdout);\n    pushIfNotEmpty(stderrParts, result.stderr);\n    if (result.exitCode !== 0 && (failure === null || (!isAbnormalTermination(failure) && isAbnormalTermination(result)))) {\n      failure = result;\n    }\n  }\n\n  return options.shouldIncludeDetails\n    ? {\n      // Not `failure?.exitCode ?? 0`: a batch killed by a signal has a `null` code, which `??` would report as success.\n      exitCode: failure === null ? 0 : failure.exitCode,\n      exitSignal: failure?.exitSignal ?? null,\n      stderr: stderrParts.join('\\n'),\n      stdout: stdoutParts.join('\\n')\n    }\n    : stdoutParts.join('\\n');\n}\n\n/**\n * Default environment variables passed to child processes, resolved at spawn time.\n *\n * Deliberately not a module-level constant. `.env` is loaded by `loadEnvFileIfExists` from inside\n * `wrapCliTask`, and ESM evaluates every import before the entry module's first statement \u2014 so a\n * snapshot taken here would always predate the load, and every spawned child would run without the\n * repo's own `.env`. Nothing surfaced that while Vitest 3 copied the `.env` it loaded into the\n * worker's `process.env`; Vitest 4 writes those to `import.meta.env` only, leaving this the sole\n * path and an empty one.\n *\n * @returns The environment to pass to spawned child processes, reflecting `process.env` as it stands now.\n */\nfunction getChildEnv(): NodeJS.ProcessEnv {\n  return buildChildEnv(process.env, process.allowedNodeEnvironmentFlags);\n}\n\n/**\n * Returns the length of the command line as the operating system will actually see it, which on Windows is\n * NOT the length of the string passed in.\n *\n * {@link spawnViaShell} routes the command through `cmd.exe`, and two things are spent between here and\n * there, neither of them visible in the assembled command:\n * - Node's `spawn(\u2026, { shell: true })` wraps it as `<comspec> /d /s /c \"<command>\"`.\n * - {@link cmdEscapeCommandLine} `^`-escapes every one of `cmd.exe`'s metacharacters, which on a list of\n *   quoted paths is a few percent of the whole (measured: +236 chars on a 7216-char invocation).\n *\n * Both are ours to compute, so they are computed rather than guessed. What is NOT computable from here is\n * what the spawned command does to its own arguments \u2014 see {@link WINDOWS_CHILD_EXPANSION_RESERVE}.\n *\n * The platform branch here MUST stay in sync with the one in {@link spawnViaShell}.\n *\n * @param commandLine - The assembled command line, before any shell wrapping.\n * @returns The length in characters of what reaches the operating system.\n */\nfunction getEffectiveCommandLineLength(commandLine: string): number {\n  if (process.platform !== 'win32') {\n    return commandLine.length;\n  }\n\n  const comspec = process.env['comspec'] ?? 'cmd.exe';\n  const CMD_WRAPPER = ' /d /s /c \"\"';\n  return comspec.length + CMD_WRAPPER.length + commandEscapeCommandLine(commandLine).length;\n}\n\n/**\n * Returns the max command line length to size an {@link ExecArgument} batch against \u2014 the platform maximum\n * less {@link WINDOWS_CHILD_EXPANSION_RESERVE}.\n *\n * Deliberately more conservative than {@link getMaxCommandLength}, because the two answer different\n * questions. Exceeding the plain-command limit is a hard failure the caller cannot avoid, so that check\n * stays exact. Exceeding the batching limit only costs one extra invocation, so that check may \u2014 and\n * should \u2014 leave room to spare.\n *\n * @returns The max length in characters available to a single batch.\n */\nfunction getMaxBatchCommandLength(): number {\n  return getMaxCommandLength() - (process.platform === 'win32' ? WINDOWS_CHILD_EXPANSION_RESERVE : 0);\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131_072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArgument}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOptions): Promise<ExecResult | string> | undefined {\n  const execArguments = parts.filter(isExecArgument);\n  if (execArguments.length === 0) {\n    return undefined;\n  }\n  if (execArguments.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArguments is allowed per command'));\n  }\n\n  const execArgument = execArguments[0];\n  assertNonNullable(execArgument);\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = buildCommandLine(staticParts);\n  const maxCommandLength = getMaxBatchCommandLength();\n\n  // Try expanding all args inline\n  const fullCommand = `${baseCommand} ${buildCommandLine([...execArgument.batchedArguments])}`;\n  if (getEffectiveCommandLineLength(fullCommand) <= maxCommandLength) {\n    return execString({\n      command: fullCommand,\n      options\n    });\n  }\n\n  // Split into batches\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const argument of execArgument.batchedArguments) {\n    const tentative = `${baseCommand} ${buildCommandLine([...currentBatch, argument])}`;\n    if (getEffectiveCommandLineLength(tentative) > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(argument.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max batch command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [argument];\n    } else {\n      currentBatch.push(argument);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArguments is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches({\n    baseCommand,\n    batches,\n    options\n  });\n}\n\n/**\n * Checks whether a result records an abnormal termination \u2014 an NTSTATUS error code or a signal \u2014 rather than\n * the child exiting on its own with a code of its choosing.\n *\n * @param result - The result to check.\n * @returns Whether the child terminated abnormally.\n */\nfunction isAbnormalTermination(result: ExecResult): boolean {\n  return result.exitSignal !== null || toNtStatus(result.exitCode) !== null;\n}\n\n/**\n * Checks if a command part is an {@link ExecArgument}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArgument(part: CommandPart): part is ExecArgument {\n  return typeof part === 'object' && 'batchedArguments' in part;\n}\n\n/**\n * Appends a batch's captured output to the accumulator, skipping an empty one so the eventual join does not\n * fabricate blank lines for batches that printed nothing.\n *\n * @param accumulator - The collected outputs so far.\n * @param output - The output of a single batch.\n */\nfunction pushIfNotEmpty(accumulator: string[], output: string): void {\n  if (output !== '') {\n    accumulator.push(output);\n  }\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param params - The parameters for spawning the child process.\n * @returns The spawned child process.\n */\nfunction spawnViaShell(params: SpawnViaShellParams): ChildProcess {\n  const { command, cwd, env: extraEnv, isInteractive = false, rawArguments } = params;\n  const env: NodeJS.ProcessEnv = {\n    ...getChildEnv(),\n    ...extraEnv\n  };\n  const stdio: 'inherit' | 'pipe' = isInteractive ? 'inherit' : 'pipe';\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArguments) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...$arguments] = rawArguments;\n    assertNonNullable(program, 'Command array must not be empty');\n    return spawn(program, $arguments, {\n      cwd,\n      env,\n      stdio\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? commandEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env,\n    shell: true,\n    stdio\n  });\n}\n\n/**\n * Reads an exit code as a Windows NTSTATUS error, if it is one.\n *\n * A crashed process on Windows exits with the NTSTATUS of the exception that killed it, and a `.cmd` shim\n * forwards its inner process's code, so a crashed `node.exe` arrives here intact \u2014 `0xC0000005` as\n * `3221225477`. The test is the NTSTATUS layout rather than a bare `>= 0xC0000000`: the top two bits are the\n * error severity and the next one is the customer flag, which must be clear. That keeps out two codes a bare\n * range would misread \u2014 `process.exit(-1)`, which Windows reports as `0xFFFFFFFF`, and the `0xE06D7363` of an\n * unhandled C++ exception, which is a crash but not an NTSTATUS. A signed reading of the same code is accepted\n * too. No linter, compiler or test runner returns a code of this shape as a count of findings.\n *\n * @param exitCode - The exit code the child reported.\n * @returns The code as an unsigned NTSTATUS, or `null` when it is not an NTSTATUS error.\n */\nfunction toNtStatus(exitCode: null | number): null | number {\n  if (exitCode === null || !Number.isSafeInteger(exitCode)) {\n    return null;\n  }\n\n  // Error severity (top two bits set) with the customer bit clear is exactly the range [0xC0000000, 0xE0000000).\n  const NTSTATUS_ERROR_START = 0xC0_00_00_00;\n  const NTSTATUS_ERROR_END = 0xE0_00_00_00;\n  const UINT32_RANGE = 0x1_00_00_00_00;\n  const unsigned = exitCode < 0 ? exitCode + UINT32_RANGE : exitCode;\n  return unsigned >= NTSTATUS_ERROR_START && unsigned < NTSTATUS_ERROR_END ? unsigned : null;\n}\n\n/**\n * Shortens a command for quoting in an error message, keeping its start, which names the program.\n *\n * @param command - The command to shorten.\n * @returns The command, cut to {@link MAX_COMMAND_LENGTH_IN_MESSAGE} characters plus an ellipsis when longer.\n */\nfunction truncateCommand(command: string): string {\n  return command.length > MAX_COMMAND_LENGTH_IN_MESSAGE ? `${command.slice(0, MAX_COMMAND_LENGTH_IN_MESSAGE)}\u2026` : command;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength", "effectiveLength", "process", "commandEscapeCommandLine"]
}
