@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/sea.js

@@ -0,0 +1,46 @@
+/* Socket Lib - Built with esbuild */
+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 sea_exports = {};
+__export(sea_exports, {
+  getSeaBinaryPath: () => getSeaBinaryPath,
+  isSeaBinary: () => isSeaBinary
+});
+module.exports = __toCommonJS(sea_exports);
+var import_path = require("./path");
+let _isSea;
+function getSeaBinaryPath() {
+  return isSeaBinary() && process.argv[0] ? (0, import_path.normalizePath)(process.argv[0]) : void 0;
+}
+function isSeaBinary() {
+  if (_isSea === void 0) {
+    try {
+      const seaModule = require("node:sea");
+      _isSea = seaModule.isSea();
+    } catch {
+      _isSea = false;
+    }
+  }
+  return _isSea ?? false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSeaBinaryPath,
+  isSeaBinary
+});
+//# sourceMappingURL=sea.js.map

package/dist/sea.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sea.ts"],
+  "sourcesContent": ["/**\n * @fileoverview SEA (Single Executable Application) detection utilities for Socket ecosystem.\n * Provides reliable detection of whether the current process is running\n * as a Node.js Single Executable Application.\n */\n\nimport { normalizePath } from './path'\n\n/**\n * Cached SEA detection result.\n */\nlet _isSea: boolean | undefined\n\n/**\n * Get the current SEA binary path.\n * Only valid when running as a SEA binary.\n */\nexport function getSeaBinaryPath(): string | undefined {\n  return isSeaBinary() && process.argv[0]\n    ? normalizePath(process.argv[0])\n    : undefined\n}\n\n/**\n * Detect if the current process is running as a SEA binary.\n * Uses Node.js 24+ native API with caching for performance.\n */\nexport function isSeaBinary(): boolean {\n  if (_isSea === undefined) {\n    try {\n      // Use Node.js 24+ native SEA detection API.\n      // eslint-disable-next-line n/no-unsupported-features/node-builtins\n      const seaModule = require('node:sea')\n      _isSea = seaModule.isSea()\n    } catch {\n      // Node.js < 24 or SEA module not available.\n      _isSea = false\n    }\n  }\n  return _isSea ?? false\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAA8B;AAK9B,IAAI;AAMG,SAAS,mBAAuC;AACrD,SAAO,YAAY,KAAK,QAAQ,KAAK,CAAC,QAClC,2BAAc,QAAQ,KAAK,CAAC,CAAC,IAC7B;AACN;AAMO,SAAS,cAAuB;AACrC,MAAI,WAAW,QAAW;AACxB,QAAI;AAGF,YAAM,YAAY,QAAQ,UAAU;AACpC,eAAS,UAAU,MAAM;AAAA,IAC3B,QAAQ;AAEN,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO,UAAU;AACnB;",
+  "names": []
+}

package/dist/shadow.d.ts

@@ -0,0 +1,17 @@
+export interface ShadowInstallationOptions {
+    cwd?: string | undefined;
+    win32?: boolean | undefined;
+}
+/**
+ * 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)
+ *
+ * @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

@@ -0,0 +1,60 @@
+/* Socket Lib - Built with esbuild */
+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 shadow_exports = {};
+__export(shadow_exports, {
+  shouldSkipShadow: () => shouldSkipShadow
+});
+module.exports = __toCommonJS(shadow_exports);
+var import_path = require("./path");
+function shouldSkipShadow(binPath, options) {
+  const { cwd = process.cwd(), win32 = false } = {
+    __proto__: null,
+    ...options
+  };
+  if (win32 && binPath) {
+    return true;
+  }
+  const userAgent = process.env["npm_config_user_agent"];
+  if (userAgent?.includes("exec") || userAgent?.includes("npx") || userAgent?.includes("dlx")) {
+    return true;
+  }
+  const normalizedCwd = (0, import_path.normalizePath)(cwd);
+  const npmCache = process.env["npm_config_cache"];
+  if (npmCache && normalizedCwd.includes((0, import_path.normalizePath)(npmCache))) {
+    return true;
+  }
+  const tempPatterns = [
+    // npm's npx cache directory
+    "_npx",
+    // pnpm dlx temporary store
+    ".pnpm-store",
+    // Common dlx directory prefix
+    "dlx-",
+    // Yarn Berry PnP virtual packages.
+    ".yarn/$$",
+    // Yarn on Windows uses normalized forward slash paths.
+    "AppData/Local/Temp/xfs-"
+  ];
+  return tempPatterns.some((pattern) => normalizedCwd.includes(pattern));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shouldSkipShadow
+});
+//# sourceMappingURL=shadow.js.map

package/dist/shadow.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/shadow.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Shadow binary installation utilities for Socket ecosystem.\n * Provides logic to determine when shadow binary installation should be skipped.\n */\n\nimport { normalizePath } from './path'\n\nexport interface ShadowInstallationOptions {\n  cwd?: string | undefined\n  win32?: boolean | undefined\n}\n\n/**\n * Determines if shadow binaries should be installed.\n * Shadows should NOT be installed when:\n * - Running in a temporary execution context (exec/npx/dlx)\n * - On Windows with an existing binary path (required for Windows to function)\n *\n * @param binPath - Path to the binary being shadowed\n * @param options - Configuration options\n * @param options.cwd - Current working directory path to check\n * @param options.win32 - Whether running on Windows\n * @returns true if shadow installation should be skipped\n */\nexport function shouldSkipShadow(\n  binPath: string,\n  options?: ShadowInstallationOptions | undefined,\n): boolean {\n  const { cwd = process.cwd(), win32 = false } = {\n    __proto__: null,\n    ...options,\n  } as ShadowInstallationOptions\n\n  // Windows compatibility: Skip shadow installation if binary is already found.\n  //\n  // This check is required because Windows handles executables differently than Unix:\n  // 1. File locking - Windows locks running executables, so cmd-shim creation would\n  //    fail with EBUSY/EACCES errors when trying to create wrapper files.\n  // 2. PATH conflicts - Attempting to shadow an already-resolved binary can create\n  //    circular references or ambiguous command resolution.\n  // 3. Registry integration - Windows package managers often use system-level\n  //    integrations beyond just PATH that our shadowing would interfere with.\n  //\n  // Without this check, users would see \"Access Denied\" or file locking errors\n  // that are difficult to debug. This is not a performance optimization - the\n  // shadow installation will fail without it.\n  if (win32 && binPath) {\n    return true\n  }\n\n  // Check environment variable for exec/npx/dlx indicators.\n  const userAgent = process.env['npm_config_user_agent']\n  if (\n    userAgent?.includes('exec') ||\n    userAgent?.includes('npx') ||\n    userAgent?.includes('dlx')\n  ) {\n    return true\n  }\n\n  // Normalize the cwd path for consistent checking across platforms.\n  const normalizedCwd = normalizePath(cwd)\n\n  // Check if running from npm's npx cache.\n  const npmCache = process.env['npm_config_cache']\n  if (npmCache && normalizedCwd.includes(normalizePath(npmCache))) {\n    return true\n  }\n\n  // Check common temporary execution path patterns.\n  const tempPatterns = [\n    // npm's npx cache directory\n    '_npx',\n    // pnpm dlx temporary store\n    '.pnpm-store',\n    // Common dlx directory prefix\n    'dlx-',\n    // Yarn Berry PnP virtual packages.\n    '.yarn/$$',\n    // Yarn on Windows uses normalized forward slash paths.\n    'AppData/Local/Temp/xfs-',\n  ]\n\n  return tempPatterns.some(pattern => normalizedCwd.includes(pattern))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,kBAA8B;AAmBvB,SAAS,iBACd,SACA,SACS;AACT,QAAM,EAAE,MAAM,QAAQ,IAAI,GAAG,QAAQ,MAAM,IAAI;AAAA,IAC7C,WAAW;AAAA,IACX,GAAG;AAAA,EACL;AAeA,MAAI,SAAS,SAAS;AACpB,WAAO;AAAA,EACT;AAGA,QAAM,YAAY,QAAQ,IAAI,uBAAuB;AACrD,MACE,WAAW,SAAS,MAAM,KAC1B,WAAW,SAAS,KAAK,KACzB,WAAW,SAAS,KAAK,GACzB;AACA,WAAO;AAAA,EACT;AAGA,QAAM,oBAAgB,2BAAc,GAAG;AAGvC,QAAM,WAAW,QAAQ,IAAI,kBAAkB;AAC/C,MAAI,YAAY,cAAc,aAAS,2BAAc,QAAQ,CAAC,GAAG;AAC/D,WAAO;AAAA,EACT;AAGA,QAAM,eAAe;AAAA;AAAA,IAEnB;AAAA;AAAA,IAEA;AAAA;AAAA,IAEA;AAAA;AAAA,IAEA;AAAA;AAAA,IAEA;AAAA,EACF;AAEA,SAAO,aAAa,KAAK,aAAW,cAAc,SAAS,OAAO,CAAC;AACrE;",
+  "names": []
+}

package/dist/signal-exit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Load signal handlers and hook into process exit events.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function load(): void;
+export interface OnExitOptions {
+    alwaysLast?: boolean;
+}
+/**
+ * Register a callback to run on process exit or signal.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function onExit(cb: (code: number | null, signal: string | null) => void, options?: OnExitOptions | undefined): () => void;
+/**
+ * Get the list of signals that are currently being monitored.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function signals(): string[] | undefined;
+/**
+ * Unload signal handlers and restore original process behavior.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function unload(): void;

package/dist/signal-exit.js

@@ -0,0 +1,250 @@
+/* Socket Lib - Built with esbuild */
+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 signal_exit_exports = {};
+__export(signal_exit_exports, {
+  load: () => load,
+  onExit: () => onExit,
+  signals: () => signals,
+  unload: () => unload
+});
+module.exports = __toCommonJS(signal_exit_exports);
+const ReflectApply = Reflect.apply;
+const globalProcess = globalThis.process;
+const originalProcessEmit = globalProcess?.emit;
+const platform = globalProcess?.platform ?? "";
+const originalProcessReallyExit = globalProcess?.reallyExit;
+const WIN32 = platform === "win32";
+let _events;
+// @__NO_SIDE_EFFECTS__
+function getEvents() {
+  if (_events === void 0) {
+    _events = require("node:events");
+  }
+  return _events;
+}
+let _emitter;
+// @__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;
+}
+let _sigListeners;
+// @__NO_SIDE_EFFECTS__
+function getSignalListeners() {
+  if (_sigListeners === void 0) {
+    _sigListeners = { __proto__: null };
+    const emitter = /* @__PURE__ */ getEmitter();
+    const sigs = /* @__PURE__ */ getSignals();
+    for (const sig of sigs) {
+      _sigListeners[sig] = function listener() {
+        const listeners = globalProcess?.listeners(sig) || [];
+        if (listeners.length === emitter.count) {
+          /* @__PURE__ */ unload();
+          /* @__PURE__ */ emit("exit", null, sig);
+          /* @__PURE__ */ emit("afterexit", null, sig);
+          const killSig = WIN32 && sig === "SIGHUP" ? "SIGINT" : sig;
+          globalProcess?.kill(globalProcess?.pid, killSig);
+        }
+      };
+    }
+  }
+  return _sigListeners;
+}
+let _signals;
+// @__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"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (platform === "linux") {
+      _signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+    }
+  }
+  return _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);
+}
+let loaded = false;
+// @__NO_SIDE_EFFECTS__
+function load() {
+  if (loaded || !globalProcess) {
+    return;
+  }
+  loaded = true;
+  const emitter = /* @__PURE__ */ getEmitter();
+  if (emitter.count !== void 0) {
+    emitter.count += 1;
+  }
+  const sigs = /* @__PURE__ */ getSignals();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  _signals = sigs.filter((sig) => {
+    try {
+      globalProcess.on(
+        sig,
+        sigListeners[sig]
+      );
+      return true;
+    } catch {
+    }
+    return false;
+  });
+  globalProcess.emit = processEmit;
+  globalProcess.reallyExit = processReallyExit;
+}
+// @__NO_SIDE_EFFECTS__
+function processEmit(eventName, exitCode, ...args) {
+  if (eventName === "exit") {
+    let actualExitCode = exitCode;
+    if (actualExitCode === void 0) {
+      const processExitCode = globalProcess?.exitCode;
+      actualExitCode = typeof processExitCode === "number" ? processExitCode : void 0;
+    } else if (globalProcess) {
+      globalProcess.exitCode = actualExitCode;
+    }
+    const result = ReflectApply(
+      originalProcessEmit,
+      this,
+      [eventName, actualExitCode, ...args]
+    );
+    const numExitCode = typeof actualExitCode === "number" ? actualExitCode : null;
+    /* @__PURE__ */ emit("exit", numExitCode, null);
+    /* @__PURE__ */ emit("afterexit", numExitCode, null);
+    return result;
+  }
+  return ReflectApply(
+    originalProcessEmit,
+    this,
+    [eventName, exitCode, ...args]
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function processReallyExit(code) {
+  const exitCode = code || 0;
+  if (globalProcess) {
+    globalProcess.exitCode = exitCode;
+  }
+  /* @__PURE__ */ emit("exit", exitCode, null);
+  /* @__PURE__ */ emit("afterexit", exitCode, null);
+  ReflectApply(
+    originalProcessReallyExit,
+    globalProcess,
+    [exitCode]
+  );
+  throw new Error("processReallyExit should never return");
+}
+// @__NO_SIDE_EFFECTS__
+function onExit(cb, options) {
+  if (!globalProcess) {
+    return function remove() {
+    };
+  }
+  if (typeof cb !== "function") {
+    throw new TypeError("a callback must be provided for exit handler");
+  }
+  if (loaded === false) {
+    /* @__PURE__ */ load();
+  }
+  const { alwaysLast } = { __proto__: null, ...options };
+  let eventName = "exit";
+  if (alwaysLast) {
+    eventName = "afterexit";
+  }
+  const emitter = /* @__PURE__ */ getEmitter();
+  emitter.on(eventName, cb);
+  return function remove() {
+    emitter.removeListener(eventName, cb);
+    if (!emitter.listeners("exit").length && !emitter.listeners("afterexit").length) {
+      /* @__PURE__ */ unload();
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function signals() {
+  return _signals;
+}
+// @__NO_SIDE_EFFECTS__
+function unload() {
+  if (!loaded || !globalProcess) {
+    return;
+  }
+  loaded = false;
+  const sigs = /* @__PURE__ */ getSignals();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  for (const sig of sigs) {
+    try {
+      globalProcess.removeListener(
+        sig,
+        sigListeners[sig]
+      );
+    } catch {
+    }
+  }
+  globalProcess.emit = originalProcessEmit;
+  if (originalProcessReallyExit !== void 0) {
+    globalProcess.reallyExit = originalProcessReallyExit;
+  }
+  const emitter = /* @__PURE__ */ getEmitter();
+  if (emitter.count !== void 0) {
+    emitter.count -= 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  load,
+  onExit,
+  signals,
+  unload
+});
+//# sourceMappingURL=signal-exit.js.map

package/dist/signal-exit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/signal-exit.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Process signal handling utilities.\n * Provides cross-platform signal exit detection and cleanup handlers.\n */\n\n// Inlined signal-exit:\n// https://socket.dev/npm/package/signal-exit/overview/4.1.0\n// ISC License\n// Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and Contributors\n\n// This is not the set of all possible signals.\n//\n// It IS, however, the set of all signals that trigger\n// an exit on either Linux or BSD systems. Linux is a\n// superset of the signal names supported on BSD, and\n// the unknown signals just fail to register, so we can\n// catch that easily enough.\n//\n// Don't bother with SIGKILL. It's uncatchable, which\n// means that we can't fire any callbacks anyway.\n//\n// If a user does happen to register a handler on a non-\n// fatal signal like SIGWINCH or something, and then\n// exit, it'll end up firing `process.emit('exit')`, so\n// the handler will be fired anyway.\n//\n// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised\n// artificially, inherently leave the process in a\n// state from which it is not safe to try and enter JS\n// listeners.\n\n// IMPORTANT: Do not use destructuring here - use direct assignment instead.\n// tsgo has a bug that incorrectly transpiles destructured exports, resulting in\n// `exports.SomeName = void 0;` which causes runtime errors.\n// See: https://github.com/SocketDev/socket-packageurl-js/issues/3\nconst ReflectApply = Reflect.apply\nconst globalProcess = globalThis.process as\n  | (NodeJS.Process & {\n      // biome-ignore lint/suspicious/noExplicitAny: Signal exit emitter can be any event emitter.\n      __signal_exit_emitter__?: any\n      reallyExit?: (code?: number | undefined) => never\n    })\n  | undefined\nconst originalProcessEmit = globalProcess?.emit\nconst platform = globalProcess?.platform ?? ''\nconst originalProcessReallyExit = globalProcess?.reallyExit as\n  | ((code?: number | undefined) => never)\n  | undefined\nconst WIN32 = platform === 'win32'\n\nlet _events: typeof import('node:events') | undefined\n/*@__NO_SIDE_EFFECTS__*/\nfunction getEvents() {\n  if (_events === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _events = /*@__PURE__*/ require('node:events')\n  }\n  return _events as typeof import('node:events')\n}\n\n// Type for tracking emitted signals.\ntype EmittedSignals = {\n  // Using string as signals can include custom events like 'exit' and 'afterexit'.\n  [signal: string]: boolean\n}\n\ntype SignalExitEmitter = import('node:events').EventEmitter & {\n  count?: number\n  emitted?: EmittedSignals\n  infinite?: boolean\n}\nlet _emitter: SignalExitEmitter | undefined\n/*@__NO_SIDE_EFFECTS__*/\nfunction getEmitter() {\n  if (_emitter === undefined) {\n    if (globalProcess?.__signal_exit_emitter__) {\n      _emitter = globalProcess.__signal_exit_emitter__\n    } else if (globalProcess) {\n      const EventEmitter = getEvents().EventEmitter\n      _emitter = globalProcess.__signal_exit_emitter__ =\n        new EventEmitter() as SignalExitEmitter\n      _emitter.count = 0\n      _emitter.emitted = { __proto__: null } as unknown as EmittedSignals\n    }\n    // Because this emitter is a global, we have to check to see if a\n    // previous version of this library failed to enable infinite listeners.\n    // I know what you're about to say.  But literally everything about\n    // signal-exit is a compromise with evil.  Get used to it.\n    if (_emitter && !_emitter.infinite) {\n      _emitter.setMaxListeners(Number.POSITIVE_INFINITY)\n      _emitter.infinite = true\n    }\n  }\n  return _emitter as SignalExitEmitter\n}\n\ntype SignalListener = () => void\n// Type for signal listeners indexed by signal name.\ntype SignalListenerMap = {\n  [signal: string]: SignalListener\n}\nlet _sigListeners: SignalListenerMap | undefined\n/*@__NO_SIDE_EFFECTS__*/\nfunction getSignalListeners() {\n  if (_sigListeners === undefined) {\n    _sigListeners = { __proto__: null } as unknown as SignalListenerMap\n    const emitter = getEmitter()\n    const sigs = getSignals()\n    for (const sig of sigs) {\n      _sigListeners[sig] = function listener() {\n        // If there are no other listeners, an exit is coming!\n        // Simplest way: remove us and then re-send the signal.\n        // We know that this will kill the process, so we can\n        // safely emit now.\n        const listeners = globalProcess?.listeners(sig as NodeJS.Signals) || []\n        if (listeners.length === emitter.count) {\n          unload()\n          emit('exit', null, sig)\n          emit('afterexit', null, sig)\n          // \"SIGHUP\" throws an `ENOSYS` error on Windows,\n          // so use a supported signal instead.\n          const killSig = WIN32 && sig === 'SIGHUP' ? 'SIGINT' : sig\n          globalProcess?.kill(globalProcess?.pid, killSig)\n        }\n      }\n    }\n  }\n  return _sigListeners as SignalListenerMap\n}\n\nlet _signals: string[] | undefined\n/*@__NO_SIDE_EFFECTS__*/\nfunction getSignals() {\n  if (_signals === undefined) {\n    _signals = ['SIGABRT', 'SIGALRM', 'SIGHUP', 'SIGINT', 'SIGTERM']\n    if (!WIN32) {\n      _signals.push(\n        'SIGVTALRM',\n        'SIGXCPU',\n        'SIGXFSZ',\n        'SIGUSR2',\n        'SIGTRAP',\n        'SIGSYS',\n        'SIGQUIT',\n        'SIGIOT',\n        // should detect profiler and enable/disable accordingly.\n        // see #21\n        // 'SIGPROF'\n      )\n    }\n    if (platform === 'linux') {\n      _signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT', 'SIGUNUSED')\n    }\n  }\n  return _signals as string[]\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction emit(event: string, code: number | null, signal: string | null): void {\n  const emitter = getEmitter()\n  if (emitter.emitted?.[event]) {\n    return\n  }\n  if (emitter.emitted) {\n    emitter.emitted[event] = true\n  }\n  emitter.emit(event, code, signal)\n}\n\nlet loaded = false\n\n/**\n * Load signal handlers and hook into process exit events.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function load(): void {\n  if (loaded || !globalProcess) {\n    return\n  }\n  loaded = true\n\n  // This is the number of onSignalExit's that are in play.\n  // It's important so that we can count the correct number of\n  // listeners on signals, and don't wait for the other one to\n  // handle it instead of us.\n  const emitter = getEmitter()\n  if (emitter.count !== undefined) {\n    emitter.count += 1\n  }\n\n  const sigs = getSignals()\n  const sigListeners = getSignalListeners()\n  _signals = sigs.filter(sig => {\n    try {\n      globalProcess.on(\n        sig as NodeJS.Signals,\n        sigListeners[sig] as SignalListener,\n      )\n      return true\n    } catch {}\n    return false\n  })\n\n  globalProcess.emit = processEmit as typeof globalProcess.emit\n  globalProcess.reallyExit = processReallyExit\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction processEmit(\n  this: NodeJS.Process,\n  eventName: string,\n  exitCode?: number | undefined,\n  // biome-ignore lint/suspicious/noExplicitAny: Process emit args can be any type.\n  ...args: any[]\n): boolean {\n  if (eventName === 'exit') {\n    let actualExitCode = exitCode\n    if (actualExitCode === undefined) {\n      const processExitCode = globalProcess?.exitCode\n      actualExitCode =\n        typeof processExitCode === 'number' ? processExitCode : undefined\n    } else if (globalProcess) {\n      globalProcess.exitCode = actualExitCode\n    }\n    const result = ReflectApply(\n      originalProcessEmit as (...args: unknown[]) => boolean,\n      this,\n      [eventName, actualExitCode, ...args],\n    ) as boolean\n    const numExitCode =\n      typeof actualExitCode === 'number' ? actualExitCode : null\n    emit('exit', numExitCode, null)\n    emit('afterexit', numExitCode, null)\n    return result\n  }\n  return ReflectApply(\n    originalProcessEmit as (...args: unknown[]) => boolean,\n    this,\n    [eventName, exitCode, ...args],\n  ) as boolean\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction processReallyExit(code?: number | undefined): never {\n  const exitCode = code || 0\n  if (globalProcess) {\n    globalProcess.exitCode = exitCode\n  }\n  emit('exit', exitCode, null)\n  emit('afterexit', exitCode, null)\n  ReflectApply(\n    originalProcessReallyExit as (code?: number) => never,\n    globalProcess,\n    [exitCode],\n  )\n  throw new Error('processReallyExit should never return')\n}\n\nexport interface OnExitOptions {\n  alwaysLast?: boolean\n}\n\n/**\n * Register a callback to run on process exit or signal.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function onExit(\n  cb: (code: number | null, signal: string | null) => void,\n  options?: OnExitOptions | undefined,\n): () => void {\n  if (!globalProcess) {\n    return function remove() {}\n  }\n  if (typeof cb !== 'function') {\n    throw new TypeError('a callback must be provided for exit handler')\n  }\n  if (loaded === false) {\n    load()\n  }\n  const { alwaysLast } = { __proto__: null, ...options } as OnExitOptions\n\n  let eventName = 'exit'\n  if (alwaysLast) {\n    eventName = 'afterexit'\n  }\n\n  const emitter = getEmitter()\n  emitter.on(eventName, cb)\n\n  return function remove() {\n    emitter.removeListener(eventName, cb)\n    if (\n      !emitter.listeners('exit').length &&\n      !emitter.listeners('afterexit').length\n    ) {\n      unload()\n    }\n  }\n}\n\n/**\n * Get the list of signals that are currently being monitored.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function signals(): string[] | undefined {\n  return _signals\n}\n\n/**\n * Unload signal handlers and restore original process behavior.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function unload(): void {\n  if (!loaded || !globalProcess) {\n    return\n  }\n  loaded = false\n\n  const sigs = getSignals()\n  const sigListeners = getSignalListeners()\n  for (const sig of sigs) {\n    try {\n      globalProcess.removeListener(\n        sig as NodeJS.Signals,\n        sigListeners[sig] as SignalListener,\n      )\n    } catch {}\n  }\n  globalProcess.emit = originalProcessEmit as typeof globalProcess.emit\n  if (originalProcessReallyExit !== undefined) {\n    globalProcess.reallyExit = originalProcessReallyExit\n  }\n  const emitter = getEmitter()\n  if (emitter.count !== undefined) {\n    emitter.count -= 1\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/sorts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compare two strings using locale-aware comparison.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function localeCompare(x: string, y: string): number;
+/**
+ * Compare two strings using natural sorting (numeric-aware, case-insensitive).
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function naturalCompare(x: string, y: string): number;
+// Type for fast-sort sorter function.
+type FastSortFunction = ReturnType<typeof import('fast-sort').createNewSortInstance>;
+/**
+ * Sort an array using natural comparison.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function naturalSorter<T>(arrayToSort: T[]): ReturnType<FastSortFunction>;
+/**
+ * Simple string comparison.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function compareStr(a: string, b: string): number;
+/**
+ * Compare semantic versions.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function compareSemver(a: string, b: string): number;
+export {};

package/dist/sorts.js

@@ -0,0 +1,96 @@
+/* Socket Lib - Built with esbuild */
+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 sorts_exports = {};
+__export(sorts_exports, {
+  compareSemver: () => compareSemver,
+  compareStr: () => compareStr,
+  localeCompare: () => localeCompare,
+  naturalCompare: () => naturalCompare,
+  naturalSorter: () => naturalSorter
+});
+module.exports = __toCommonJS(sorts_exports);
+let _localeCompare;
+// @__NO_SIDE_EFFECTS__
+function localeCompare(x, y) {
+  if (_localeCompare === void 0) {
+    _localeCompare = new Intl.Collator().compare;
+  }
+  return _localeCompare(x, y);
+}
+let _naturalCompare;
+// @__NO_SIDE_EFFECTS__
+function naturalCompare(x, y) {
+  if (_naturalCompare === void 0) {
+    _naturalCompare = new Intl.Collator(
+      // The `undefined` locale means it uses the default locale of the user's
+      // environment.
+      void 0,
+      {
+        // Enables numeric sorting: numbers in strings are compared by value,
+        // e.g. 'file2' comes before 'file10' as numbers and not 'file10' before
+        // 'file2' as plain text.
+        numeric: true,
+        // Makes the comparison case-insensitive and ignores diacritics, e.g.
+        // 'a', 'A', and 'á' are treated as equivalent.
+        sensitivity: "base"
+      }
+    ).compare;
+  }
+  return _naturalCompare(x, y);
+}
+let _naturalSorter;
+// @__NO_SIDE_EFFECTS__
+function naturalSorter(arrayToSort) {
+  if (_naturalSorter === void 0) {
+    const fastSort = require("./external/fast-sort");
+    _naturalSorter = fastSort.createNewSortInstance({
+      comparer: naturalCompare
+    });
+  }
+  return _naturalSorter?.(arrayToSort);
+}
+// @__NO_SIDE_EFFECTS__
+function compareStr(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+// @__NO_SIDE_EFFECTS__
+function compareSemver(a, b) {
+  const semver = require("./external/semver");
+  const validA = semver.valid(a);
+  const validB = semver.valid(b);
+  if (!validA && !validB) {
+    return 0;
+  }
+  if (!validA) {
+    return -1;
+  }
+  if (!validB) {
+    return 1;
+  }
+  return semver.compare(a, b);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compareSemver,
+  compareStr,
+  localeCompare,
+  naturalCompare,
+  naturalSorter
+});
+//# sourceMappingURL=sorts.js.map

package/dist/sorts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sorts.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Sorting comparison functions including locale-aware and natural sorting.\n * Provides various comparison utilities for arrays and collections.\n */\n\nlet _localeCompare: ((x: string, y: string) => number) | undefined\n/**\n * Compare two strings using locale-aware comparison.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function localeCompare(x: string, y: string): number {\n  if (_localeCompare === undefined) {\n    // Lazily call new Intl.Collator() because in Node it can take 10-14ms.\n    _localeCompare = new Intl.Collator().compare\n  }\n  return _localeCompare(x, y)\n}\n\nlet _naturalCompare: ((x: string, y: string) => number) | undefined\n/**\n * Compare two strings using natural sorting (numeric-aware, case-insensitive).\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function naturalCompare(x: string, y: string): number {\n  if (_naturalCompare === undefined) {\n    // Lazily call new Intl.Collator() because in Node it can take 10-14ms.\n    _naturalCompare = new Intl.Collator(\n      // The `undefined` locale means it uses the default locale of the user's\n      // environment.\n      undefined,\n      {\n        // Enables numeric sorting: numbers in strings are compared by value,\n        // e.g. 'file2' comes before 'file10' as numbers and not 'file10' before\n        // 'file2' as plain text.\n        numeric: true,\n        // Makes the comparison case-insensitive and ignores diacritics, e.g.\n        // 'a', 'A', and '\u00E1' are treated as equivalent.\n        sensitivity: 'base',\n      },\n    ).compare\n  }\n  return _naturalCompare(x, y)\n}\n\n// Type for fast-sort sorter function.\ntype FastSortFunction = ReturnType<\n  typeof import('fast-sort').createNewSortInstance\n>\n\nlet _naturalSorter: FastSortFunction | undefined\n/**\n * Sort an array using natural comparison.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function naturalSorter<T>(\n  arrayToSort: T[],\n): ReturnType<FastSortFunction> {\n  if (_naturalSorter === undefined) {\n    const fastSort = /*@__PURE__*/ require('./external/fast-sort')\n    // biome-ignore lint/suspicious/noExplicitAny: Fast-sort API requires dynamic method access.\n    _naturalSorter = (fastSort as any).createNewSortInstance({\n      comparer: naturalCompare,\n    })\n  }\n  return _naturalSorter?.(arrayToSort)\n}\n\n/**\n * Simple string comparison.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function compareStr(a: string, b: string): number {\n  return a < b ? -1 : a > b ? 1 : 0\n}\n\n/**\n * Compare semantic versions.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function compareSemver(a: string, b: string): number {\n  const semver = /*@__PURE__*/ require('./external/semver')\n  const validA = semver.valid(a)\n  const validB = semver.valid(b)\n\n  if (!validA && !validB) {\n    return 0\n  }\n  if (!validA) {\n    return -1\n  }\n  if (!validB) {\n    return 1\n  }\n  // biome-ignore lint/suspicious/noExplicitAny: Semver API requires dynamic method access.\n  return (semver as any).compare(a, b)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,IAAI;AAAA;AAKG,SAAS,cAAc,GAAW,GAAmB;AAC1D,MAAI,mBAAmB,QAAW;AAEhC,qBAAiB,IAAI,KAAK,SAAS,EAAE;AAAA,EACvC;AACA,SAAO,eAAe,GAAG,CAAC;AAC5B;AAEA,IAAI;AAAA;AAKG,SAAS,eAAe,GAAW,GAAmB;AAC3D,MAAI,oBAAoB,QAAW;AAEjC,sBAAkB,IAAI,KAAK;AAAA;AAAA;AAAA,MAGzB;AAAA,MACA;AAAA;AAAA;AAAA;AAAA,QAIE,SAAS;AAAA;AAAA;AAAA,QAGT,aAAa;AAAA,MACf;AAAA,IACF,EAAE;AAAA,EACJ;AACA,SAAO,gBAAgB,GAAG,CAAC;AAC7B;AAOA,IAAI;AAAA;AAKG,SAAS,cACd,aAC8B;AAC9B,MAAI,mBAAmB,QAAW;AAChC,UAAM,WAAyB,QAAQ,sBAAsB;AAE7D,qBAAkB,SAAiB,sBAAsB;AAAA,MACvD,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACA,SAAO,iBAAiB,WAAW;AACrC;AAAA;AAMO,SAAS,WAAW,GAAW,GAAmB;AACvD,SAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI;AAClC;AAAA;AAMO,SAAS,cAAc,GAAW,GAAmB;AAC1D,QAAM,SAAuB,QAAQ,mBAAmB;AACxD,QAAM,SAAS,OAAO,MAAM,CAAC;AAC7B,QAAM,SAAS,OAAO,MAAM,CAAC;AAE7B,MAAI,CAAC,UAAU,CAAC,QAAQ;AACtB,WAAO;AAAA,EACT;AACA,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AACA,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAEA,SAAQ,OAAe,QAAQ,GAAG,CAAC;AACrC;",
+  "names": []
+}