cross-spawn-cb 2.4.14 → 2.5.1

package/dist/cjs/shim/resolve.js

@@ -0,0 +1,78 @@
+/**
+ * Command resolution using which
+ * Simplified from cross-spawn v6.0.5
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveCommand", {
+    enumerable: true,
+    get: function() {
+        return resolveCommand;
+    }
+});
+var _envpathkey = /*#__PURE__*/ _interop_require_default(require("env-path-key"));
+var _path = /*#__PURE__*/ _interop_require_default(require("path"));
+var _which = /*#__PURE__*/ _interop_require_default(require("which"));
+var _constantsts = require("../constants.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var pathDelimiter = _constantsts.isWindows ? ';' : ':';
+var NODES = [
+    'node',
+    'node.exe',
+    'node.cmd'
+];
+function resolveCommandAttempt(parsed, withoutPathExt) {
+    var command = parsed.command;
+    var options = parsed.options;
+    var env = options.env || process.env;
+    var cwd = process.cwd();
+    var hasCustomCwd = options.cwd != null;
+    // Handle NODE/npm_node_execpath env vars for node commands
+    // This is needed because shebang detection may change the command to 'node'
+    // after the initial NODE env check in crossSpawn.ts has already passed
+    if (NODES.indexOf(_path.default.basename(command).toLowerCase()) >= 0) {
+        var nodeFromEnv = env.NODE || env.npm_node_execpath;
+        if (nodeFromEnv) {
+            return nodeFromEnv;
+        }
+    }
+    // If a custom cwd was specified, we need to change the process cwd
+    // because which will do stat calls but does not support a custom cwd
+    if (hasCustomCwd) {
+        try {
+            process.chdir(options.cwd);
+        } catch (_err) {
+        /* ignore */ }
+    }
+    var resolved = null;
+    var pathKey = (0, _envpathkey.default)({
+        env: options.env || process.env
+    }) || 'PATH';
+    try {
+        resolved = _which.default.sync(command, {
+            path: (options.env || process.env)[pathKey],
+            // On Windows: undefined uses PATHEXT, pathDelimiter bypasses it
+            // withoutPathExt fallback is needed to find files without extensions
+            pathExt: withoutPathExt ? pathDelimiter : undefined
+        });
+    } catch (_e) {
+    /* not found */ } finally{
+        if (hasCustomCwd) {
+            process.chdir(cwd);
+        }
+    }
+    // Ensure absolute path
+    if (resolved) {
+        resolved = _path.default.resolve(hasCustomCwd ? options.cwd : '', resolved);
+    }
+    return resolved;
+}
+function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/shim/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/resolve.ts"],"sourcesContent":["/**\n * Command resolution using which\n * Simplified from cross-spawn v6.0.5\n */\n\nimport envPathKey from 'env-path-key';\nimport path from 'path';\nimport which from 'which';\nimport { isWindows } from '../constants.ts';\nimport type { Parsed } from './types.ts';\n\nconst pathDelimiter = isWindows ? ';' : ':';\nconst NODES = ['node', 'node.exe', 'node.cmd'];\n\nfunction resolveCommandAttempt(parsed: Parsed, withoutPathExt?: boolean): string | null {\n  const command = parsed.command;\n  const options = parsed.options;\n  const env = options.env || process.env;\n  const cwd = process.cwd();\n  const hasCustomCwd = options.cwd != null;\n\n  // Handle NODE/npm_node_execpath env vars for node commands\n  // This is needed because shebang detection may change the command to 'node'\n  // after the initial NODE env check in crossSpawn.ts has already passed\n  if (NODES.indexOf(path.basename(command).toLowerCase()) >= 0) {\n    const nodeFromEnv = env.NODE || env.npm_node_execpath;\n    if (nodeFromEnv) {\n      return nodeFromEnv;\n    }\n  }\n\n  // If a custom cwd was specified, we need to change the process cwd\n  // because which will do stat calls but does not support a custom cwd\n  if (hasCustomCwd) {\n    try {\n      process.chdir(options.cwd as string);\n    } catch (_err) {\n      /* ignore */\n    }\n  }\n\n  let resolved: string | null = null;\n  const pathKey = envPathKey({ env: options.env || process.env }) || 'PATH';\n\n  try {\n    resolved = which.sync(command, {\n      path: (options.env || process.env)[pathKey],\n      // On Windows: undefined uses PATHEXT, pathDelimiter bypasses it\n      // withoutPathExt fallback is needed to find files without extensions\n      pathExt: withoutPathExt ? pathDelimiter : undefined,\n    });\n  } catch (_e) {\n    /* not found */\n  } finally {\n    if (hasCustomCwd) {\n      process.chdir(cwd);\n    }\n  }\n\n  // Ensure absolute path\n  if (resolved) {\n    resolved = path.resolve(hasCustomCwd ? (options.cwd as string) : '', resolved);\n  }\n\n  return resolved;\n}\n\n// Try twice: first with PATHEXT (finds .cmd/.bat/.exe), then without (finds extensionless files)\nexport function resolveCommand(parsed: Parsed): string | null {\n  return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);\n}\n"],"names":["resolveCommand","pathDelimiter","isWindows","NODES","resolveCommandAttempt","parsed","withoutPathExt","command","options","env","process","cwd","hasCustomCwd","indexOf","path","basename","toLowerCase","nodeFromEnv","NODE","npm_node_execpath","chdir","_err","resolved","pathKey","envPathKey","which","sync","pathExt","undefined","_e","resolve"],"mappings":"AAAA;;;CAGC;;;;+BAiEeA;;;eAAAA;;;iEA/DO;2DACN;4DACC;2BACQ;;;;;;AAG1B,IAAMC,gBAAgBC,sBAAS,GAAG,MAAM;AACxC,IAAMC,QAAQ;IAAC;IAAQ;IAAY;CAAW;AAE9C,SAASC,sBAAsBC,MAAc,EAAEC,cAAwB;IACrE,IAAMC,UAAUF,OAAOE,OAAO;IAC9B,IAAMC,UAAUH,OAAOG,OAAO;IAC9B,IAAMC,MAAMD,QAAQC,GAAG,IAAIC,QAAQD,GAAG;IACtC,IAAME,MAAMD,QAAQC,GAAG;IACvB,IAAMC,eAAeJ,QAAQG,GAAG,IAAI;IAEpC,2DAA2D;IAC3D,4EAA4E;IAC5E,uEAAuE;IACvE,IAAIR,MAAMU,OAAO,CAACC,aAAI,CAACC,QAAQ,CAACR,SAASS,WAAW,OAAO,GAAG;QAC5D,IAAMC,cAAcR,IAAIS,IAAI,IAAIT,IAAIU,iBAAiB;QACrD,IAAIF,aAAa;YACf,OAAOA;QACT;IACF;IAEA,mEAAmE;IACnE,qEAAqE;IACrE,IAAIL,cAAc;QAChB,IAAI;YACFF,QAAQU,KAAK,CAACZ,QAAQG,GAAG;QAC3B,EAAE,OAAOU,MAAM;QACb,UAAU,GACZ;IACF;IAEA,IAAIC,WAA0B;IAC9B,IAAMC,UAAUC,IAAAA,mBAAU,EAAC;QAAEf,KAAKD,QAAQC,GAAG,IAAIC,QAAQD,GAAG;IAAC,MAAM;IAEnE,IAAI;QACFa,WAAWG,cAAK,CAACC,IAAI,CAACnB,SAAS;YAC7BO,MAAM,AAACN,CAAAA,QAAQC,GAAG,IAAIC,QAAQD,GAAG,AAAD,CAAE,CAACc,QAAQ;YAC3C,gEAAgE;YAChE,qEAAqE;YACrEI,SAASrB,iBAAiBL,gBAAgB2B;QAC5C;IACF,EAAE,OAAOC,IAAI;IACX,aAAa,GACf,SAAU;QACR,IAAIjB,cAAc;YAChBF,QAAQU,KAAK,CAACT;QAChB;IACF;IAEA,uBAAuB;IACvB,IAAIW,UAAU;QACZA,WAAWR,aAAI,CAACgB,OAAO,CAAClB,eAAgBJ,QAAQG,GAAG,GAAc,IAAIW;IACvE;IAEA,OAAOA;AACT;AAGO,SAAStB,eAAeK,MAAc;IAC3C,OAAOD,sBAAsBC,WAAWD,sBAAsBC,QAAQ;AACxE"}

package/dist/cjs/shim/shebang.d.cts

@@ -0,0 +1,5 @@
+/**
+ * Shebang detection for cross-platform script execution
+ * Extracted from cross-spawn v6.0.5
+ */
+export declare function readShebang(command: string): string | null;

package/dist/cjs/shim/shebang.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shebang detection for cross-platform script execution
+ * Extracted from cross-spawn v6.0.5
+ */
+export declare function readShebang(command: string): string | null;

package/dist/cjs/shim/shebang.js

@@ -0,0 +1,43 @@
+/**
+ * Shebang detection for cross-platform script execution
+ * Extracted from cross-spawn v6.0.5
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "readShebang", {
+    enumerable: true,
+    get: function() {
+        return readShebang;
+    }
+});
+var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+var _compatts = require("../compat.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var shebangRegex = /^#!.*/;
+function parseShebang(str) {
+    var match = str.match(shebangRegex);
+    if (!match) return null;
+    var arr = match[0].replace(/#! ?/, '').split(' ');
+    var bin = arr[0].split('/').pop();
+    var arg = arr[1];
+    return bin === 'env' ? arg : bin + (arg ? " ".concat(arg) : '');
+}
+function readShebang(command) {
+    var size = 150;
+    var buffer = (0, _compatts.allocBuffer)(size);
+    var fd;
+    try {
+        fd = _fs.default.openSync(command, 'r');
+        _fs.default.readSync(fd, buffer, 0, size, 0);
+        _fs.default.closeSync(fd);
+    } catch (_e) {
+        return null;
+    }
+    return parseShebang(buffer.toString());
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/shim/shebang.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/shebang.ts"],"sourcesContent":["/**\n * Shebang detection for cross-platform script execution\n * Extracted from cross-spawn v6.0.5\n */\n\nimport fs from 'fs';\nimport { allocBuffer } from '../compat.ts';\n\nconst shebangRegex = /^#!.*/;\n\nfunction parseShebang(str: string): string | null {\n  const match = str.match(shebangRegex);\n  if (!match) return null;\n\n  const arr = match[0].replace(/#! ?/, '').split(' ');\n  const bin = arr[0].split('/').pop();\n  const arg = arr[1];\n\n  return bin === 'env' ? arg : bin + (arg ? ` ${arg}` : '');\n}\n\nexport function readShebang(command: string): string | null {\n  const size = 150;\n  const buffer = allocBuffer(size);\n\n  let fd: number | undefined;\n  try {\n    fd = fs.openSync(command, 'r');\n    fs.readSync(fd, buffer, 0, size, 0);\n    fs.closeSync(fd);\n  } catch (_e) {\n    return null;\n  }\n\n  return parseShebang(buffer.toString());\n}\n"],"names":["readShebang","shebangRegex","parseShebang","str","match","arr","replace","split","bin","pop","arg","command","size","buffer","allocBuffer","fd","fs","openSync","readSync","closeSync","_e","toString"],"mappings":"AAAA;;;CAGC;;;;+BAkBeA;;;eAAAA;;;yDAhBD;wBACa;;;;;;AAE5B,IAAMC,eAAe;AAErB,SAASC,aAAaC,GAAW;IAC/B,IAAMC,QAAQD,IAAIC,KAAK,CAACH;IACxB,IAAI,CAACG,OAAO,OAAO;IAEnB,IAAMC,MAAMD,KAAK,CAAC,EAAE,CAACE,OAAO,CAAC,QAAQ,IAAIC,KAAK,CAAC;IAC/C,IAAMC,MAAMH,GAAG,CAAC,EAAE,CAACE,KAAK,CAAC,KAAKE,GAAG;IACjC,IAAMC,MAAML,GAAG,CAAC,EAAE;IAElB,OAAOG,QAAQ,QAAQE,MAAMF,MAAOE,CAAAA,MAAM,AAAC,IAAO,OAAJA,OAAQ,EAAC;AACzD;AAEO,SAASV,YAAYW,OAAe;IACzC,IAAMC,OAAO;IACb,IAAMC,SAASC,IAAAA,qBAAW,EAACF;IAE3B,IAAIG;IACJ,IAAI;QACFA,KAAKC,WAAE,CAACC,QAAQ,CAACN,SAAS;QAC1BK,WAAE,CAACE,QAAQ,CAACH,IAAIF,QAAQ,GAAGD,MAAM;QACjCI,WAAE,CAACG,SAAS,CAACJ;IACf,EAAE,OAAOK,IAAI;QACX,OAAO;IACT;IAEA,OAAOlB,aAAaW,OAAOQ,QAAQ;AACrC"}

package/dist/cjs/shim/types.d.cts

@@ -0,0 +1,24 @@
+/**
+ * Types for the cross-spawn shim
+ */
+import type { SpawnOptions } from 'child_process';
+export interface ShimSpawnOptions extends SpawnOptions {
+    forceShell?: boolean;
+}
+export interface Parsed {
+    command: string;
+    args: string[];
+    options: ShimSpawnOptions;
+    file: string | null | undefined;
+    original: {
+        command: string;
+        args: string[];
+    };
+}
+export interface ENOENTError extends Error {
+    code: string;
+    errno: string;
+    syscall: string;
+    path: string;
+    spawnargs: string[];
+}

package/dist/cjs/shim/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Types for the cross-spawn shim
+ */
+import type { SpawnOptions } from 'child_process';
+export interface ShimSpawnOptions extends SpawnOptions {
+    forceShell?: boolean;
+}
+export interface Parsed {
+    command: string;
+    args: string[];
+    options: ShimSpawnOptions;
+    file: string | null | undefined;
+    original: {
+        command: string;
+        args: string[];
+    };
+}
+export interface ENOENTError extends Error {
+    code: string;
+    errno: string;
+    syscall: string;
+    path: string;
+    spawnargs: string[];
+}

package/dist/cjs/shim/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the cross-spawn shim
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/shim/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/types.ts"],"sourcesContent":["/**\n * Types for the cross-spawn shim\n */\n\nimport type { SpawnOptions } from 'child_process';\n\nexport interface ShimSpawnOptions extends SpawnOptions {\n  forceShell?: boolean;\n}\n\nexport interface Parsed {\n  command: string;\n  args: string[];\n  options: ShimSpawnOptions;\n  file: string | null | undefined;\n  original: {\n    command: string;\n    args: string[];\n  };\n}\n\nexport interface ENOENTError extends Error {\n  code: string;\n  errno: string;\n  syscall: string;\n  path: string;\n  spawnargs: string[];\n}\n"],"names":[],"mappings":"AAAA;;CAEC"}

package/dist/esm/compat.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compatibility Layer for Node.js 0.8+
+ * Provides polyfills for features not available in older Node versions.
+ */
+export declare function allocBuffer(size: number): Buffer;
+export declare function objectAssign<T, U>(target: T, source: U): T & U;

package/dist/esm/compat.js

@@ -0,0 +1,28 @@
+/**
+ * Compatibility Layer for Node.js 0.8+
+ * Provides polyfills for features not available in older Node versions.
+ */ // Buffer.alloc (Node 4.5+)
+const hasBufferAlloc = typeof Buffer.alloc === 'function';
+export function allocBuffer(size) {
+    if (hasBufferAlloc) {
+        return Buffer.alloc(size);
+    }
+    // Node < 4.5 fallback
+    const buffer = new Buffer(size);
+    buffer.fill(0);
+    return buffer;
+}
+// Object.assign (ES2015 / Node 4.0+)
+const hasObjectAssign = typeof Object.assign === 'function';
+const _hasOwnProperty = Object.prototype.hasOwnProperty;
+export function objectAssign(target, source) {
+    if (hasObjectAssign) {
+        return Object.assign(target, source);
+    }
+    for(const key in source){
+        if (_hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+        }
+    }
+    return target;
+}

package/dist/esm/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/compat.ts"],"sourcesContent":["/**\n * Compatibility Layer for Node.js 0.8+\n * Provides polyfills for features not available in older Node versions.\n */\n\n// Buffer.alloc (Node 4.5+)\nconst hasBufferAlloc = typeof Buffer.alloc === 'function';\n\nexport function allocBuffer(size: number): Buffer {\n  if (hasBufferAlloc) {\n    return Buffer.alloc(size);\n  }\n  // Node < 4.5 fallback\n  const buffer = new (Buffer as unknown as new (size: number) => Buffer)(size);\n  buffer.fill(0);\n  return buffer;\n}\n\n// Object.assign (ES2015 / Node 4.0+)\nconst hasObjectAssign = typeof Object.assign === 'function';\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nexport function objectAssign<T, U>(target: T, source: U): T & U {\n  if (hasObjectAssign) {\n    return Object.assign(target, source);\n  }\n  for (const key in source) {\n    if (_hasOwnProperty.call(source, key)) {\n      (target as Record<string, unknown>)[key] = (source as Record<string, unknown>)[key];\n    }\n  }\n  return target as T & U;\n}\n"],"names":["hasBufferAlloc","Buffer","alloc","allocBuffer","size","buffer","fill","hasObjectAssign","Object","assign","_hasOwnProperty","prototype","hasOwnProperty","objectAssign","target","source","key","call"],"mappings":"AAAA;;;CAGC,GAED,2BAA2B;AAC3B,MAAMA,iBAAiB,OAAOC,OAAOC,KAAK,KAAK;AAE/C,OAAO,SAASC,YAAYC,IAAY;IACtC,IAAIJ,gBAAgB;QAClB,OAAOC,OAAOC,KAAK,CAACE;IACtB;IACA,sBAAsB;IACtB,MAAMC,SAAS,IAAKJ,OAAmDG;IACvEC,OAAOC,IAAI,CAAC;IACZ,OAAOD;AACT;AAEA,qCAAqC;AACrC,MAAME,kBAAkB,OAAOC,OAAOC,MAAM,KAAK;AACjD,MAAMC,kBAAkBF,OAAOG,SAAS,CAACC,cAAc;AAEvD,OAAO,SAASC,aAAmBC,MAAS,EAAEC,MAAS;IACrD,IAAIR,iBAAiB;QACnB,OAAOC,OAAOC,MAAM,CAACK,QAAQC;IAC/B;IACA,IAAK,MAAMC,OAAOD,OAAQ;QACxB,IAAIL,gBAAgBO,IAAI,CAACF,QAAQC,MAAM;YACpCF,MAAkC,CAACE,IAAI,GAAG,AAACD,MAAkC,CAACC,IAAI;QACrF;IACF;IACA,OAAOF;AACT"}

package/dist/esm/constants.d.ts

@@ -1 +1,2 @@
 export declare const spawnKeys: string[];
+export declare const isWindows: boolean;

package/dist/esm/constants.js

@@ -6,3 +6,4 @@ export const spawnKeys = [
     'stderr',
     'output'
 ];
+export const isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);

package/dist/esm/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/constants.ts"],"sourcesContent":["export const spawnKeys = ['pid', 'status', 'signal', 'stdout', 'stderr', 'output'];\n"],"names":["spawnKeys"],"mappings":"AAAA,OAAO,MAAMA,YAAY;IAAC;IAAO;IAAU;IAAU;IAAU;IAAU;CAAS,CAAC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/constants.ts"],"sourcesContent":["export const spawnKeys = ['pid', 'status', 'signal', 'stdout', 'stderr', 'output'];\n\nexport const isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\n"],"names":["spawnKeys","isWindows","process","platform","test","env","OSTYPE"],"mappings":"AAAA,OAAO,MAAMA,YAAY;IAAC;IAAO;IAAU;IAAU;IAAU;IAAU;CAAS,CAAC;AAEnF,OAAO,MAAMC,YAAYC,QAAQC,QAAQ,KAAK,WAAW,kBAAkBC,IAAI,CAACF,QAAQG,GAAG,CAACC,MAAM,EAAE"}

package/dist/esm/crossSpawn.js

@@ -4,7 +4,8 @@ import path from 'path';
 import spawnSyncPolyfill from './polyfills/spawnSync.js';
 const major = +process.versions.node.split('.')[0];
 const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
-const crossSpawn = _require(major <= 7 ? '../../assets/cross-spawn.cjs' : 'cross-spawn');
+// Use lightweight shim for legacy Node (<= 7), modern cross-spawn for Node >= 8
+const crossSpawn = _require(major <= 7 ? './shim/index.js' : 'cross-spawn');
 export default function spawn(command, args, options) {
     const parsed = spawn._parse(command, args, options);
     const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);

package/dist/esm/crossSpawn.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/crossSpawn.ts"],"sourcesContent":["import type { ChildProcess } from 'child_process';\nimport cp from 'child_process';\nimport Module from 'module';\nimport path from 'path';\nimport spawnSyncPolyfill from './polyfills/spawnSync.ts';\nimport type { Enoent, Parsed, SpawnOptions, SpawnResult, SpawnSyncOptions } from './types.ts';\n\nconst major = +process.versions.node.split('.')[0];\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\nconst crossSpawn = _require(major <= 7 ? '../../assets/cross-spawn.cjs' : 'cross-spawn');\n\nexport default function spawn(command: string, args: string[], options?: SpawnOptions): ChildProcess {\n  const parsed = spawn._parse(command, args, options);\n  const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);\n  spawn._enoent.hookChildProcess(spawned, parsed);\n  return spawned;\n}\n\nconst cpSpawnSync = cp.spawnSync || spawnSyncPolyfill;\nspawn.sync = function sync(command: string, args: string[], options?: SpawnSyncOptions): SpawnResult {\n  const parsed = spawn._parse(command, args, options) as Parsed;\n  const res = cpSpawnSync(parsed.command, parsed.args, parsed.options);\n  res.error = res.error || spawn._enoent.verifyENOENTSync(res.status, parsed);\n  return res;\n};\n\n// patch earlier versions of cross-spawn with inconsistent handling of node\nconst NODES = ['node', 'node.exe', 'node.cmd'];\nfunction _parse(command: string, args: string[], options?: SpawnOptions | SpawnSyncOptions): Parsed {\n  if (NODES.indexOf(path.basename(command).toLowerCase()) >= 0) {\n    const env = options ? options.env || process.env : process.env;\n    command = env.NODE || env.npm_node_execpath || command;\n  }\n  return crossSpawn._parse(command, args, options);\n}\nspawn._parse = (major <= 7 ? _parse : crossSpawn._parse) as typeof _parse;\nspawn._enoent = crossSpawn._enoent as Enoent;\n"],"names":["cp","Module","path","spawnSyncPolyfill","major","process","versions","node","split","_require","require","createRequire","url","crossSpawn","spawn","command","args","options","parsed","_parse","spawned","_enoent","hookChildProcess","cpSpawnSync","spawnSync","sync","res","error","verifyENOENTSync","status","NODES","indexOf","basename","toLowerCase","env","NODE","npm_node_execpath"],"mappings":"AACA,OAAOA,QAAQ,gBAAgB;AAC/B,OAAOC,YAAY,SAAS;AAC5B,OAAOC,UAAU,OAAO;AACxB,OAAOC,uBAAuB,2BAA2B;AAGzD,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,MAAMC,WAAW,OAAOC,YAAY,cAAcT,OAAOU,aAAa,CAAC,YAAYC,GAAG,IAAIF;AAC1F,MAAMG,aAAaJ,SAASL,SAAS,IAAI,iCAAiC;AAE1E,eAAe,SAASU,MAAMC,OAAe,EAAEC,IAAc,EAAEC,OAAsB;IACnF,MAAMC,SAASJ,MAAMK,MAAM,CAACJ,SAASC,MAAMC;IAC3C,MAAMG,UAAUpB,GAAGc,KAAK,CAACI,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACpEH,MAAMO,OAAO,CAACC,gBAAgB,CAACF,SAASF;IACxC,OAAOE;AACT;AAEA,MAAMG,cAAcvB,GAAGwB,SAAS,IAAIrB;AACpCW,MAAMW,IAAI,GAAG,SAASA,KAAKV,OAAe,EAAEC,IAAc,EAAEC,OAA0B;IACpF,MAAMC,SAASJ,MAAMK,MAAM,CAACJ,SAASC,MAAMC;IAC3C,MAAMS,MAAMH,YAAYL,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACnES,IAAIC,KAAK,GAAGD,IAAIC,KAAK,IAAIb,MAAMO,OAAO,CAACO,gBAAgB,CAACF,IAAIG,MAAM,EAAEX;IACpE,OAAOQ;AACT;AAEA,2EAA2E;AAC3E,MAAMI,QAAQ;IAAC;IAAQ;IAAY;CAAW;AAC9C,SAASX,OAAOJ,OAAe,EAAEC,IAAc,EAAEC,OAAyC;IACxF,IAAIa,MAAMC,OAAO,CAAC7B,KAAK8B,QAAQ,CAACjB,SAASkB,WAAW,OAAO,GAAG;QAC5D,MAAMC,MAAMjB,UAAUA,QAAQiB,GAAG,IAAI7B,QAAQ6B,GAAG,GAAG7B,QAAQ6B,GAAG;QAC9DnB,UAAUmB,IAAIC,IAAI,IAAID,IAAIE,iBAAiB,IAAIrB;IACjD;IACA,OAAOF,WAAWM,MAAM,CAACJ,SAASC,MAAMC;AAC1C;AACAH,MAAMK,MAAM,GAAIf,SAAS,IAAIe,SAASN,WAAWM,MAAM;AACvDL,MAAMO,OAAO,GAAGR,WAAWQ,OAAO"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/crossSpawn.ts"],"sourcesContent":["import type { ChildProcess } from 'child_process';\nimport cp from 'child_process';\nimport Module from 'module';\nimport path from 'path';\nimport spawnSyncPolyfill from './polyfills/spawnSync.ts';\nimport type { Enoent, Parsed, SpawnOptions, SpawnResult, SpawnSyncOptions } from './types.ts';\n\nconst major = +process.versions.node.split('.')[0];\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n// Use lightweight shim for legacy Node (<= 7), modern cross-spawn for Node >= 8\nconst crossSpawn = _require(major <= 7 ? './shim/index.js' : 'cross-spawn');\n\nexport default function spawn(command: string, args: string[], options?: SpawnOptions): ChildProcess {\n  const parsed = spawn._parse(command, args, options);\n  const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);\n  spawn._enoent.hookChildProcess(spawned, parsed);\n  return spawned;\n}\n\nconst cpSpawnSync = cp.spawnSync || spawnSyncPolyfill;\nspawn.sync = function sync(command: string, args: string[], options?: SpawnSyncOptions): SpawnResult {\n  const parsed = spawn._parse(command, args, options) as Parsed;\n  const res = cpSpawnSync(parsed.command, parsed.args, parsed.options);\n  res.error = res.error || spawn._enoent.verifyENOENTSync(res.status, parsed);\n  return res;\n};\n\n// patch earlier versions of cross-spawn with inconsistent handling of node\nconst NODES = ['node', 'node.exe', 'node.cmd'];\nfunction _parse(command: string, args: string[], options?: SpawnOptions | SpawnSyncOptions): Parsed {\n  if (NODES.indexOf(path.basename(command).toLowerCase()) >= 0) {\n    const env = options ? options.env || process.env : process.env;\n    command = env.NODE || env.npm_node_execpath || command;\n  }\n  return crossSpawn._parse(command, args, options);\n}\nspawn._parse = (major <= 7 ? _parse : crossSpawn._parse) as typeof _parse;\nspawn._enoent = crossSpawn._enoent as Enoent;\n"],"names":["cp","Module","path","spawnSyncPolyfill","major","process","versions","node","split","_require","require","createRequire","url","crossSpawn","spawn","command","args","options","parsed","_parse","spawned","_enoent","hookChildProcess","cpSpawnSync","spawnSync","sync","res","error","verifyENOENTSync","status","NODES","indexOf","basename","toLowerCase","env","NODE","npm_node_execpath"],"mappings":"AACA,OAAOA,QAAQ,gBAAgB;AAC/B,OAAOC,YAAY,SAAS;AAC5B,OAAOC,UAAU,OAAO;AACxB,OAAOC,uBAAuB,2BAA2B;AAGzD,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,MAAMC,WAAW,OAAOC,YAAY,cAAcT,OAAOU,aAAa,CAAC,YAAYC,GAAG,IAAIF;AAC1F,gFAAgF;AAChF,MAAMG,aAAaJ,SAASL,SAAS,IAAI,oBAAoB;AAE7D,eAAe,SAASU,MAAMC,OAAe,EAAEC,IAAc,EAAEC,OAAsB;IACnF,MAAMC,SAASJ,MAAMK,MAAM,CAACJ,SAASC,MAAMC;IAC3C,MAAMG,UAAUpB,GAAGc,KAAK,CAACI,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACpEH,MAAMO,OAAO,CAACC,gBAAgB,CAACF,SAASF;IACxC,OAAOE;AACT;AAEA,MAAMG,cAAcvB,GAAGwB,SAAS,IAAIrB;AACpCW,MAAMW,IAAI,GAAG,SAASA,KAAKV,OAAe,EAAEC,IAAc,EAAEC,OAA0B;IACpF,MAAMC,SAASJ,MAAMK,MAAM,CAACJ,SAASC,MAAMC;IAC3C,MAAMS,MAAMH,YAAYL,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACnES,IAAIC,KAAK,GAAGD,IAAIC,KAAK,IAAIb,MAAMO,OAAO,CAACO,gBAAgB,CAACF,IAAIG,MAAM,EAAEX;IACpE,OAAOQ;AACT;AAEA,2EAA2E;AAC3E,MAAMI,QAAQ;IAAC;IAAQ;IAAY;CAAW;AAC9C,SAASX,OAAOJ,OAAe,EAAEC,IAAc,EAAEC,OAAyC;IACxF,IAAIa,MAAMC,OAAO,CAAC7B,KAAK8B,QAAQ,CAACjB,SAASkB,WAAW,OAAO,GAAG;QAC5D,MAAMC,MAAMjB,UAAUA,QAAQiB,GAAG,IAAI7B,QAAQ6B,GAAG,GAAG7B,QAAQ6B,GAAG;QAC9DnB,UAAUmB,IAAIC,IAAI,IAAID,IAAIE,iBAAiB,IAAIrB;IACjD;IACA,OAAOF,WAAWM,MAAM,CAACJ,SAASC,MAAMC;AAC1C;AACAH,MAAMK,MAAM,GAAIf,SAAS,IAAIe,SAASN,WAAWM,MAAM;AACvDL,MAAMO,OAAO,GAAGR,WAAWQ,OAAO"}

package/dist/esm/shim/enoent.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ENOENT error handling for Windows
+ * Extracted from cross-spawn v6.0.5
+ */
+import type { ChildProcess } from 'child_process';
+import type { ENOENTError, Parsed } from './types.js';
+export declare function notFoundError(original: Parsed['original'], syscall: string): ENOENTError;
+export declare function hookChildProcess(cp: ChildProcess, parsed: Parsed): void;
+export declare function verifyENOENT(status: number, parsed: Parsed): ENOENTError | null;
+export declare function verifyENOENTSync(status: number, parsed: Parsed): ENOENTError | null;

package/dist/esm/shim/enoent.js

@@ -0,0 +1,38 @@
+/**
+ * ENOENT error handling for Windows
+ * Extracted from cross-spawn v6.0.5
+ */ import { isWindows } from '../constants.js';
+export function notFoundError(original, syscall) {
+    const err = new Error(`${syscall} ${original.command} ENOENT`);
+    err.code = 'ENOENT';
+    err.errno = 'ENOENT';
+    err.syscall = `${syscall} ${original.command}`;
+    err.path = original.command;
+    err.spawnargs = original.args;
+    return err;
+}
+export function hookChildProcess(cp, parsed) {
+    if (!isWindows) return;
+    const originalEmit = cp.emit.bind(cp);
+    cp.emit = (name, ...args)=>{
+        if (name === 'exit') {
+            const err = verifyENOENT(args[0], parsed);
+            if (err) {
+                return originalEmit('error', err);
+            }
+        }
+        return originalEmit(name, ...args);
+    };
+}
+export function verifyENOENT(status, parsed) {
+    if (isWindows && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawn');
+    }
+    return null;
+}
+export function verifyENOENTSync(status, parsed) {
+    if (isWindows && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawnSync');
+    }
+    return null;
+}

package/dist/esm/shim/enoent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/enoent.ts"],"sourcesContent":["/**\n * ENOENT error handling for Windows\n * Extracted from cross-spawn v6.0.5\n */\n\nimport type { ChildProcess } from 'child_process';\nimport { isWindows } from '../constants.ts';\nimport type { ENOENTError, Parsed } from './types.ts';\n\nexport function notFoundError(original: Parsed['original'], syscall: string): ENOENTError {\n  const err = new Error(`${syscall} ${original.command} ENOENT`) as ENOENTError;\n  err.code = 'ENOENT';\n  err.errno = 'ENOENT';\n  err.syscall = `${syscall} ${original.command}`;\n  err.path = original.command;\n  err.spawnargs = original.args;\n  return err;\n}\n\nexport function hookChildProcess(cp: ChildProcess, parsed: Parsed): void {\n  if (!isWindows) return;\n\n  const originalEmit = cp.emit.bind(cp);\n  cp.emit = (name: string | symbol, ...args: unknown[]): boolean => {\n    if (name === 'exit') {\n      const err = verifyENOENT(args[0] as number, parsed);\n      if (err) {\n        return originalEmit('error', err);\n      }\n    }\n    return originalEmit(name, ...args);\n  };\n}\n\nexport function verifyENOENT(status: number, parsed: Parsed): ENOENTError | null {\n  if (isWindows && status === 1 && !parsed.file) {\n    return notFoundError(parsed.original, 'spawn');\n  }\n  return null;\n}\n\nexport function verifyENOENTSync(status: number, parsed: Parsed): ENOENTError | null {\n  if (isWindows && status === 1 && !parsed.file) {\n    return notFoundError(parsed.original, 'spawnSync');\n  }\n  return null;\n}\n"],"names":["isWindows","notFoundError","original","syscall","err","Error","command","code","errno","path","spawnargs","args","hookChildProcess","cp","parsed","originalEmit","emit","bind","name","verifyENOENT","status","file","verifyENOENTSync"],"mappings":"AAAA;;;CAGC,GAGD,SAASA,SAAS,QAAQ,kBAAkB;AAG5C,OAAO,SAASC,cAAcC,QAA4B,EAAEC,OAAe;IACzE,MAAMC,MAAM,IAAIC,MAAM,GAAGF,QAAQ,CAAC,EAAED,SAASI,OAAO,CAAC,OAAO,CAAC;IAC7DF,IAAIG,IAAI,GAAG;IACXH,IAAII,KAAK,GAAG;IACZJ,IAAID,OAAO,GAAG,GAAGA,QAAQ,CAAC,EAAED,SAASI,OAAO,EAAE;IAC9CF,IAAIK,IAAI,GAAGP,SAASI,OAAO;IAC3BF,IAAIM,SAAS,GAAGR,SAASS,IAAI;IAC7B,OAAOP;AACT;AAEA,OAAO,SAASQ,iBAAiBC,EAAgB,EAAEC,MAAc;IAC/D,IAAI,CAACd,WAAW;IAEhB,MAAMe,eAAeF,GAAGG,IAAI,CAACC,IAAI,CAACJ;IAClCA,GAAGG,IAAI,GAAG,CAACE,MAAuB,GAAGP;QACnC,IAAIO,SAAS,QAAQ;YACnB,MAAMd,MAAMe,aAAaR,IAAI,CAAC,EAAE,EAAYG;YAC5C,IAAIV,KAAK;gBACP,OAAOW,aAAa,SAASX;YAC/B;QACF;QACA,OAAOW,aAAaG,SAASP;IAC/B;AACF;AAEA,OAAO,SAASQ,aAAaC,MAAc,EAAEN,MAAc;IACzD,IAAId,aAAaoB,WAAW,KAAK,CAACN,OAAOO,IAAI,EAAE;QAC7C,OAAOpB,cAAca,OAAOZ,QAAQ,EAAE;IACxC;IACA,OAAO;AACT;AAEA,OAAO,SAASoB,iBAAiBF,MAAc,EAAEN,MAAc;IAC7D,IAAId,aAAaoB,WAAW,KAAK,CAACN,OAAOO,IAAI,EAAE;QAC7C,OAAOpB,cAAca,OAAOZ,QAAQ,EAAE;IACxC;IACA,OAAO;AACT"}

package/dist/esm/shim/escape.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Windows cmd.exe argument escaping
+ * Extracted from cross-spawn v6.0.5
+ */
+export declare function escapeCommand(arg: string): string;
+export declare function escapeArgument(arg: string, doubleEscapeMetaChars?: boolean): string;

package/dist/esm/shim/escape.js

@@ -0,0 +1,26 @@
+/**
+ * Windows cmd.exe argument escaping
+ * Extracted from cross-spawn v6.0.5
+ */ const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+export function escapeCommand(arg) {
+    return arg.replace(metaCharsRegExp, '^$1');
+}
+export function escapeArgument(arg, doubleEscapeMetaChars) {
+    // Convert to string
+    arg = `${arg}`;
+    // Sequence of backslashes followed by a double quote:
+    // double up all the backslashes and escape the double quote
+    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+    // Sequence of backslashes followed by the end of the string:
+    // double up all the backslashes
+    arg = arg.replace(/(\\*)$/, '$1$1');
+    // Quote the whole thing
+    arg = `"${arg}"`;
+    // Escape meta chars
+    arg = arg.replace(metaCharsRegExp, '^$1');
+    // Double escape meta chars if necessary
+    if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, '^$1');
+    }
+    return arg;
+}

package/dist/esm/shim/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/escape.ts"],"sourcesContent":["/**\n * Windows cmd.exe argument escaping\n * Extracted from cross-spawn v6.0.5\n */\n\nconst metaCharsRegExp = /([()\\][%!^\"`<>&|;, *?])/g;\n\nexport function escapeCommand(arg: string): string {\n  return arg.replace(metaCharsRegExp, '^$1');\n}\n\nexport function escapeArgument(arg: string, doubleEscapeMetaChars?: boolean): string {\n  // Convert to string\n  arg = `${arg}`;\n\n  // Sequence of backslashes followed by a double quote:\n  // double up all the backslashes and escape the double quote\n  arg = arg.replace(/(\\\\*)\"/g, '$1$1\\\\\"');\n\n  // Sequence of backslashes followed by the end of the string:\n  // double up all the backslashes\n  arg = arg.replace(/(\\\\*)$/, '$1$1');\n\n  // Quote the whole thing\n  arg = `\"${arg}\"`;\n\n  // Escape meta chars\n  arg = arg.replace(metaCharsRegExp, '^$1');\n\n  // Double escape meta chars if necessary\n  if (doubleEscapeMetaChars) {\n    arg = arg.replace(metaCharsRegExp, '^$1');\n  }\n\n  return arg;\n}\n"],"names":["metaCharsRegExp","escapeCommand","arg","replace","escapeArgument","doubleEscapeMetaChars"],"mappings":"AAAA;;;CAGC,GAED,MAAMA,kBAAkB;AAExB,OAAO,SAASC,cAAcC,GAAW;IACvC,OAAOA,IAAIC,OAAO,CAACH,iBAAiB;AACtC;AAEA,OAAO,SAASI,eAAeF,GAAW,EAAEG,qBAA+B;IACzE,oBAAoB;IACpBH,MAAM,GAAGA,KAAK;IAEd,sDAAsD;IACtD,4DAA4D;IAC5DA,MAAMA,IAAIC,OAAO,CAAC,WAAW;IAE7B,6DAA6D;IAC7D,gCAAgC;IAChCD,MAAMA,IAAIC,OAAO,CAAC,UAAU;IAE5B,wBAAwB;IACxBD,MAAM,CAAC,CAAC,EAAEA,IAAI,CAAC,CAAC;IAEhB,oBAAoB;IACpBA,MAAMA,IAAIC,OAAO,CAACH,iBAAiB;IAEnC,wCAAwC;IACxC,IAAIK,uBAAuB;QACzBH,MAAMA,IAAIC,OAAO,CAACH,iBAAiB;IACrC;IAEA,OAAOE;AACT"}

package/dist/esm/shim/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Minimal cross-spawn shim for Windows compatibility on legacy Node.js
+ *
+ * This replaces the bundled cross-spawn v6.0.5 (~1,950 lines) with a minimal
+ * implementation (~200 lines) that uses external dependencies:
+ * - which@^1.0.0 (command resolution)
+ * - env-path-key@^1.0.0 (cross-platform PATH key detection)
+ */
+import type { ChildProcess, SpawnSyncReturns } from 'child_process';
+import { hookChildProcess, notFoundError, verifyENOENT, verifyENOENTSync } from './enoent.js';
+import { parse } from './parse.js';
+import type { Parsed, ShimSpawnOptions } from './types.js';
+declare function spawn(command: string, args?: string[] | ShimSpawnOptions, options?: ShimSpawnOptions): ChildProcess;
+declare function spawnSync(command: string, args?: string[] | ShimSpawnOptions, options?: ShimSpawnOptions): SpawnSyncReturns<Buffer>;
+export default spawn;
+export { spawn };
+export { spawnSync as sync };
+export { parse as _parse };
+export declare const _enoent: {
+    hookChildProcess: typeof hookChildProcess;
+    verifyENOENT: typeof verifyENOENT;
+    verifyENOENTSync: typeof verifyENOENTSync;
+    notFoundError: typeof notFoundError;
+};
+export type { Parsed, ShimSpawnOptions };

package/dist/esm/shim/index.js

@@ -0,0 +1,37 @@
+/**
+ * Minimal cross-spawn shim for Windows compatibility on legacy Node.js
+ *
+ * This replaces the bundled cross-spawn v6.0.5 (~1,950 lines) with a minimal
+ * implementation (~200 lines) that uses external dependencies:
+ * - which@^1.0.0 (command resolution)
+ * - env-path-key@^1.0.0 (cross-platform PATH key detection)
+ */ import cp from 'child_process';
+import spawnSyncPolyfill from '../polyfills/spawnSync.js';
+import { hookChildProcess, notFoundError, verifyENOENT, verifyENOENTSync } from './enoent.js';
+import { parse } from './parse.js';
+const cpSpawnSync = cp.spawnSync || spawnSyncPolyfill;
+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 = cpSpawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || verifyENOENTSync(result.status, parsed);
+    return result;
+}
+// Main export
+export default spawn;
+// Named exports matching cross-spawn's API
+export { spawn };
+export { spawnSync as sync };
+// Internal APIs used by crossSpawn.ts
+export { parse as _parse };
+export const _enoent = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+};

package/dist/esm/shim/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/index.ts"],"sourcesContent":["/**\n * Minimal cross-spawn shim for Windows compatibility on legacy Node.js\n *\n * This replaces the bundled cross-spawn v6.0.5 (~1,950 lines) with a minimal\n * implementation (~200 lines) that uses external dependencies:\n * - which@^1.0.0 (command resolution)\n * - env-path-key@^1.0.0 (cross-platform PATH key detection)\n */\n\nimport type { ChildProcess, SpawnSyncReturns } from 'child_process';\nimport cp from 'child_process';\nimport spawnSyncPolyfill from '../polyfills/spawnSync.ts';\nimport { hookChildProcess, notFoundError, verifyENOENT, verifyENOENTSync } from './enoent.ts';\nimport { parse } from './parse.ts';\nimport type { Parsed, ShimSpawnOptions } from './types.ts';\n\nconst cpSpawnSync = cp.spawnSync || spawnSyncPolyfill;\n\nfunction spawn(command: string, args?: string[] | ShimSpawnOptions, options?: ShimSpawnOptions): ChildProcess {\n  const parsed = parse(command, args, options);\n  const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);\n  hookChildProcess(spawned, parsed);\n  return spawned;\n}\n\nfunction spawnSync(command: string, args?: string[] | ShimSpawnOptions, options?: ShimSpawnOptions): SpawnSyncReturns<Buffer> {\n  const parsed = parse(command, args, options);\n  const result = cpSpawnSync(parsed.command, parsed.args, parsed.options) as SpawnSyncReturns<Buffer> & { error?: Error };\n  result.error = result.error || verifyENOENTSync(result.status as number, parsed);\n  return result;\n}\n\n// Main export\nexport default spawn;\n\n// Named exports matching cross-spawn's API\nexport { spawn };\nexport { spawnSync as sync };\n\n// Internal APIs used by crossSpawn.ts\nexport { parse as _parse };\nexport const _enoent = {\n  hookChildProcess,\n  verifyENOENT,\n  verifyENOENTSync,\n  notFoundError,\n};\n\n// Re-export types\nexport type { Parsed, ShimSpawnOptions };\n"],"names":["cp","spawnSyncPolyfill","hookChildProcess","notFoundError","verifyENOENT","verifyENOENTSync","parse","cpSpawnSync","spawnSync","spawn","command","args","options","parsed","spawned","result","error","status","sync","_parse","_enoent"],"mappings":"AAAA;;;;;;;CAOC,GAGD,OAAOA,QAAQ,gBAAgB;AAC/B,OAAOC,uBAAuB,4BAA4B;AAC1D,SAASC,gBAAgB,EAAEC,aAAa,EAAEC,YAAY,EAAEC,gBAAgB,QAAQ,cAAc;AAC9F,SAASC,KAAK,QAAQ,aAAa;AAGnC,MAAMC,cAAcP,GAAGQ,SAAS,IAAIP;AAEpC,SAASQ,MAAMC,OAAe,EAAEC,IAAkC,EAAEC,OAA0B;IAC5F,MAAMC,SAASP,MAAMI,SAASC,MAAMC;IACpC,MAAME,UAAUd,GAAGS,KAAK,CAACI,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACpEV,iBAAiBY,SAASD;IAC1B,OAAOC;AACT;AAEA,SAASN,UAAUE,OAAe,EAAEC,IAAkC,EAAEC,OAA0B;IAChG,MAAMC,SAASP,MAAMI,SAASC,MAAMC;IACpC,MAAMG,SAASR,YAAYM,OAAOH,OAAO,EAAEG,OAAOF,IAAI,EAAEE,OAAOD,OAAO;IACtEG,OAAOC,KAAK,GAAGD,OAAOC,KAAK,IAAIX,iBAAiBU,OAAOE,MAAM,EAAYJ;IACzE,OAAOE;AACT;AAEA,cAAc;AACd,eAAeN,MAAM;AAErB,2CAA2C;AAC3C,SAASA,KAAK,GAAG;AACjB,SAASD,aAAaU,IAAI,GAAG;AAE7B,sCAAsC;AACtC,SAASZ,SAASa,MAAM,GAAG;AAC3B,OAAO,MAAMC,UAAU;IACrBlB;IACAE;IACAC;IACAF;AACF,EAAE"}

package/dist/esm/shim/parse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Command parsing for cross-platform spawn
+ * Simplified from cross-spawn v6.0.5
+ */
+import type { Parsed, ShimSpawnOptions } from './types.js';
+export declare function parse(command: string, args?: string[] | ShimSpawnOptions | null, options?: ShimSpawnOptions): Parsed;

package/dist/esm/shim/parse.js

@@ -0,0 +1,102 @@
+/**
+ * Command parsing for cross-platform spawn
+ * Simplified from cross-spawn v6.0.5
+ */ import path from 'path';
+import { objectAssign } from '../compat.js';
+import { isWindows } from '../constants.js';
+import { escapeArgument, escapeCommand } from './escape.js';
+import { resolveCommand } from './resolve.js';
+import { readShebang } from './shebang.js';
+const isExecutableRegExp = /\.(?:com|exe)$/i;
+const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+    }
+    return parsed.file;
+}
+function parseNonShell(parsed) {
+    if (!isWindows) return parsed;
+    // Detect & add support for shebangs
+    const commandFile = detectShebang(parsed);
+    // We don't need a shell if the command filename is an executable
+    const needsShell = !isExecutableRegExp.test(commandFile || '');
+    if (parsed.options.forceShell || needsShell) {
+        // Need to double escape meta chars if the command is a cmd-shim
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile || '');
+        // Normalize posix paths into OS compatible paths
+        parsed.command = path.normalize(parsed.command);
+        // Escape command & arguments
+        parsed.command = escapeCommand(parsed.command);
+        parsed.args = parsed.args.map((arg)=>escapeArgument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [
+            parsed.command
+        ].concat(parsed.args).join(' ');
+        parsed.args = [
+            '/d',
+            '/s',
+            '/c',
+            `"${shellCommand}"`
+        ];
+        parsed.command = process.env.comspec || 'cmd.exe';
+        parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+}
+function parseShell(parsed) {
+    // Mimic node shell option for older Node versions
+    const shellCommand = [
+        parsed.command
+    ].concat(parsed.args).join(' ');
+    if (isWindows) {
+        parsed.command = typeof parsed.options.shell === 'string' ? parsed.options.shell : process.env.comspec || 'cmd.exe';
+        parsed.args = [
+            '/d',
+            '/s',
+            '/c',
+            `"${shellCommand}"`
+        ];
+        parsed.options.windowsVerbatimArguments = true;
+    } else {
+        if (typeof parsed.options.shell === 'string') {
+            parsed.command = parsed.options.shell;
+        } else if (process.platform === 'android') {
+            parsed.command = '/system/bin/sh';
+        } else {
+            parsed.command = '/bin/sh';
+        }
+        parsed.args = [
+            '-c',
+            shellCommand
+        ];
+    }
+    return parsed;
+}
+export function parse(command, args, options) {
+    // Normalize arguments
+    let argsArray;
+    let opts;
+    if (args && !Array.isArray(args)) {
+        // args is actually options
+        argsArray = [];
+        opts = objectAssign({}, args);
+    } else {
+        argsArray = args ? args.slice(0) : [];
+        opts = objectAssign({}, options || {});
+    }
+    const parsed = {
+        command: command,
+        args: argsArray,
+        options: opts,
+        file: undefined,
+        original: {
+            command: command,
+            args: argsArray
+        }
+    };
+    return opts.shell ? parseShell(parsed) : parseNonShell(parsed);
+}

package/dist/esm/shim/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/compat/cross-spawn-cb/src/shim/parse.ts"],"sourcesContent":["/**\n * Command parsing for cross-platform spawn\n * Simplified from cross-spawn v6.0.5\n */\n\nimport path from 'path';\nimport { objectAssign } from '../compat.ts';\nimport { isWindows } from '../constants.ts';\nimport { escapeArgument, escapeCommand } from './escape.ts';\nimport { resolveCommand } from './resolve.ts';\nimport { readShebang } from './shebang.ts';\nimport type { Parsed, ShimSpawnOptions } from './types.ts';\n\nconst isExecutableRegExp = /\\.(?:com|exe)$/i;\nconst isCmdShimRegExp = /node_modules[\\\\/].bin[\\\\/][^\\\\/]+\\.cmd$/i;\n\nfunction detectShebang(parsed: Parsed): string | null {\n  parsed.file = resolveCommand(parsed);\n\n  const shebang = parsed.file && readShebang(parsed.file);\n  if (shebang) {\n    parsed.args.unshift(parsed.file);\n    parsed.command = shebang;\n    return resolveCommand(parsed);\n  }\n\n  return parsed.file;\n}\n\nfunction parseNonShell(parsed: Parsed): Parsed {\n  if (!isWindows) return parsed;\n\n  // Detect & add support for shebangs\n  const commandFile = detectShebang(parsed);\n\n  // We don't need a shell if the command filename is an executable\n  const needsShell = !isExecutableRegExp.test(commandFile || '');\n\n  if (parsed.options.forceShell || needsShell) {\n    // Need to double escape meta chars if the command is a cmd-shim\n    const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile || '');\n\n    // Normalize posix paths into OS compatible paths\n    parsed.command = path.normalize(parsed.command);\n\n    // Escape command & arguments\n    parsed.command = escapeCommand(parsed.command);\n    parsed.args = parsed.args.map((arg) => escapeArgument(arg, needsDoubleEscapeMetaChars));\n\n    const shellCommand = [parsed.command].concat(parsed.args).join(' ');\n\n    parsed.args = ['/d', '/s', '/c', `\"${shellCommand}\"`];\n    parsed.command = process.env.comspec || 'cmd.exe';\n    parsed.options.windowsVerbatimArguments = true;\n  }\n\n  return parsed;\n}\n\nfunction parseShell(parsed: Parsed): Parsed {\n  // Mimic node shell option for older Node versions\n  const shellCommand = [parsed.command].concat(parsed.args).join(' ');\n\n  if (isWindows) {\n    parsed.command = typeof parsed.options.shell === 'string' ? parsed.options.shell : process.env.comspec || 'cmd.exe';\n    parsed.args = ['/d', '/s', '/c', `\"${shellCommand}\"`];\n    parsed.options.windowsVerbatimArguments = true;\n  } else {\n    if (typeof parsed.options.shell === 'string') {\n      parsed.command = parsed.options.shell;\n    } else if (process.platform === 'android') {\n      parsed.command = '/system/bin/sh';\n    } else {\n      parsed.command = '/bin/sh';\n    }\n    parsed.args = ['-c', shellCommand];\n  }\n\n  return parsed;\n}\n\nexport function parse(command: string, args?: string[] | ShimSpawnOptions | null, options?: ShimSpawnOptions): Parsed {\n  // Normalize arguments\n  let argsArray: string[];\n  let opts: ShimSpawnOptions;\n\n  if (args && !Array.isArray(args)) {\n    // args is actually options\n    argsArray = [];\n    opts = objectAssign({}, args);\n  } else {\n    argsArray = args ? (args as string[]).slice(0) : [];\n    opts = objectAssign({}, options || {});\n  }\n\n  const parsed: Parsed = {\n    command: command,\n    args: argsArray,\n    options: opts,\n    file: undefined,\n    original: {\n      command: command,\n      args: argsArray,\n    },\n  };\n\n  return opts.shell ? parseShell(parsed) : parseNonShell(parsed);\n}\n"],"names":["path","objectAssign","isWindows","escapeArgument","escapeCommand","resolveCommand","readShebang","isExecutableRegExp","isCmdShimRegExp","detectShebang","parsed","file","shebang","args","unshift","command","parseNonShell","commandFile","needsShell","test","options","forceShell","needsDoubleEscapeMetaChars","normalize","map","arg","shellCommand","concat","join","process","env","comspec","windowsVerbatimArguments","parseShell","shell","platform","parse","argsArray","opts","Array","isArray","slice","undefined","original"],"mappings":"AAAA;;;CAGC,GAED,OAAOA,UAAU,OAAO;AACxB,SAASC,YAAY,QAAQ,eAAe;AAC5C,SAASC,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,cAAc,EAAEC,aAAa,QAAQ,cAAc;AAC5D,SAASC,cAAc,QAAQ,eAAe;AAC9C,SAASC,WAAW,QAAQ,eAAe;AAG3C,MAAMC,qBAAqB;AAC3B,MAAMC,kBAAkB;AAExB,SAASC,cAAcC,MAAc;IACnCA,OAAOC,IAAI,GAAGN,eAAeK;IAE7B,MAAME,UAAUF,OAAOC,IAAI,IAAIL,YAAYI,OAAOC,IAAI;IACtD,IAAIC,SAAS;QACXF,OAAOG,IAAI,CAACC,OAAO,CAACJ,OAAOC,IAAI;QAC/BD,OAAOK,OAAO,GAAGH;QACjB,OAAOP,eAAeK;IACxB;IAEA,OAAOA,OAAOC,IAAI;AACpB;AAEA,SAASK,cAAcN,MAAc;IACnC,IAAI,CAACR,WAAW,OAAOQ;IAEvB,oCAAoC;IACpC,MAAMO,cAAcR,cAAcC;IAElC,iEAAiE;IACjE,MAAMQ,aAAa,CAACX,mBAAmBY,IAAI,CAACF,eAAe;IAE3D,IAAIP,OAAOU,OAAO,CAACC,UAAU,IAAIH,YAAY;QAC3C,gEAAgE;QAChE,MAAMI,6BAA6Bd,gBAAgBW,IAAI,CAACF,eAAe;QAEvE,iDAAiD;QACjDP,OAAOK,OAAO,GAAGf,KAAKuB,SAAS,CAACb,OAAOK,OAAO;QAE9C,6BAA6B;QAC7BL,OAAOK,OAAO,GAAGX,cAAcM,OAAOK,OAAO;QAC7CL,OAAOG,IAAI,GAAGH,OAAOG,IAAI,CAACW,GAAG,CAAC,CAACC,MAAQtB,eAAesB,KAAKH;QAE3D,MAAMI,eAAe;YAAChB,OAAOK,OAAO;SAAC,CAACY,MAAM,CAACjB,OAAOG,IAAI,EAAEe,IAAI,CAAC;QAE/DlB,OAAOG,IAAI,GAAG;YAAC;YAAM;YAAM;YAAM,CAAC,CAAC,EAAEa,aAAa,CAAC,CAAC;SAAC;QACrDhB,OAAOK,OAAO,GAAGc,QAAQC,GAAG,CAACC,OAAO,IAAI;QACxCrB,OAAOU,OAAO,CAACY,wBAAwB,GAAG;IAC5C;IAEA,OAAOtB;AACT;AAEA,SAASuB,WAAWvB,MAAc;IAChC,kDAAkD;IAClD,MAAMgB,eAAe;QAAChB,OAAOK,OAAO;KAAC,CAACY,MAAM,CAACjB,OAAOG,IAAI,EAAEe,IAAI,CAAC;IAE/D,IAAI1B,WAAW;QACbQ,OAAOK,OAAO,GAAG,OAAOL,OAAOU,OAAO,CAACc,KAAK,KAAK,WAAWxB,OAAOU,OAAO,CAACc,KAAK,GAAGL,QAAQC,GAAG,CAACC,OAAO,IAAI;QAC1GrB,OAAOG,IAAI,GAAG;YAAC;YAAM;YAAM;YAAM,CAAC,CAAC,EAAEa,aAAa,CAAC,CAAC;SAAC;QACrDhB,OAAOU,OAAO,CAACY,wBAAwB,GAAG;IAC5C,OAAO;QACL,IAAI,OAAOtB,OAAOU,OAAO,CAACc,KAAK,KAAK,UAAU;YAC5CxB,OAAOK,OAAO,GAAGL,OAAOU,OAAO,CAACc,KAAK;QACvC,OAAO,IAAIL,QAAQM,QAAQ,KAAK,WAAW;YACzCzB,OAAOK,OAAO,GAAG;QACnB,OAAO;YACLL,OAAOK,OAAO,GAAG;QACnB;QACAL,OAAOG,IAAI,GAAG;YAAC;YAAMa;SAAa;IACpC;IAEA,OAAOhB;AACT;AAEA,OAAO,SAAS0B,MAAMrB,OAAe,EAAEF,IAAyC,EAAEO,OAA0B;IAC1G,sBAAsB;IACtB,IAAIiB;IACJ,IAAIC;IAEJ,IAAIzB,QAAQ,CAAC0B,MAAMC,OAAO,CAAC3B,OAAO;QAChC,2BAA2B;QAC3BwB,YAAY,EAAE;QACdC,OAAOrC,aAAa,CAAC,GAAGY;IAC1B,OAAO;QACLwB,YAAYxB,OAAO,AAACA,KAAkB4B,KAAK,CAAC,KAAK,EAAE;QACnDH,OAAOrC,aAAa,CAAC,GAAGmB,WAAW,CAAC;IACtC;IAEA,MAAMV,SAAiB;QACrBK,SAASA;QACTF,MAAMwB;QACNjB,SAASkB;QACT3B,MAAM+B;QACNC,UAAU;YACR5B,SAASA;YACTF,MAAMwB;QACR;IACF;IAEA,OAAOC,KAAKJ,KAAK,GAAGD,WAAWvB,UAAUM,cAAcN;AACzD"}

package/dist/esm/shim/resolve.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Command resolution using which
+ * Simplified from cross-spawn v6.0.5
+ */
+import type { Parsed } from './types.js';
+export declare function resolveCommand(parsed: Parsed): string | null;