cross-spawn-esm 0.0.1

package/LICENSE

@@ -0,0 +1,104 @@
+MIT License
+
+Copyright (c) 2026 Timur Bikmuhametov <https://github.com/Timbic>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+# Attribution
+
+This project contains modified code from the following open source projects. 
+I am grateful to the authors and contributors of these projects.
+
+## cross-spawn
+
+Github: <https://github.com/moxystudio/node-cross-spawn>
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+## path-key
+
+Github: <https://github.com/sindresorhus/path-key>
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+## shebang-command
+
+Github: <https://github.com/kevva/shebang-command>
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

package/README.md

@@ -0,0 +1,168 @@
+# cross-spawn-esm
+
+<p>
+  <a href="https://www.npmjs.com/package/cross-spawn-esm"><img src="https://img.shields.io/npm/v/cross-spawn-esm.svg?logo=nodedotjs" alt="npm package"></a>
+  <a href="https://github.com/Timbic/cross-spawn-esm"><img src="https://img.shields.io/badge/Github-gray.svg?logo=github" alt="github repo"></a>
+</p>
+
+> **Note:** This package is still in development and not recommended for production use yet. However, testing it in your projects is greatly
+> appreciated. If you find any errors, please open an issue - PRs are also welcomed!
+
+This is a "fork" of [cross-spawn](https://www.npmjs.com/package/cross-spawn?activeTab=readme) ( a cross-platform solution to node's spawn
+and spawnSync ) which ports its codebase to modern ESM and TypeScript.
+
+This package isn't a 100% drop-in replacement for **cross-spawn** ( the API differs slightly ) but it tries to behave the same as the
+original package. Please refer to the [Migration guide](#migration-guide) for further explanation.
+
+## Installation
+
+With NPM:
+
+```bash
+npm install cross-spawn-esm
+```
+
+With Yarn:
+
+```bash
+yarn add cross-spawn-esm
+```
+
+With PNPM:
+
+```bash
+pnpm add cross-spawn-esm
+```
+
+With Bun:
+
+```bash
+bun add cross-spawn-esm
+```
+
+With Deno:
+
+```bash
+deno add cross-spawn-esm
+```
+
+## Usage
+
+Use it exactly the same way as node's `spawn` and `spawnSync` ( a drop-in replacement for them ) with the same arguments and options. There
+is **no default export**; always use named imports.
+
+```ts
+import { spawn, spawnSync } from "cross-spawn-esm";
+
+// Spawn NPM asynchronously
+const child = spawn("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+
+// Spawn NPM synchronously
+const result = spawnSync("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+```
+
+## Benefits
+
+- Overall smaller bundle size
+- Tree-shaking friendly
+- Fewer dependencies
+- No need for an additional types package (`@types/cross-spawn`)
+- Modern codebase and active maintenance
+- Better documentation
+
+## Migration guide
+
+Porting from `cross-spawn` to `cross-spawn-esm` is mostly a matter of changing how you import the package and how you call its sync API.
+
+### 1. Install
+
+Uninstall `cross-spawn` (and `@types/cross-spawn` if you had it) and install `cross-spawn-esm`:
+
+```bash
+npm remove cross-spawn @types/cross-spawn
+npm install cross-spawn-esm
+```
+
+### 2. Update imports & sync calls
+
+**Before**:
+
+```js
+import spawn from "cross-spawn";
+
+const child = spawn("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+const result = spawn.sync("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+```
+
+**After**:
+
+```ts
+import { spawn, spawnSync } from "cross-spawn-esm";
+
+const child = spawn("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+const result = spawnSync("npm", ["list", "-g", "-depth", "0"], { stdio: "inherit" });
+```
+
+### 3. Internal utilities
+
+If you were relying on the hidden internals:
+
+**Before**: `spawn._parse(...)`, `spawn._enoent.verifyENOENT(...)`
+
+**After**:
+
+```ts
+import { _parse, _enoent } from "cross-spawn-esm";
+```
+
+##### Changes:
+
+- `_enoent.verifyENOENT(status, parsed, syscall)` now takes an explicit `syscall` argument (`"spawn"` or `"spawnSync"`), where the original
+  shipped two separate functions (`verifyENOENT` / `verifyENOENTSync`).
+- `_enoent.notFoundError(...)` now returns a valid **NodeJS.ErrnoException**.
+- `_parse` now contains both `parse` and `parseNonShell` functions:
+
+> **Before**: const parsed = _parse(...)
+>
+> **After**: const parsed = _parse.parse(...)
+
+- New `_utils` object exposes all the lower-level helpers (`shebangCommand`, `readShebang`, `detectShebang`, `enterCwd`, `resolveCommand`,
+  `resolveCommandAttempt`, `escapeLineBreaks`, `escapeMetaChars`, `escapeCommand`, `escapeArgument`, `pathKey`) If you were relying on the
+  original **cross-spawn** dependencies ( **path-key** and **shebang-command** ), their improved versions can be found in `_utils`.
+
+### 4. TypeScript
+
+`cross-spawn-esm` ships its own type definitions, so the third-party `@types/cross-spawn` package is no longer needed.
+
+### 5. Behavior notes
+
+Beyond the API surface, a few implementation details intentionally differ:
+
+- **`original.args` is an independent snapshot**: `parse` clones the args and gives `original.args` its own copy, so shebang rewiring and
+  `cmd.exe` escaping never mutate it.
+- **Broader shebang support**: Shebang detection on Windows reads the shebang of the resolved script and rewires the command to its
+  interpreter. `#!/usr/bin/env <program>` is resolved from `PATH` and spawned directly. Any other shebang (`#!/bin/sh`, `#!/bin/bash -e`) is
+  reduced to the interpreter's basename (plus its single argument, if any) and falls back to the `cmd.exe` wrapper, which works when that
+  interpreter is on `PATH`.
+
+The following behaviors are intentionally kept identical to `cross-spawn`:
+
+- When `options.shell` is used, parsing, escaping, and shebang enhancements are disabled — matching both the original and Node.js behavior.
+- Windows-only ENOENT detection: when the process exits with code `1` and the command could not be resolved, an `error` event (async) or
+  `result.error` (sync) is produced.
+
+### API comparison
+
+| Feature          | cross-spawn              | cross-spawn-esm          |
+| ---------------- | ------------------------ | ------------------------ |
+| Module format    | CommonJS                 | ESM (`"type": "module"`) |
+| Async spawn      | `spawn` (default export) | `spawn` (named export)   |
+| Sync spawn       | `spawn.sync`             | `spawnSync`              |
+| Parse internals  | `spawn._parse`           | `_parse`                 |
+| ENOENT internals | `spawn._enoent`          | `_enoent`                |
+| Other internals  | not exposed              | `_utils`                 |
+| TypeScript types | `@types/cross-spawn`     | built-in                 |
+
+## License
+
+Released under the [MIT License](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import { ChildProcess, SpawnOptions, SpawnSyncOptions, SpawnSyncReturns } from "node:child_process";
+import { NonSharedBuffer } from "node:buffer";
+//#region src/utils/resolve-command.d.ts
+interface ParsedCommand {
+  command: string;
+  args: Array<string>;
+  options: SpawnOptions & {
+    _forceShell?: boolean;
+  };
+  file?: string | null;
+  original: {
+    command: string;
+    args: ReadonlyArray<string>;
+  };
+}
+/**
+ * Change the process working directory to `cwd`.
+ */
+declare function enterCwd(cwd?: string): boolean;
+/**
+ * Resolve `parsed.command` to an absolute file path by searching the
+ * environment's `PATH`, using the custom `cwd` when one is set.
+ */
+declare function resolveCommandAttempt(parsed: ParsedCommand, withoutPathExt?: boolean): string | null;
+/**
+ * Resolve `parsed.command` to an absolute file path by searching the
+ * environment's `PATH`, returning `null` when it cannot be found.
+ *
+ * @example
+ * resolveCommand({ command: "node", args: [], options: {}, original: {...} });
+ * //=> "C:\\Program Files\\nodejs\\node.exe"
+ *
+ * resolveCommand({ command: "no-such-tool", ... });
+ * //=> null
+ */
+declare function resolveCommand(parsed: ParsedCommand): string | null;
+//#endregion
+//#region src/enoent.d.ts
+/**
+ * Builds an ENOENT error for a command that could not be found. Creates
+ * an error whose shape matches what Node's own `spawn`/`spawnSync` would produce
+ * when it fails to locate the command file. This makes the error interchangeable
+ * with a real ENOENT from Node.
+ */
+declare function notFoundError(original: ParsedCommand["original"], syscall: "spawn" | "spawnSync"): NodeJS.ErrnoException;
+/**
+ * Detects the Windows-only fake ENOENT that `cmd.exe` produces. On POSIX or
+ * for any other exit code the error is not applicable, so `null` is returned.
+ */
+declare function verifyENOENT(status: number | null, parsed: ParsedCommand, syscall: "spawn" | "spawnSync"): NodeJS.ErrnoException | null;
+/**
+ * Hooks into a `ChildProcess` `exit` event so that a missing command is
+ * surfaced as an `error` event instead of silently exiting with code `1`.
+ *
+ * On POSIX, a missing command already produces a real ENOENT from libuv and
+ * this hook is not needed. On Windows, the command is typically wrapped by
+ * `cmd.exe`, which reports an unrecognized command as exit status `1`. This
+ * monkey-patches `cp.emit` to intercept that case and emit an `error` event
+ * with the proper ENOENT, so Node-style error handling works unchanged.
+ */
+declare function hookChildProcess(cp: ChildProcess, parsed: ParsedCommand): void;
+//#endregion
+//#region src/utils/shebang.d.ts
+/**
+ * Parses a shebang line into the interpreter command to run the script.
+ * The interpreter path is reduced to its last segment (like `basename`, e.g. `/usr/bin/env` -> `env`).
+ * Returns the bare binary, or `binary <argument>` when an argument is present.
+ * The special case `env` returns only its argument (e.g. `/usr/bin/env node` -> `node`), because `env` would otherwise run with no program.
+ *
+ * @example
+ * shebangCommand("#!/usr/bin/env node");
+ * //=> "node"
+ *
+ * shebangCommand("#!/bin/bash -e");
+ * //=> "bash -e"
+ *
+ * shebangCommand("not a shebang");
+ * //=> null
+ */
+declare function shebangCommand(string: string): string | null;
+/**
+ * Reads the shebang from a script file's contents.
+ * Returns `null` if the file cannot be opened/read or if `shebangCommand` finds no shebang
+ *
+ * @example
+ * readShebang("/usr/local/bin/script");
+ * //=> "node"   (when the file starts with "#!/usr/bin/env node")
+ * //=> null     (when the file has no shebang or cannot be read)
+ */
+declare function readShebang(file: string): string | null;
+/**
+ * Detects the shebang of the resolved `parsed.command` file and rewire
+ * `parsed` to run the script through its interpreter. When the file has a shebang,
+ * the script path is prepended to `parsed.args` and `parsed.command` becomes
+ * the interpreter; the interpreter path is then resolved and returned.
+ * Otherwise the resolved script path is returned, or `null` when the command could not be found.
+ *
+ * @example
+ * detectShebang({ command: "my-script", args: [], file: undefined, ... });
+ * // Rewired: command = "node", args = ["C:\\dir\\my-script"]
+ * //=> "C:\\Program Files\\nodejs\\node.exe"
+ */
+declare function detectShebang(parsed: ParsedCommand): string | null;
+//#endregion
+//#region src/utils/escapes.d.ts
+/**
+ * Remove line breaks (`\r` and `\n`) from the given string. Without this, an argument containing a newline could terminate the enclosing
+ * command early and inject an arbitrary second command into the shell.
+ *
+ * @example
+ * // Without escaping, cmd.exe would run two commands:
+ * //   node -e "console.log('ok')
+ * //   calc.exe"
+ * escapeLineBreaks("console.log('ok')\ncalc.exe");
+ * //=> "console.log('ok')calc.exe"
+ */
+declare function escapeLineBreaks(arg: string): string;
+/**
+ * Escape Windows `cmd.exe` shell meta characters (``/([()\][%!^"`<>&|;, *?])/g``) by prefixing each with `^`. Without this, a meta character in a command or argument would be interpreted
+ * by the shell, breaking the command or enabling arbitrary command execution.
+ *
+ * @example
+ * // Without escaping, cmd.exe would treat the spaces and `&` as separators:
+ * escapeMetaChars('notepad "a & b.txt"');
+ * //=> 'notepad^ ^"a^ ^&^ b.txt^"'
+ */
+declare function escapeMetaChars(arg: string): string;
+/**
+ * Escapes a command name for safe use in a Windows `cmd.exe` invocation.
+ */
+declare function escapeCommand(arg: string): string;
+/**
+ * Escape a single argument into a fully self-contained token for a Windows
+ * `cmd.exe` command line.
+ */
+declare function escapeArgument(arg: unknown, doubleEscapeMetaChars?: boolean): string;
+//#endregion
+//#region src/utils/path-key.d.ts
+interface PathKeyOptions {
+  /**
+   * Use a custom environment variables object.
+   * @default process.env
+   *
+   * @see https://nodejs.org/api/process.html#process_process_env
+   */
+  env?: Record<string, string | undefined>;
+  /**
+   * Get the PATH key for a specific platform.
+   * @default process.platform
+   *
+   * @see https://nodejs.org/api/process.html#process_process_platform
+   */
+  platform?: NodeJS.Platform;
+}
+/**
+ * Get the [PATH] environment variable key cross-platform.
+ * @see https://en.wikipedia.org/wiki/PATH_(variable)
+ *
+ * @example
+ * const key = pathKey();
+ * //=> 'PATH'
+ *
+ * const PATH = process.env[key];
+ * //=> '/usr/local/bin:/usr/bin:/bin'
+ */
+declare function pathKey({ env, platform }: PathKeyOptions): string;
+//#endregion
+//#region src/parse.d.ts
+/**
+ * Prepares a parsed command for spawning without a shell.
+ * On POSIX the command is returned as-is, since the native `spawn` handles it.
+ * On Windows the command is resolved first: a shebang script is rewired to run
+ * through its interpreter. Unless the resolved command is a plain `.exe`,
+ * the command is then wrapped for `cmd.exe`: the command and arguments are
+ * escaped and reassembled into a `cmd /d /s /c "..."` invocation with
+ * `windowsVerbatimArguments` set. The result is a `parsed` whose `command`/`args` are directly spawnable.
+ */
+declare function parseNonShell(parsed: ParsedCommand): ParsedCommand;
+/**
+ * Turns a `spawn`/`spawnSync` call signature into a `ParsedCommand`.
+ * Accepts the same overload as Node: when the second argument is an options
+ * object instead of an args array, it is treated as `options`. The args and
+ * options are cloned so the caller's objects are never mutated, and parsing is
+ * delegated to `parseNonShell` unless `options.shell` is set (in which case
+ * the command is passed through untouched, like Node).
+ */
+declare function parse(command: string, args: ReadonlyArray<string> | SpawnOptions, options: SpawnOptions): ParsedCommand;
+//#endregion
+//#region src/index.d.ts
+/**
+ * A cross-platform drop-in replacement for `child_process.spawn()`.
+ *
+ * On POSIX, arguments are forwarded to the native `spawn` unchanged. On
+ * Windows the command and its arguments are rewritten so that the correct
+ * interpreter is invoked for shebang scripts, special characters and
+ * whitespace in arguments are safely escaped for `cmd.exe`, and a missing
+ * command (which `cmd.exe` signals with exit status `1` instead of a real
+ * `ENOENT`) is surfaced as an `error` event, matching what Node produces on POSIX.
+ */
+export declare function spawn(command: string, options?: SpawnOptions): ChildProcess;
+export declare function spawn(command: string, args?: ReadonlyArray<string>, options?: SpawnOptions): ChildProcess;
+/**
+ * A cross-platform drop-in replacement for `child_process.spawnSync()`.
+ *
+ * On POSIX, arguments are forwarded to the native `spawnSync` unchanged. On
+ * Windows the same shebang resolution, argument escaping, and ENOENT
+ * detection applied by {@link spawn} are performed synchronously, so the
+ * returned `SpawnSyncResult` carries a proper `error` when the command does not exist.
+ */
+export declare function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | NonSharedBuffer>;
+export declare function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | NonSharedBuffer>;
+export declare const _parse: {
+  parseNonShell: typeof parseNonShell;
+  parse: typeof parse;
+};
+export declare const _enoent: {
+  notFoundError: typeof notFoundError;
+  verifyENOENT: typeof verifyENOENT;
+  hookChildProcess: typeof hookChildProcess;
+};
+export declare const _utils: {
+  shebangCommand: typeof shebangCommand;
+  readShebang: typeof readShebang;
+  detectShebang: typeof detectShebang;
+  enterCwd: typeof enterCwd;
+  resolveCommand: typeof resolveCommand;
+  resolveCommandAttempt: typeof resolveCommandAttempt;
+  escapeLineBreaks: typeof escapeLineBreaks;
+  escapeMetaChars: typeof escapeMetaChars;
+  escapeArgument: typeof escapeArgument;
+  escapeCommand: typeof escapeCommand;
+  pathKey: typeof pathKey;
+};
+//#endregion
+export type { ParsedCommand, PathKeyOptions };

package/dist/index.js

@@ -0,0 +1,208 @@
+import cp from "node:child_process";
+import path from "node:path";
+import which from "which";
+import fs from "node:fs";
+//#region src/utils/constants.ts
+const _cwd = process.cwd();
+const _env = process.env;
+const _platform = process.platform;
+const isWin = _platform === "win32";
+const shebangRegExp = /^#!(.*)/;
+const lineBreaksRegExp = /[\r\n]+/g;
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+const executableRegExp = /\.(?:exe)$/i;
+const cmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+//#endregion
+//#region src/utils/path-key.ts
+function pathKey({ env = _env, platform = _platform }) {
+	return platform === "win32" ? Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") ?? "Path" : "PATH";
+}
+//#endregion
+//#region src/utils/resolve-command.ts
+function enterCwd(cwd) {
+	if (cwd == null) return false;
+	try {
+		process.chdir(cwd);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveCommandAttempt(parsed, withoutPathExt) {
+	const env = parsed.options.env ?? _env;
+	const cwd = parsed.options.cwd?.toString();
+	const switchCwd = process.chdir;
+	const switched = cwd != null && process.chdir !== void 0 && !switchCwd?.disabled && enterCwd(cwd);
+	try {
+		const resolved = which.sync(parsed.command, {
+			path: env[pathKey({ env })],
+			pathExt: withoutPathExt ? path.delimiter : void 0
+		});
+		return path.resolve(cwd ?? "", resolved);
+	} catch {
+		return null;
+	} finally {
+		if (switched) process.chdir(_cwd);
+	}
+}
+function resolveCommand(parsed) {
+	return resolveCommandAttempt(parsed) ?? resolveCommandAttempt(parsed, true);
+}
+//#endregion
+//#region src/enoent.ts
+function notFoundError(original, syscall) {
+	return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+		code: "ENOENT",
+		errno: -2,
+		syscall: `${syscall} ${original.command}`,
+		path: original.command,
+		spawnargs: original.args
+	});
+}
+function verifyENOENT(status, parsed, syscall) {
+	if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, syscall);
+	return null;
+}
+function hookChildProcess(cp, parsed) {
+	if (!isWin) return;
+	const originalEmit = cp.emit;
+	cp.emit = function(name, ...args) {
+		if (name === "exit") {
+			const status = args[0];
+			const err = verifyENOENT(status, parsed, "spawn");
+			if (err) return originalEmit.call(cp, "error", err);
+		}
+		return originalEmit.apply(cp, [name, ...args]);
+	};
+}
+//#endregion
+//#region src/utils/shebang.ts
+function shebangCommand(string) {
+	const match = string.match(shebangRegExp);
+	if (!match) return null;
+	const [path, argument] = match[0].replace(/^#!\s*/, "").split(/\s+/);
+	const binary = path.split("/").pop() ?? "";
+	return binary === "env" ? argument ?? binary : argument ? `${binary} ${argument}` : binary;
+}
+function readShebang(file) {
+	const buffer = Buffer.alloc(150);
+	try {
+		const fd = fs.openSync(file, "r");
+		fs.readSync(fd, buffer, 0, 150, 0);
+		fs.closeSync(fd);
+	} catch {
+		return null;
+	}
+	return shebangCommand(buffer.toString());
+}
+function detectShebang(parsed) {
+	parsed.file = resolveCommand(parsed);
+	if (parsed.file) {
+		const shebang = readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+	}
+	return parsed.file;
+}
+//#endregion
+//#region src/utils/escapes.ts
+function escapeLineBreaks(arg) {
+	return arg.replace(lineBreaksRegExp, "");
+}
+function escapeMetaChars(arg) {
+	return arg.replace(metaCharsRegExp, "^$1");
+}
+function escapeCommand(arg) {
+	return escapeMetaChars(escapeLineBreaks(arg));
+}
+function escapeArgument(arg, doubleEscapeMetaChars) {
+	let argStr = `${arg}`;
+	argStr = escapeLineBreaks(argStr);
+	argStr = argStr.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+	argStr = argStr.replace(/(?=(\\+?)?)\1$/, "$1$1");
+	argStr = escapeMetaChars(`"${argStr}"`);
+	if (doubleEscapeMetaChars) argStr = escapeMetaChars(argStr);
+	return argStr;
+}
+//#endregion
+//#region src/parse.ts
+function parseNonShell(parsed) {
+	if (!isWin) return parsed;
+	const commandFile = detectShebang(parsed) ?? "";
+	const needsShell = !executableRegExp.test(commandFile);
+	if (parsed.options._forceShell ?? needsShell) {
+		const needsDoubleEscapeMetaChars = cmdShimRegExp.test(commandFile);
+		parsed.command = path.normalize(parsed.command);
+		parsed.command = escapeCommand(parsed.command);
+		parsed.args = parsed.args.map((arg) => escapeArgument(arg, needsDoubleEscapeMetaChars));
+		parsed.args = [
+			"/d",
+			"/s",
+			"/c",
+			`"${[parsed.command].concat(parsed.args).join(" ")}"`
+		];
+		parsed.command = _env.comspec ?? "cmd.exe";
+		parsed.options.windowsVerbatimArguments = true;
+	}
+	return parsed;
+}
+function parse(command, args, options) {
+	if (!Array.isArray(args)) {
+		options = args;
+		args = [];
+	}
+	const argsCopy = args.slice(0);
+	options = Object.assign({}, options);
+	const parsed = {
+		command,
+		args: argsCopy,
+		options,
+		file: void 0,
+		original: {
+			command,
+			args: argsCopy.slice(0)
+		}
+	};
+	return options.shell ? parsed : parseNonShell(parsed);
+}
+//#endregion
+//#region src/index.ts
+function spawn(command, args = [], options = {}) {
+	const parsed = parse(command, args, options);
+	const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+	hookChildProcess(spawned, parsed);
+	return spawned;
+}
+function spawnSync(command, args = [], options = {}) {
+	const parsed = parse(command, args, options);
+	const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+	result.error = result.error ?? verifyENOENT(result.status, parsed, "spawnSync") ?? void 0;
+	return result;
+}
+const _parse = {
+	parseNonShell,
+	parse
+};
+const _enoent = {
+	notFoundError,
+	verifyENOENT,
+	hookChildProcess
+};
+const _utils = {
+	shebangCommand,
+	readShebang,
+	detectShebang,
+	enterCwd,
+	resolveCommand,
+	resolveCommandAttempt,
+	escapeLineBreaks,
+	escapeMetaChars,
+	escapeArgument,
+	escapeCommand,
+	pathKey
+};
+//#endregion
+export { _enoent, _parse, _utils, spawn, spawnSync };

package/package.json

@@ -0,0 +1,69 @@
+{
+	"name": "cross-spawn-esm",
+	"type": "module",
+	"version": "0.0.1",
+	"description": "ESM version of cross-spawn package",
+	"author": "Timur Bikmuhametov <tim.bic22@gmail.com>",
+	"license": "MIT",
+	"keywords": [
+		"cross-spawn",
+		"spawn",
+		"spawnSync",
+		"windows",
+		"cross-platform",
+		"path-ext",
+		"shebang",
+		"cmd",
+		"execute"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Timbic/cross-spawn-esm.git"
+	},
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"sideEffects": false,
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"dev": "tsdown --watch",
+		"build": "tsdown",
+		"fmt": "prettier --cache --write .",
+		"fmt:chk": "prettier --check .",
+		"lint": "eslint --cache",
+		"lint:fix": "eslint --cache --fix",
+		"typecheck": "tsc --noEmit",
+		"release": "bumpp",
+		"prepare": "husky"
+	},
+	"dependencies": {
+		"which": "7.0.0"
+	},
+	"devDependencies": {
+		"@timbic/eslint-config": "1.2.2",
+		"@timbic/prettier-config": "1.2.3",
+		"@types/node": "26.6.1",
+		"@types/which": "3.0.4",
+		"bumpp": "12.3.0",
+		"eslint": "10.10.0",
+		"husky": "9.1.7",
+		"lint-staged": "17.5.1",
+		"prettier": "3.9.6",
+		"tsdown": "0.23.0",
+		"typescript": "6.0.3"
+	},
+	"lint-staged": {
+		"*/**/*.{js,ts,md,json}": [
+			"pnpm fmt",
+			"pnpm lint:fix"
+		]
+	},
+	"packageManager": "pnpm@12.4.2"
+}