@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/secrets/windows.js

@@ -0,0 +1,318 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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 windows_exports = {};
+__export(windows_exports, {
+  buildTarget: () => buildTarget,
+  deleteWindows: () => deleteWindows,
+  deleteWindowsSync: () => deleteWindowsSync,
+  getDpapiFilePath: () => getDpapiFilePath,
+  isWindowsBackendAvailable: () => isWindowsBackendAvailable,
+  quotePs: () => quotePs,
+  readDpapi: () => readDpapi,
+  readDpapiSync: () => readDpapiSync,
+  readWindows: () => readWindows,
+  readWindowsSync: () => readWindowsSync,
+  runPsAsync: () => runPsAsync,
+  runPsSync: () => runPsSync,
+  validateKeychainComponent: () => validateKeychainComponent,
+  writeDpapi: () => writeDpapi,
+  writeDpapiSync: () => writeDpapiSync,
+  writeWindows: () => writeWindows,
+  writeWindowsSync: () => writeWindowsSync
+});
+module.exports = __toCommonJS(windows_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+const POWERSHELL_BIN = "powershell";
+function buildTarget(service, account) {
+  return `${service}:${account}`;
+}
+async function deleteWindows(service, account) {
+  const target = buildTarget(service, account);
+  let removedAny = false;
+  const psScript = `
+    try { Remove-StoredCredential -Target ${quotePs(target)}; exit 0 }
+    catch { exit 1 }
+  `;
+  const ps = await runPsAsync(psScript);
+  if (ps.status === 0) {
+    removedAny = true;
+  }
+  const filePath = getDpapiFilePath(service, account);
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    try {
+      const { rmSync } = await import("node:fs");
+      rmSync(filePath, { force: true });
+      removedAny = true;
+    } catch {
+    }
+  }
+  return removedAny ? "removed" : "absent";
+}
+function deleteWindowsSync(service, account) {
+  const target = buildTarget(service, account);
+  let removedAny = false;
+  const psScript = `
+    try { Remove-StoredCredential -Target ${quotePs(target)}; exit 0 }
+    catch { exit 1 }
+  `;
+  const ps = runPsSync(psScript);
+  if (ps.status === 0) {
+    removedAny = true;
+  }
+  const filePath = getDpapiFilePath(service, account);
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    try {
+      const fsMod = require("node:fs");
+      fsMod.rmSync(filePath, { force: true });
+      removedAny = true;
+    } catch {
+    }
+  }
+  return removedAny ? "removed" : "absent";
+}
+function getDpapiFilePath(service, account) {
+  validateKeychainComponent(service, "service");
+  validateKeychainComponent(account, "account");
+  const appData = import_node_process.default.env["APPDATA"] ?? import_node_path.default.join((0, import_node_os.homedir)(), "AppData", "Roaming");
+  return import_node_path.default.join(appData, service, `${account}.enc`);
+}
+function isWindowsBackendAvailable() {
+  const r = (0, import_node_child_process.spawnSync)(POWERSHELL_BIN, ["-NoProfile", "-Command", "exit 0"], {
+    stdio: "ignore"
+  });
+  return r.status === 0;
+}
+function quotePs(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function readDpapi(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    return void 0;
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [Convert]::FromBase64String((Get-Content -Raw ${quotePs(filePath)}))
+    $plain = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [System.Text.Encoding]::UTF8.GetString($plain)
+  `;
+  const r = await runPsAsync(script);
+  if (r.status !== 0) {
+    return void 0;
+  }
+  const out = r.stdout.trim();
+  return out || void 0;
+}
+function readDpapiSync(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    return void 0;
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [Convert]::FromBase64String((Get-Content -Raw ${quotePs(filePath)}))
+    $plain = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [System.Text.Encoding]::UTF8.GetString($plain)
+  `;
+  const r = runPsSync(script);
+  if (r.status !== 0) {
+    return void 0;
+  }
+  const out = r.stdout.trim();
+  return out || void 0;
+}
+async function readWindows(service, account) {
+  const target = buildTarget(service, account);
+  const script = `
+    try {
+      (Get-StoredCredential -Target ${quotePs(target)}).Password |
+        ConvertFrom-SecureString -AsPlainText
+    } catch { exit 1 }
+  `;
+  const ps = await runPsAsync(script);
+  if (ps.status === 0) {
+    const out = ps.stdout.trim();
+    if (out) {
+      return out;
+    }
+  }
+  return readDpapi(getDpapiFilePath(service, account));
+}
+function readWindowsSync(service, account) {
+  const target = buildTarget(service, account);
+  const script = `
+    try {
+      (Get-StoredCredential -Target ${quotePs(target)}).Password |
+        ConvertFrom-SecureString -AsPlainText
+    } catch { exit 1 }
+  `;
+  const ps = runPsSync(script);
+  if (ps.status === 0) {
+    const out = ps.stdout.trim();
+    if (out) {
+      return out;
+    }
+  }
+  return readDpapiSync(getDpapiFilePath(service, account));
+}
+function runPsAsync(script, input) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process.spawn)(POWERSHELL_BIN, ["-NoProfile", "-Command", script], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", () => resolve({ status: -1, stdout, stderr }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
+    if (input !== void 0) {
+      child.stdin.end(input);
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+function runPsSync(script, input) {
+  const r = (0, import_node_child_process.spawnSync)(POWERSHELL_BIN, ["-NoProfile", "-Command", script], {
+    encoding: "utf8",
+    input,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return { status: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+function validateKeychainComponent(value, name) {
+  if (/[\\/]/.test(value) || value.includes("..") || value.includes("\0") || value === "" || value === ".") {
+    throw new Error(
+      `secrets/windows: ${name} contains path-traversal characters: ${JSON.stringify(value)}. Use a plain identifier (no \\\\, /, .., or NUL).`
+    );
+  }
+}
+async function writeDpapi(filePath, value) {
+  const dir = import_node_path.default.dirname(filePath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $token = [Console]::In.ReadToEnd().Trim()
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($token)
+    $protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($protected) | Set-Content -Path ${quotePs(filePath)} -NoNewline
+  `;
+  const r = await runPsAsync(script, value);
+  if (r.status !== 0) {
+    throw new Error(
+      `DPAPI file write failed: ${r.stderr.trim()}. Install the CredentialManager PowerShell module (\`Install-Module CredentialManager -Scope CurrentUser\`) for a cleaner storage path.`
+    );
+  }
+}
+function writeDpapiSync(filePath, value) {
+  const dir = import_node_path.default.dirname(filePath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $token = [Console]::In.ReadToEnd().Trim()
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($token)
+    $protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($protected) | Set-Content -Path ${quotePs(filePath)} -NoNewline
+  `;
+  const r = runPsSync(script, value);
+  if (r.status !== 0) {
+    throw new Error(
+      `DPAPI file write failed: ${r.stderr.trim()}. Install the CredentialManager PowerShell module (\`Install-Module CredentialManager -Scope CurrentUser\`) for a cleaner storage path.`
+    );
+  }
+}
+async function writeWindows(service, account, value, _label) {
+  const target = buildTarget(service, account);
+  const psScript = `
+    $token = $input | Out-String
+    $token = $token.Trim()
+    $secure = ConvertTo-SecureString $token -AsPlainText -Force
+    try {
+      New-StoredCredential -Target ${quotePs(target)} -UserName ${quotePs(account)} -SecurePassword $secure -Persist LocalMachine | Out-Null
+      exit 0
+    } catch { exit 1 }
+  `;
+  const ps = await runPsAsync(psScript, value);
+  if (ps.status === 0) {
+    return;
+  }
+  await writeDpapi(getDpapiFilePath(service, account), value);
+}
+function writeWindowsSync(service, account, value, _label) {
+  const target = buildTarget(service, account);
+  const psScript = `
+    $token = $input | Out-String
+    $token = $token.Trim()
+    $secure = ConvertTo-SecureString $token -AsPlainText -Force
+    try {
+      New-StoredCredential -Target ${quotePs(target)} -UserName ${quotePs(account)} -SecurePassword $secure -Persist LocalMachine | Out-Null
+      exit 0
+    } catch { exit 1 }
+  `;
+  const ps = runPsSync(psScript, value);
+  if (ps.status === 0) {
+    return;
+  }
+  writeDpapiSync(getDpapiFilePath(service, account), value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTarget,
+  deleteWindows,
+  deleteWindowsSync,
+  getDpapiFilePath,
+  isWindowsBackendAvailable,
+  quotePs,
+  readDpapi,
+  readDpapiSync,
+  readWindows,
+  readWindowsSync,
+  runPsAsync,
+  runPsSync,
+  validateKeychainComponent,
+  writeDpapi,
+  writeDpapiSync,
+  writeWindows,
+  writeWindowsSync
+});

package/dist/shadow/skip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Shadow binary installation utilities for Socket ecosystem. Provides
+ *   logic to determine when shadow binary installation should be skipped.
+ */
+import type { ShadowInstallationOptions } from './types';
+/**
+ * Determines if shadow binaries should be installed. Shadows should NOT be
+ * installed when: - Running in a temporary execution context (exec/npx/dlx) -
+ * On Windows with an existing binary path (required for Windows to function)
+ *
+ * @example
+ *   ;```typescript
+ *   if (shouldSkipShadow(binPath, { cwd: process.cwd() })) {
+ *     console.log('Skipping shadow binary installation')
+ *   }
+ *   ```
+ *
+ * @param binPath - Path to the binary being shadowed.
+ * @param options - Configuration options.
+ * @param options.cwd - Current working directory path to check.
+ * @param options.win32 - Whether running on Windows.
+ *
+ * @returns True if shadow installation should be skipped
+ */
+export declare function shouldSkipShadow(binPath: string, options?: ShadowInstallationOptions | undefined): boolean;

package/dist/{shadow.js → shadow/skip.js}

@@ -28,13 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var shadow_exports = {};
-__export(shadow_exports, {
+var skip_exports = {};
+__export(skip_exports, {
   shouldSkipShadow: () => shouldSkipShadow
 });
-module.exports = __toCommonJS(shadow_exports);
+module.exports = __toCommonJS(skip_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_normalize = require("./paths/normalize");
+var import_normalize = require("../paths/normalize");
 function shouldSkipShadow(binPath, options) {
   const { cwd = import_node_process.default.cwd(), win32 = false } = {
     __proto__: null,

package/dist/shadow/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Public type surface for `shadow/*` modules — the
+ *   `ShadowInstallationOptions` record. Pure types, no runtime side effects.
+ */
+export interface ShadowInstallationOptions {
+    cwd?: string | undefined;
+    win32?: boolean | undefined;
+}

package/dist/shadow/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/signal-exit/_internal.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @file Private internals for `signal-exit/*` modules — the shared
+ *   module-singleton state plus the lazy accessors that read and mutate it.
+ *   Owns the emitter, signal list, and `loaded` flag. `lifecycle`
+ *   (load/unload/getSignalListeners) and `intercept`
+ *   (processEmit/processReallyExit) share state through this leaf. Inlined
+ *   signal-exit: https://socket.dev/npm/package/signal-exit/overview/4.1.0 ISC
+ *   License — Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and
+ *   Contributors.
+ */
+import type { SignalExitEmitter } from './types';
+export declare const globalProcess: (NodeJS.Process & {
+    __signal_exit_emitter__?: import('node:events').EventEmitter;
+    reallyExit?: (code?: number | undefined) => never;
+}) | undefined;
+export declare const originalProcessEmit: {
+    (event: "beforeExit", code: number): boolean;
+    (event: "disconnect"): boolean;
+    (event: "exit", code: number): boolean;
+    (event: "rejectionHandled", promise: Promise<unknown>): boolean;
+    (event: "uncaughtException", error: Error): boolean;
+    (event: "uncaughtExceptionMonitor", error: Error): boolean;
+    (event: "unhandledRejection", reason: unknown, promise: Promise<unknown>): boolean;
+    (event: "warning", warning: Error): boolean;
+    (event: "message", message: unknown, sendHandle: import("child_process").SendHandle): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+    (event: NodeJS.Signals, signal?: NodeJS.Signals): boolean;
+    (event: "multipleResolves", type: NodeJS.MultipleResolveType, promise: Promise<unknown>, value: unknown): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+    (event: "worker", listener: NodeJS.WorkerListener): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+} | undefined;
+export declare const platform: string;
+export declare const originalProcessReallyExit: ((code?: number | undefined) => never) | undefined;
+export declare const WIN32: boolean;
+export declare function emit(event: string, code: number | undefined, signal: string | undefined): void;
+export declare function getEmitter(): SignalExitEmitter;
+export declare function getEvents(): typeof import('node:events');
+/**
+ * Get the cached signal list. Triggers lazy init on first call; after `load()`
+ * runs it returns the filtered subset of successfully registered signals
+ * instead of the full default list.
+ */
+export declare function getSignals(): string[];
+/**
+ * Read the loaded flag from a sibling leaf (lifecycle / on-exit).
+ *
+ * @private
+ */
+export declare function isLoaded(): boolean;
+/**
+ * Set the `loaded` flag from a sibling leaf (load / unload).
+ *
+ * @private
+ */
+export declare function setLoaded(value: boolean): void;
+/**
+ * Replace the cached signal list (used by `load()`'s filter step).
+ *
+ * @private
+ */
+export declare function setSignals(value: string[]): void;

package/dist/signal-exit/_internal.js

@@ -0,0 +1,127 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  WIN32: () => WIN32,
+  emit: () => emit,
+  getEmitter: () => getEmitter,
+  getEvents: () => getEvents,
+  getSignals: () => getSignals,
+  globalProcess: () => globalProcess,
+  isLoaded: () => isLoaded,
+  originalProcessEmit: () => originalProcessEmit,
+  originalProcessReallyExit: () => originalProcessReallyExit,
+  platform: () => platform,
+  setLoaded: () => setLoaded,
+  setSignals: () => setSignals
+});
+module.exports = __toCommonJS(internal_exports);
+const globalProcess = globalThis.process;
+const originalProcessEmit = globalProcess?.emit;
+const platform = globalProcess?.platform ?? "";
+const originalProcessReallyExit = globalProcess?.reallyExit;
+const WIN32 = platform === "win32";
+let _events;
+let _emitter;
+let _loaded = false;
+let _signals;
+// @__NO_SIDE_EFFECTS__
+function emit(event, code, signal) {
+  const emitter = /* @__PURE__ */ getEmitter();
+  if (emitter.emitted?.[event]) {
+    return;
+  }
+  if (emitter.emitted) {
+    emitter.emitted[event] = true;
+  }
+  emitter.emit(event, code, signal);
+}
+// @__NO_SIDE_EFFECTS__
+function getEmitter() {
+  if (_emitter === void 0) {
+    if (globalProcess?.__signal_exit_emitter__) {
+      _emitter = globalProcess.__signal_exit_emitter__;
+    } else if (globalProcess) {
+      const EventEmitter = (/* @__PURE__ */ getEvents()).EventEmitter;
+      _emitter = globalProcess.__signal_exit_emitter__ = new EventEmitter();
+      _emitter.count = 0;
+      _emitter.emitted = { __proto__: null };
+    }
+    if (_emitter && !_emitter.infinite) {
+      _emitter.setMaxListeners(Number.POSITIVE_INFINITY);
+      _emitter.infinite = true;
+    }
+  }
+  return _emitter;
+}
+// @__NO_SIDE_EFFECTS__
+function getEvents() {
+  if (_events === void 0) {
+    _events = require("node:events");
+  }
+  return _events;
+}
+// @__NO_SIDE_EFFECTS__
+function getSignals() {
+  if (_signals === void 0) {
+    _signals = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
+    if (!WIN32) {
+      _signals.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+      );
+    }
+    if (platform === "linux") {
+      _signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+    }
+  }
+  return _signals;
+}
+function isLoaded() {
+  return _loaded;
+}
+function setLoaded(value) {
+  _loaded = value;
+}
+function setSignals(value) {
+  _signals = value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WIN32,
+  emit,
+  getEmitter,
+  getEvents,
+  getSignals,
+  globalProcess,
+  isLoaded,
+  originalProcessEmit,
+  originalProcessReallyExit,
+  platform,
+  setLoaded,
+  setSignals
+});

package/dist/signal-exit/intercept.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Process-method interceptors — `processEmit` replaces `process.emit` and
+ *   `processReallyExit` replaces `process.reallyExit` while `load()` is active.
+ *   Both forward to the originals captured in `_internal` and broadcast `exit`
+ *   / `afterexit` through the signal-exit emitter.
+ */
+export declare function processEmit(this: NodeJS.Process, eventName: string, exitCode?: number | undefined, ...args: unknown[]): boolean;
+export declare function processReallyExit(code?: number | undefined): never;

package/dist/signal-exit/intercept.js

@@ -0,0 +1,75 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intercept_exports = {};
+__export(intercept_exports, {
+  processEmit: () => processEmit,
+  processReallyExit: () => processReallyExit
+});
+module.exports = __toCommonJS(intercept_exports);
+var import_error = require("../primordials/error");
+var import_reflect = require("../primordials/reflect");
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function processEmit(eventName, exitCode, ...args) {
+  if (eventName === "exit") {
+    let actualExitCode = exitCode;
+    if (actualExitCode === void 0) {
+      const processExitCode = import_internal.globalProcess?.exitCode;
+      actualExitCode = typeof processExitCode === "number" ? processExitCode : void 0;
+    } else if (import_internal.globalProcess) {
+      import_internal.globalProcess.exitCode = actualExitCode;
+    }
+    const result = (0, import_reflect.ReflectApply)(
+      import_internal.originalProcessEmit,
+      this,
+      [eventName, actualExitCode, ...args]
+    );
+    const numExitCode = typeof actualExitCode === "number" ? actualExitCode : void 0;
+    (0, import_internal.emit)("exit", numExitCode, void 0);
+    (0, import_internal.emit)("afterexit", numExitCode, void 0);
+    return result;
+  }
+  return (0, import_reflect.ReflectApply)(
+    import_internal.originalProcessEmit,
+    this,
+    [eventName, exitCode, ...args]
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function processReallyExit(code) {
+  const exitCode = code || 0;
+  if (import_internal.globalProcess) {
+    import_internal.globalProcess.exitCode = exitCode;
+  }
+  (0, import_internal.emit)("exit", exitCode, void 0);
+  (0, import_internal.emit)("afterexit", exitCode, void 0);
+  (0, import_reflect.ReflectApply)(
+    import_internal.originalProcessReallyExit,
+    import_internal.globalProcess,
+    [exitCode]
+  );
+  throw new import_error.ErrorCtor("processReallyExit should never return");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processEmit,
+  processReallyExit
+});