@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/events/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
+});

package/dist/events/exit/lifecycle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file `load` and `unload` — install and remove the `signal-exit` listeners.
+ *   Co-located with `getSignalListeners` because the per-signal listener body
+ *   calls `unload()`; keeping them in the same leaf avoids an inter-leaf import
+ *   cycle.
+ */
+import type { SignalListenerMap } from './types';
+export declare function getSignalListeners(): SignalListenerMap;
+/**
+ * Load signal handlers and hook into process exit events.
+ *
+ * @example
+ *   ;```typescript
+ *   load()
+ *   // Signal handlers are now active
+ *   ```
+ */
+export declare function load(): void;
+/**
+ * Unload signal handlers and restore original process behavior.
+ *
+ * @example
+ *   ;```typescript
+ *   unload()
+ *   // Signal handlers are now removed
+ *   ```
+ */
+export declare function unload(): void;

package/dist/events/exit/lifecycle.js

@@ -0,0 +1,109 @@
+"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 lifecycle_exports = {};
+__export(lifecycle_exports, {
+  getSignalListeners: () => getSignalListeners,
+  load: () => load,
+  unload: () => unload
+});
+module.exports = __toCommonJS(lifecycle_exports);
+var import_internal = require("./_internal");
+var import_intercept = require("./intercept");
+let _sigListeners;
+// @__NO_SIDE_EFFECTS__
+function getSignalListeners() {
+  if (_sigListeners === void 0) {
+    _sigListeners = { __proto__: null };
+    const emitter = (0, import_internal.getEmitter)();
+    const sigs = (0, import_internal.getSignals)();
+    for (const sig of sigs) {
+      _sigListeners[sig] = function listener() {
+        const listeners = import_internal.globalProcess?.listeners(sig) || [];
+        if (listeners.length === emitter.count) {
+          /* @__PURE__ */ unload();
+          (0, import_internal.emit)("exit", void 0, sig);
+          (0, import_internal.emit)("afterexit", void 0, sig);
+          const killSig = import_internal.WIN32 && sig === "SIGHUP" ? "SIGINT" : sig;
+          import_internal.globalProcess?.kill(import_internal.globalProcess?.pid, killSig);
+        }
+      };
+    }
+  }
+  return _sigListeners;
+}
+// @__NO_SIDE_EFFECTS__
+function load() {
+  if ((0, import_internal.isLoaded)() || !import_internal.globalProcess) {
+    return;
+  }
+  (0, import_internal.setLoaded)(true);
+  const proc = import_internal.globalProcess;
+  const emitter = (0, import_internal.getEmitter)();
+  if (emitter.count !== void 0) {
+    emitter.count += 1;
+  }
+  const sigs = (0, import_internal.getSignals)();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  (0, import_internal.setSignals)(
+    sigs.filter((sig) => {
+      try {
+        proc.on(sig, sigListeners[sig]);
+        return true;
+      } catch {
+      }
+      return false;
+    })
+  );
+  proc.emit = import_intercept.processEmit;
+  proc.reallyExit = import_intercept.processReallyExit;
+}
+// @__NO_SIDE_EFFECTS__
+function unload() {
+  if (!(0, import_internal.isLoaded)() || !import_internal.globalProcess) {
+    return;
+  }
+  (0, import_internal.setLoaded)(false);
+  const sigs = (0, import_internal.getSignals)();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  for (const sig of sigs) {
+    try {
+      import_internal.globalProcess.removeListener(
+        sig,
+        sigListeners[sig]
+      );
+    } catch {
+    }
+  }
+  import_internal.globalProcess.emit = import_internal.originalProcessEmit;
+  if (import_internal.originalProcessReallyExit !== void 0) {
+    import_internal.globalProcess.reallyExit = import_internal.originalProcessReallyExit;
+  }
+  const emitter = (0, import_internal.getEmitter)();
+  if (emitter.count !== void 0) {
+    emitter.count -= 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSignalListeners,
+  load,
+  unload
+});

package/dist/events/exit/signals.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file `signals()` — list the signals this process is watching. Before
+ *   `load()` runs, returns the lazy-initialised default list; after `load()`
+ *   runs, returns the filtered subset that was actually registered
+ *   successfully.
+ */
+/**
+ * Get the list of signals that are currently being monitored.
+ *
+ * @example
+ *   ;```typescript
+ *   const sigs = signals()
+ *   console.log(sigs) // ['SIGABRT', 'SIGALRM', 'SIGHUP', ...]
+ *   ```
+ */
+export declare function signals(): string[];

package/dist/events/exit/signals.js

@@ -0,0 +1,34 @@
+"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 signals_exports = {};
+__export(signals_exports, {
+  signals: () => signals
+});
+module.exports = __toCommonJS(signals_exports);
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function signals() {
+  return (0, import_internal.getSignals)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  signals
+});

package/dist/events/exit/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Public type surface for `events/exit/*` modules — the `OnExitOptions`
+ *   consumed by `onExit`, plus the shared internal types for the signal
+ *   emitter, emitted-signal map, and listener map. Pure types, no runtime side
+ *   effects.
+ */
+export type EmittedSignals = {
+    [signal: string]: boolean;
+};
+export type SignalExitEmitter = import('node:events').EventEmitter & {
+    count?: number;
+    emitted?: EmittedSignals;
+    infinite?: boolean;
+};
+export type SignalListener = () => void;
+export type SignalListenerMap = {
+    [signal: string]: SignalListener;
+};
+export interface OnExitOptions {
+    alwaysLast?: boolean;
+}

package/dist/events/exit/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/events/warning/handler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Bump the max-listener cap on an EventTarget (or AbortSignal). Lives
+ *   next to the suppress-warnings family because the goal is the same — silence
+ *   Node's noise about exceeding the default 10-listener threshold — but the
+ *   mechanism is different: here we set the symbol on the target itself, no
+ *   `process.emitWarning` wrapping involved.
+ */
+/**
+ * Set max listeners on an EventTarget (like AbortSignal) to avoid TypeError.
+ *
+ * By manually setting `kMaxEventTargetListeners` on the target we avoid:
+ * TypeError [ERR_INVALID_ARG_TYPE]: The "emitter" argument must be an instance
+ * of EventEmitter or EventTarget. Received an instance of AbortSignal.
+ *
+ * In some patch releases of Node 18-23 when calling events.getMaxListeners().
+ * See https://github.com/nodejs/node/pull/56807.
+ *
+ * Instead of calling events.setMaxListeners(n, target) we set the symbol
+ * property directly to avoid depending on 'node:events' module.
+ *
+ * @example
+ *   import { setMaxEventTargetListeners } from '@socketsecurity/lib/events/warning/handler'
+ *
+ *   const controller = new AbortController()
+ *   setMaxEventTargetListeners(controller.signal)
+ *
+ * @param target - The EventTarget or AbortSignal to configure.
+ * @param maxListeners - Maximum number of listeners (defaults to 10, the
+ *   Node.js default)
+ */
+export declare function setMaxEventTargetListeners(target: EventTarget | AbortSignal | undefined, maxListeners?: number): void;

package/dist/events/warning/handler.js

@@ -0,0 +1,43 @@
+"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 handler_exports = {};
+__export(handler_exports, {
+  setMaxEventTargetListeners: () => setMaxEventTargetListeners
+});
+module.exports = __toCommonJS(handler_exports);
+var import_object = require("../../primordials/object");
+function setMaxEventTargetListeners(target, maxListeners = 10) {
+  if (!target) {
+    return;
+  }
+  const symbols = (0, import_object.ObjectGetOwnPropertySymbols)(target);
+  const kMaxEventTargetListeners = symbols.find(
+    (s) => s.description === "events.maxEventTargetListeners"
+  );
+  if (kMaxEventTargetListeners) {
+    ;
+    target[kMaxEventTargetListeners] = maxListeners;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setMaxEventTargetListeners
+});

package/dist/events/warning/suppress.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @file `process.emitWarning` suppression. Single shared wrapper installed on
+ *   first call, driven by a membership Set so repeated `suppressWarningType`
+ *   calls are cheap.
+ */
+/**
+ * Restore the original process.emitWarning function. Call this to re-enable all
+ * warnings after suppressing them.
+ *
+ * @example
+ *   ;```typescript
+ *   suppressMaxListenersWarning()
+ *   // ... do work ...
+ *   restoreWarnings() // Re-enable all warnings
+ *   ```
+ */
+export declare function restoreWarnings(): void;
+/**
+ * Internal function to set up warning suppression. Only wraps
+ * process.emitWarning once, regardless of how many times it's called.
+ */
+export declare function setupSuppression(): void;
+/**
+ * Silence `MaxListenersExceededWarning` messages from `process.emitWarning`.
+ * Installs a single shared wrapper around `process.emitWarning` on first call
+ * so repeat invocations are cheap.
+ *
+ * @example
+ *   import { suppressMaxListenersWarning } from '@socketsecurity/lib/events/warning/suppress'
+ *
+ *   suppressMaxListenersWarning()
+ */
+export declare function suppressMaxListenersWarning(): void;
+/**
+ * Suppress all process warnings of a specific type.
+ *
+ * @example
+ *   import { suppressWarningType } from '@socketsecurity/lib/events/warning/suppress'
+ *
+ *   suppressWarningType('ExperimentalWarning')
+ *
+ * @param warningType - The warning type to suppress (e.g.,
+ *   'DeprecationWarning', 'ExperimentalWarning')
+ */
+export declare function suppressWarningType(warningType: string): void;
+/**
+ * Suppress warnings temporarily within a callback.
+ *
+ * @example
+ *   import { withSuppressedWarnings } from '@socketsecurity/lib/events/warning/suppress'
+ *
+ *   const result = await withSuppressedWarnings(
+ *     'ExperimentalWarning',
+ *     async () => {
+ *       // Code that triggers experimental warnings
+ *       return someValue
+ *     },
+ *   )
+ *
+ * @param warningType - The warning type to suppress.
+ * @param callback - Function to execute with warnings suppressed.
+ *
+ * @returns The result of the callback
+ */
+export declare function withSuppressedWarnings<T>(warningType: string, callback: () => T | Promise<T>): Promise<T>;

package/dist/{suppress-warnings.js → events/warning/suppress.js}

@@ -28,19 +28,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var suppress_warnings_exports = {};
-__export(suppress_warnings_exports, {
+var suppress_exports = {};
+__export(suppress_exports, {
   restoreWarnings: () => restoreWarnings,
-  setMaxEventTargetListeners: () => setMaxEventTargetListeners,
+  setupSuppression: () => setupSuppression,
   suppressMaxListenersWarning: () => suppressMaxListenersWarning,
   suppressWarningType: () => suppressWarningType,
   withSuppressedWarnings: () => withSuppressedWarnings
 });
-module.exports = __toCommonJS(suppress_warnings_exports);
+module.exports = __toCommonJS(suppress_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_primordials = require("./primordials");
+var import_map_set = require("../../primordials/map-set");
+var import_reflect = require("../../primordials/reflect");
 let originalEmitWarning;
-const suppressedWarnings = new import_primordials.SetCtor();
+const suppressedWarnings = new import_map_set.SetCtor();
+function restoreWarnings() {
+  if (originalEmitWarning) {
+    import_node_process.default.emitWarning = originalEmitWarning;
+    originalEmitWarning = void 0;
+    suppressedWarnings.clear();
+  }
+}
 function setupSuppression() {
   if (!originalEmitWarning) {
     originalEmitWarning = import_node_process.default.emitWarning;
@@ -57,7 +65,7 @@ function setupSuppression() {
           return;
         }
       }
-      return (0, import_primordials.ReflectApply)(
+      return (0, import_reflect.ReflectApply)(
         originalEmitWarning,
         import_node_process.default,
         [warning, ...args]
@@ -65,26 +73,6 @@ function setupSuppression() {
     };
   }
 }
-function restoreWarnings() {
-  if (originalEmitWarning) {
-    import_node_process.default.emitWarning = originalEmitWarning;
-    originalEmitWarning = void 0;
-    suppressedWarnings.clear();
-  }
-}
-function setMaxEventTargetListeners(target, maxListeners = 10) {
-  if (!target) {
-    return;
-  }
-  const symbols = (0, import_primordials.ObjectGetOwnPropertySymbols)(target);
-  const kMaxEventTargetListeners = symbols.find(
-    (s) => s.description === "events.maxEventTargetListeners"
-  );
-  if (kMaxEventTargetListeners) {
-    ;
-    target[kMaxEventTargetListeners] = maxListeners;
-  }
-}
 function suppressMaxListenersWarning() {
   suppressedWarnings.add("MaxListenersExceededWarning");
   setupSuppression();
@@ -107,7 +95,7 @@ async function withSuppressedWarnings(warningType, callback) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   restoreWarnings,
-  setMaxEventTargetListeners,
+  setupSuppression,
   suppressMaxListenersWarning,
   suppressWarningType,
   withSuppressedWarnings

package/dist/external/@npmcli/package-json/lib/read-package.js

@@ -1,4 +1,14 @@
-const { ArrayIsArray: _p_ArrayIsArray, BufferIsBuffer: _p_BufferIsBuffer, JSONParse: _p_JSONParse, ObjectAssign: _p_ObjectAssign, StringPrototypeCharCodeAt: _p_StringPrototypeCharCodeAt, TypeErrorCtor: _p_TypeErrorCtor } = require('../../../../primordials.js')
+const { ArrayIsArray: _p_ArrayIsArray } = require('../../../../primordials/array.js')
+const { BufferIsBuffer: _p_BufferIsBuffer } = require('../../../../primordials/buffer.js')
+
+const { TypeErrorCtor: _p_TypeErrorCtor } = require('../../../../primordials/error.js')
+
+const { JSONParse: _p_JSONParse } = require('../../../../primordials/json.js')
+
+const { ObjectAssign: _p_ObjectAssign } = require('../../../../primordials/object.js')
+
+const { StringPrototypeCharCodeAt: _p_StringPrototypeCharCodeAt } = require('../../../../primordials/string.js')
+
 "use strict";
 /**
  * Bundled from @npmcli/package-json/lib/read-package.js