@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/{process-lock.js → process/lock-manager.js}

@@ -18,56 +18,44 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var process_lock_exports = {};
-__export(process_lock_exports, {
-  processLock: () => processLock
+var lock_manager_exports = {};
+__export(lock_manager_exports, {
+  ProcessLockManager: () => ProcessLockManager
 });
-module.exports = __toCommonJS(process_lock_exports);
-var import_errors = require("./errors");
-var import_fs = require("./fs");
-var import_logger = require("./logger");
-var import_promises = require("./promises");
-var import_signal_exit = require("./signal-exit");
-var import_primordials = require("./primordials");
-let _fs;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
+module.exports = __toCommonJS(lock_manager_exports);
+var import_message = require("../errors/message");
+var import_safe = require("../fs/safe");
+var import_logger = require("../logger/logger");
+var import_date = require("../primordials/date");
+var import_error = require("../primordials/error");
+var import_map_set = require("../primordials/map-set");
+var import_math = require("../primordials/math");
+var import_retry = require("../promises/retry");
+var import_register = require("../signal-exit/register");
+var import_internal = require("./_internal");
 const logger = (0, import_logger.getDefaultLogger)();
 class ProcessLockManager {
-  activeLocks = new import_primordials.SetCtor();
-  touchTimers = new import_primordials.MapCtor();
+  activeLocks = new import_map_set.SetCtor();
+  touchTimers = new import_map_set.MapCtor();
   exitHandlerRegistered = false;
   /**
-   * Ensure process exit handler is registered for cleanup.
-   * Registers a handler that cleans up all active locks when the process exits.
+   * Ensure process exit handler is registered for cleanup. Registers a handler
+   * that cleans up all active locks when the process exits.
    */
   ensureExitHandler() {
     if (this.exitHandlerRegistered) {
       return;
     }
-    (0, import_signal_exit.onExit)(() => {
+    (0, import_register.onExit)(() => {
       for (const timer of this.touchTimers.values()) {
         clearInterval(timer);
       }
       this.touchTimers.clear();
-      const fs = /* @__PURE__ */ getFs();
+      const fs = (0, import_internal.getFs)();
       for (const lockPath of this.activeLocks) {
         try {
           if (fs.existsSync(lockPath)) {
-            (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
+            (0, import_safe.safeDeleteSync)(lockPath, { recursive: true });
           }
         } catch {
         }
@@ -76,28 +64,28 @@ class ProcessLockManager {
     this.exitHandlerRegistered = true;
   }
   /**
-   * Touch a lock file to update its mtime.
-   * This prevents the lock from being detected as stale during long operations.
+   * Touch a lock file to update its mtime. This prevents the lock from being
+   * detected as stale during long operations.
    *
-   * @param lockPath - Path to the lock directory
+   * @param lockPath - Path to the lock directory.
    */
   touchLock(lockPath) {
     try {
-      const fs = /* @__PURE__ */ getFs();
+      const fs = (0, import_internal.getFs)();
       if (fs.existsSync(lockPath)) {
-        const now = (0, import_primordials.DateNow)() / 1e3;
+        const now = (0, import_date.DateNow)() / 1e3;
         fs.utimesSync(lockPath, now, now);
       }
     } catch (e) {
-      logger.warn(`Failed to touch lock ${lockPath}: ${(0, import_errors.errorMessage)(e)}`);
+      logger.warn(`Failed to touch lock ${lockPath}: ${(0, import_message.errorMessage)(e)}`);
     }
   }
   /**
-   * Start periodic touching of a lock file.
-   * Aligned with npm npx strategy to prevent false stale detection.
+   * Start periodic touching of a lock file. Aligned with npm npx strategy to
+   * prevent false stale detection.
    *
-   * @param lockPath - Path to the lock directory
-   * @param intervalMs - Touch interval in milliseconds
+   * @param lockPath - Path to the lock directory.
+   * @param intervalMs - Touch interval in milliseconds.
    */
   startTouchTimer(lockPath, intervalMs) {
     if (intervalMs <= 0 || this.touchTimers.has(lockPath)) {
@@ -112,7 +100,7 @@ class ProcessLockManager {
   /**
    * Stop periodic touching of a lock file.
    *
-   * @param lockPath - Path to the lock directory
+   * @param lockPath - Path to the lock directory.
    */
   stopTouchTimer(lockPath) {
     const timer = this.touchTimers.get(lockPath);
@@ -122,47 +110,50 @@ class ProcessLockManager {
     }
   }
   /**
-   * Check if a lock is stale based on mtime.
-   * Uses second-level granularity to avoid APFS floating-point precision issues.
-   * Aligned with npm's npx locking strategy.
+   * Check if a lock is stale based on mtime. Uses second-level granularity to
+   * avoid APFS floating-point precision issues. Aligned with npm's npx locking
+   * strategy.
+   *
+   * @param lockPath - Path to the lock directory.
+   * @param staleMs - Stale timeout in milliseconds.
    *
-   * @param lockPath - Path to the lock directory
-   * @param staleMs - Stale timeout in milliseconds
    * @returns True if lock exists and is stale
    */
   isStale(lockPath, staleMs) {
     try {
-      const stats = (/* @__PURE__ */ getFs()).statSync(lockPath, { throwIfNoEntry: false });
+      const stats = (0, import_internal.getFs)().statSync(lockPath, { throwIfNoEntry: false });
       if (!stats) {
         return false;
       }
-      return (0, import_primordials.DateNow)() - stats.mtime.getTime() > staleMs;
+      return (0, import_date.DateNow)() - stats.mtime.getTime() > staleMs;
     } catch {
       return false;
     }
   }
   /**
-   * Acquire a lock using mkdir for atomic operation.
-   * Handles stale locks and includes exit cleanup.
+   * Acquire a lock using mkdir for atomic operation. Handles stale locks and
+   * includes exit cleanup.
    *
    * This method attempts to create a lock directory atomically. If the lock
    * already exists, it checks if it's stale and removes it before retrying.
    * Uses exponential backoff with jitter for retry attempts.
    *
-   * @param lockPath - Path to the lock directory
-   * @param options - Lock acquisition options
+   * @example
+   *   ;```typescript
+   *   const release = await processLock.acquire('/tmp/my-lock')
+   *   try {
+   *     // Critical section
+   *   } finally {
+   *     release()
+   *   }
+   *   ```
+   *
+   * @param lockPath - Path to the lock directory.
+   * @param options - Lock acquisition options.
+   *
    * @returns Release function to unlock
-   * @throws Error if lock cannot be acquired after all retries
    *
-   * @example
-   * ```typescript
-   * const release = await processLock.acquire('/tmp/my-lock')
-   * try {
-   *   // Critical section
-   * } finally {
-   *   release()
-   * }
-   * ```
+   * @throws Error if lock cannot be acquired after all retries
    */
   async acquire(lockPath, options = {}) {
     const {
@@ -173,18 +164,18 @@ class ProcessLockManager {
       touchIntervalMs = 2e3
     } = options;
     this.ensureExitHandler();
-    return await (0, import_promises.pRetry)(
+    return await (0, import_retry.pRetry)(
       async () => {
         try {
           if (this.isStale(lockPath, staleMs)) {
             logger.log(`Removing stale lock: ${lockPath}`);
             try {
-              (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
+              (0, import_safe.safeDeleteSync)(lockPath, { recursive: true });
             } catch {
             }
           }
-          const fs = /* @__PURE__ */ getFs();
-          const parent = (/* @__PURE__ */ getPath()).dirname(lockPath);
+          const fs = (0, import_internal.getFs)();
+          const parent = (0, import_internal.getPath)().dirname(lockPath);
           if (parent && parent !== "." && parent !== lockPath) {
             fs.mkdirSync(parent, { recursive: true });
           }
@@ -196,29 +187,29 @@ class ProcessLockManager {
           const code = e.code;
           if (code === "EEXIST") {
             if (this.isStale(lockPath, staleMs)) {
-              throw new import_primordials.ErrorCtor(`Stale lock detected: ${lockPath}`);
+              throw new import_error.ErrorCtor(`Stale lock detected: ${lockPath}`);
             }
-            throw new import_primordials.ErrorCtor(`Lock already exists: ${lockPath}`);
+            throw new import_error.ErrorCtor(`Lock already exists: ${lockPath}`);
           }
           if (code === "EACCES" || code === "EPERM") {
-            throw new import_primordials.ErrorCtor(
+            throw new import_error.ErrorCtor(
               `Permission denied creating lock: ${lockPath}. Check directory permissions or run with appropriate access.`,
               { cause: e }
             );
           }
           if (code === "EROFS") {
-            throw new import_primordials.ErrorCtor(
+            throw new import_error.ErrorCtor(
               `Cannot create lock on read-only filesystem: ${lockPath}`,
               { cause: e }
             );
           }
           if (code === "ENOTDIR") {
-            const lastSlashIndex = (0, import_primordials.MathMax)(
+            const lastSlashIndex = (0, import_math.MathMax)(
               lockPath.lastIndexOf("/"),
               lockPath.lastIndexOf("\\")
             );
             const parentDir = lastSlashIndex === -1 ? "." : lockPath.slice(0, lastSlashIndex);
-            throw new import_primordials.ErrorCtor(
+            throw new import_error.ErrorCtor(
               `Cannot create lock directory: ${lockPath}
 A path component is a file when it should be a directory.
 Parent path: ${parentDir}
@@ -230,12 +221,12 @@ To resolve:
             );
           }
           if (code === "ENOENT") {
-            const lastSlashIndex = (0, import_primordials.MathMax)(
+            const lastSlashIndex = (0, import_math.MathMax)(
               lockPath.lastIndexOf("/"),
               lockPath.lastIndexOf("\\")
             );
             const parentDir = lastSlashIndex === -1 ? "." : lockPath.slice(0, lastSlashIndex);
-            throw new import_primordials.ErrorCtor(
+            throw new import_error.ErrorCtor(
               `Cannot create lock directory: ${lockPath}
 Parent directory does not exist: ${parentDir}
 To resolve:
@@ -245,7 +236,7 @@ To resolve:
               { cause: e }
             );
           }
-          throw new import_primordials.ErrorCtor(`Failed to acquire lock: ${lockPath}`, {
+          throw new import_error.ErrorCtor(`Failed to acquire lock: ${lockPath}`, {
             cause: e
           });
         }
@@ -259,47 +250,49 @@ To resolve:
     );
   }
   /**
-   * Release a lock and remove from tracking.
-   * Stops periodic touching and removes the lock directory.
-   *
-   * @param lockPath - Path to the lock directory
+   * Release a lock and remove from tracking. Stops periodic touching and
+   * removes the lock directory.
    *
    * @example
-   * ```typescript
-   * processLock.release('/tmp/my-lock')
-   * ```
+   *   ;```typescript
+   *   processLock.release('/tmp/my-lock')
+   *   ```
+   *
+   * @param lockPath - Path to the lock directory.
    */
   release(lockPath) {
     this.stopTouchTimer(lockPath);
     try {
-      if ((/* @__PURE__ */ getFs()).existsSync(lockPath)) {
-        (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
+      if ((0, import_internal.getFs)().existsSync(lockPath)) {
+        (0, import_safe.safeDeleteSync)(lockPath, { recursive: true });
       }
       this.activeLocks.delete(lockPath);
     } catch (e) {
-      logger.warn(`Failed to release lock ${lockPath}: ${(0, import_errors.errorMessage)(e)}`);
+      logger.warn(`Failed to release lock ${lockPath}: ${(0, import_message.errorMessage)(e)}`);
     }
   }
   /**
-   * Execute a function with exclusive lock protection.
-   * Automatically handles lock acquisition, execution, and cleanup.
+   * Execute a function with exclusive lock protection. Automatically handles
+   * lock acquisition, execution, and cleanup.
    *
-   * This is the recommended way to use process locks, as it guarantees
-   * cleanup even if the callback throws an error.
+   * This is the recommended way to use process locks, as it guarantees cleanup
+   * even if the callback throws an error.
+   *
+   * @example
+   *   ;```typescript
+   *   const result = await processLock.withLock('/tmp/my-lock', async () => {
+   *     // Critical section
+   *     return someValue
+   *   })
+   *   ```
+   *
+   * @param lockPath - Path to the lock directory.
+   * @param fn - Function to execute while holding the lock.
+   * @param options - Lock acquisition options.
    *
-   * @param lockPath - Path to the lock directory
-   * @param fn - Function to execute while holding the lock
-   * @param options - Lock acquisition options
    * @returns Result of the callback function
-   * @throws Error from callback or lock acquisition failure
    *
-   * @example
-   * ```typescript
-   * const result = await processLock.withLock('/tmp/my-lock', async () => {
-   *   // Critical section
-   *   return someValue
-   * })
-   * ```
+   * @throws Error from callback or lock acquisition failure
    */
   async withLock(lockPath, fn, options) {
     const release = await this.acquire(lockPath, options);
@@ -310,8 +303,7 @@ To resolve:
     }
   }
 }
-const processLock = new ProcessLockManager();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  processLock
+  ProcessLockManager
 });

package/dist/process/lock-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Public type surface for `process/lock-*` modules — the
+ *   `ProcessLockOptions` bag accepted by `processLock.acquire` and
+ *   `processLock.withLock`. Pure types, no runtime side effects.
+ */
+/**
+ * Lock acquisition options.
+ */
+export interface ProcessLockOptions {
+    /**
+     * Maximum number of retry attempts.
+     *
+     * @default 3
+     */
+    retries?: number | undefined;
+    /**
+     * Base delay between retries in milliseconds.
+     *
+     * @default 100
+     */
+    baseDelayMs?: number | undefined;
+    /**
+     * Maximum delay between retries in milliseconds.
+     *
+     * @default 1000
+     */
+    maxDelayMs?: number | undefined;
+    /**
+     * Stale lock timeout in milliseconds. Locks older than this are considered
+     * abandoned and can be reclaimed. Aligned with npm's npx locking strategy (5
+     * seconds).
+     *
+     * @default 5000 (5 seconds)
+     */
+    staleMs?: number | undefined;
+    /**
+     * Interval for touching lock file to keep it fresh in milliseconds. Set to 0
+     * to disable periodic touching.
+     *
+     * @default 2000 (2 seconds)
+     */
+    touchIntervalMs?: number | undefined;
+}

package/dist/process/lock-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 lock_types_exports = {};
+module.exports = __toCommonJS(lock_types_exports);

package/dist/process/transient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file Temporary package executor detection utilities for Socket ecosystem.
+ *   Identifies and handles temporary execution contexts such as npx, pnpm dlx,
+ *   and yarn dlx.
+ */
+/**
+ * Detects if the current process is running in a temporary package execution
+ * context such as npm exec, npx, pnpm dlx, or yarn dlx.
+ *
+ * When package managers run commands via exec/npx/dlx, they execute in
+ * temporary directories that are cleaned up after execution. Creating
+ * persistent shadows or modifying PATH in these contexts can break subsequent
+ * package manager commands.
+ *
+ * @example
+ *   ;```typescript
+ *   if (isTransientProcess()) {
+ *     console.log('Running in a temporary executor context')
+ *   }
+ *   ```
+ */
+export declare function isTransientProcess(cwd?: string): boolean;

package/dist/{temporary-executor.js → process/transient.js}

@@ -28,15 +28,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var temporary_executor_exports = {};
-__export(temporary_executor_exports, {
-  isRunningInTemporaryExecutor: () => isRunningInTemporaryExecutor
+var transient_exports = {};
+__export(transient_exports, {
+  isTransientProcess: () => isTransientProcess
 });
-module.exports = __toCommonJS(temporary_executor_exports);
+module.exports = __toCommonJS(transient_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_platform = require("./constants/platform");
-var import_normalize = require("./paths/normalize");
-function isRunningInTemporaryExecutor(cwd = import_node_process.default.cwd()) {
+var import_platform = require("../constants/platform");
+var import_normalize = require("../paths/normalize");
+function isTransientProcess(cwd = import_node_process.default.cwd()) {
   const userAgent = import_node_process.default.env["npm_config_user_agent"];
   if (userAgent?.includes("exec") || userAgent?.includes("npx") || // # socket-hook: allow npx
   userAgent?.includes("dlx")) {
@@ -64,5 +64,5 @@ function isRunningInTemporaryExecutor(cwd = import_node_process.default.cwd()) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isRunningInTemporaryExecutor
+  isTransientProcess
 });

package/dist/promise-queue/queue.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file Bounded concurrency promise queue. Exports the `PromiseQueue` class,
+ *   which limits how many async tasks run simultaneously, supports an optional
+ *   max queue length (new tasks beyond the cap are rejected with "Task dropped:
+ *   queue length exceeded"), and exposes an idle-wait helper.
+ */
+export declare class PromiseQueue {
+    private queue;
+    private running;
+    private idleResolvers;
+    private readonly maxConcurrency;
+    private readonly maxQueueLength;
+    /**
+     * Creates a new PromiseQueue.
+     *
+     * @param maxConcurrency - Maximum number of promises that can run
+     *   concurrently.
+     * @param maxQueueLength - Maximum queue size; submissions past the cap reject
+     *   with "Task dropped: queue length exceeded" instead of evicting a caller
+     *   that has been waiting patiently. Callers must handle this rejection or
+     *   they'll see an unhandled rejection.
+     */
+    constructor(maxConcurrency: number, maxQueueLength?: number | undefined);
+    /**
+     * Add a task to the queue.
+     *
+     * @param fn - Async function to execute.
+     *
+     * @returns Promise that resolves with the function's result, or rejects with
+     *   "Task dropped: queue length exceeded" if the queue is full.
+     */
+    add<T>(fn: () => Promise<T>): Promise<T>;
+    private runNext;
+    private notifyIdleIfNeeded;
+    /**
+     * Wait for all queued and running tasks to complete.
+     */
+    onIdle(): Promise<void>;
+    /**
+     * Get the number of tasks currently running.
+     */
+    get activeCount(): number;
+    /**
+     * Get the number of tasks waiting in the queue.
+     */
+    get pendingCount(): number;
+    /**
+     * Clear all pending tasks from the queue (does not affect running tasks)
+     */
+    clear(): void;
+}

package/dist/{promise-queue.js → promise-queue/queue.js}

@@ -18,12 +18,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var promise_queue_exports = {};
-__export(promise_queue_exports, {
+var queue_exports = {};
+__export(queue_exports, {
   PromiseQueue: () => PromiseQueue
 });
-module.exports = __toCommonJS(promise_queue_exports);
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(queue_exports);
+var import_error = require("../primordials/error");
+var import_promise = require("../primordials/promise");
 class PromiseQueue {
   queue = [];
   running = 0;
@@ -31,30 +32,34 @@ class PromiseQueue {
   maxConcurrency;
   maxQueueLength;
   /**
-   * Creates a new PromiseQueue
-   * @param maxConcurrency - Maximum number of promises that can run concurrently
-   * @param maxQueueLength - Maximum queue size; submissions past the cap
-   * reject with "Task dropped: queue length exceeded" instead of evicting
-   * a caller that has been waiting patiently. Callers must handle this
-   * rejection or they'll see an unhandled rejection.
+   * Creates a new PromiseQueue.
+   *
+   * @param maxConcurrency - Maximum number of promises that can run
+   *   concurrently.
+   * @param maxQueueLength - Maximum queue size; submissions past the cap reject
+   *   with "Task dropped: queue length exceeded" instead of evicting a caller
+   *   that has been waiting patiently. Callers must handle this rejection or
+   *   they'll see an unhandled rejection.
    */
   constructor(maxConcurrency, maxQueueLength) {
     this.maxConcurrency = maxConcurrency;
     this.maxQueueLength = maxQueueLength;
     if (maxConcurrency < 1) {
-      throw new import_primordials.ErrorCtor("maxConcurrency must be at least 1");
+      throw new import_error.ErrorCtor("maxConcurrency must be at least 1");
     }
   }
   /**
-   * Add a task to the queue
-   * @param fn - Async function to execute
-   * @returns Promise that resolves with the function's result, or rejects
-   * with "Task dropped: queue length exceeded" if the queue is full.
+   * Add a task to the queue.
+   *
+   * @param fn - Async function to execute.
+   *
+   * @returns Promise that resolves with the function's result, or rejects with
+   *   "Task dropped: queue length exceeded" if the queue is full.
    */
   async add(fn) {
-    return await new import_primordials.PromiseCtor((resolve, reject) => {
+    return await new import_promise.PromiseCtor((resolve, reject) => {
       if (this.maxQueueLength !== void 0 && this.queue.length >= this.maxQueueLength) {
-        reject(new import_primordials.ErrorCtor("Task dropped: queue length exceeded"));
+        reject(new import_error.ErrorCtor("Task dropped: queue length exceeded"));
         return;
       }
       const task = { fn, resolve, reject };
@@ -93,24 +98,24 @@ class PromiseQueue {
     }
   }
   /**
-   * Wait for all queued and running tasks to complete
+   * Wait for all queued and running tasks to complete.
    */
   async onIdle() {
     if (this.running === 0 && this.queue.length === 0) {
       return;
     }
-    return await new import_primordials.PromiseCtor((resolve) => {
+    return await new import_promise.PromiseCtor((resolve) => {
       this.idleResolvers.push(resolve);
     });
   }
   /**
-   * Get the number of tasks currently running
+   * Get the number of tasks currently running.
    */
   get activeCount() {
     return this.running;
   }
   /**
-   * Get the number of tasks waiting in the queue
+   * Get the number of tasks waiting in the queue.
    */
   get pendingCount() {
     return this.queue.length;
@@ -122,7 +127,7 @@ class PromiseQueue {
     const pending = this.queue;
     this.queue = [];
     for (const task of pending) {
-      task.reject(new import_primordials.ErrorCtor("Task cancelled: queue cleared"));
+      task.reject(new import_error.ErrorCtor("Task cancelled: queue cleared"));
     }
     this.notifyIdleIfNeeded();
   }

package/dist/promise-queue/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Public type surface for `promise-queue/*` modules — the `QueuedTask`
+ *   storage shape used by the bounded-concurrency `PromiseQueue`. Pure types,
+ *   no runtime side effects.
+ */
+export type QueuedTask<T> = {
+    fn: () => Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+};

package/dist/promise-queue/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);