@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/versions/range.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @file Range / set helpers — `satisfiesVersion` / `filterVersions` check
+ *   membership against a semver range, `maxVersion` / `minVersion` pick the
+ *   bounds of an arbitrary version array. The bound pickers use the vendored
+ *   `semver` directly because the prerelease-inclusion options aren't part of
+ *   the smol-versions surface.
+ */
+/**
+ * Get all versions from an array that satisfy a semver range.
+ *
+ * @example
+ *   ;```typescript
+ *   filterVersions(['1.0.0', '1.5.0', '2.0.0'], '>=1.0.0 <2.0.0')
+ *   // ['1.0.0', '1.5.0']
+ *   ```
+ */
+export declare function filterVersions(versions: string[], range: string): string[];
+/**
+ * Get the highest version from an array of versions.
+ *
+ * @example
+ *   ;```typescript
+ *   maxVersion(['1.0.0', '2.0.0', '1.5.0']) // '2.0.0'
+ *   ```
+ */
+export declare function maxVersion(versions: string[]): string | undefined;
+/**
+ * Get the lowest version from an array of versions.
+ *
+ * @example
+ *   ;```typescript
+ *   minVersion(['1.0.0', '2.0.0', '1.5.0']) // '1.0.0'
+ *   ```
+ */
+export declare function minVersion(versions: string[]): string | undefined;
+/**
+ * Check if a version satisfies a semver range.
+ *
+ * @example
+ *   ;```typescript
+ *   satisfiesVersion('1.5.0', '>=1.0.0 <2.0.0') // true
+ *   satisfiesVersion('3.0.0', '>=1.0.0 <2.0.0') // false
+ *   ```
+ */
+export declare function satisfiesVersion(version: string, range: string): boolean;

package/dist/versions/range.js

@@ -0,0 +1,50 @@
+"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 range_exports = {};
+__export(range_exports, {
+  filterVersions: () => filterVersions,
+  maxVersion: () => maxVersion,
+  minVersion: () => minVersion,
+  satisfiesVersion: () => satisfiesVersion
+});
+module.exports = __toCommonJS(range_exports);
+var import_internal = require("./_internal");
+function filterVersions(versions, range) {
+  return versions.filter((v) => import_internal.impl.satisfies(v, range));
+}
+function maxVersion(versions) {
+  const semver = (0, import_internal.getSemver)();
+  return semver.maxSatisfying(versions, "*", { includePrerelease: true }) || void 0;
+}
+function minVersion(versions) {
+  const semver = (0, import_internal.getSemver)();
+  return semver.minSatisfying(versions, "*", { includePrerelease: true }) || void 0;
+}
+function satisfiesVersion(version, range) {
+  return import_internal.impl.satisfies(version, range);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterVersions,
+  maxVersion,
+  minVersion,
+  satisfiesVersion
+});

package/dist/versions/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Public type surface for `versions/*` modules — the parsed-version shape
+ *   returned by `parseVersion` (a stable subset of semver's SemVer instance,
+ *   exposed as a structural type rather than leaking the upstream class). Pure
+ *   types, no runtime side effects.
+ */
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: ReadonlyArray<string | number>;
+    build: readonly string[];
+}

package/dist/versions/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/warnings/event-target.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/warnings/event-target'
+ *
+ *   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/warnings/event-target.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 event_target_exports = {};
+__export(event_target_exports, {
+  setMaxEventTargetListeners: () => setMaxEventTargetListeners
+});
+module.exports = __toCommonJS(event_target_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/warnings/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/warnings/suppress'
+ *
+ *   suppressMaxListenersWarning()
+ */
+export declare function suppressMaxListenersWarning(): void;
+/**
+ * Suppress all process warnings of a specific type.
+ *
+ * @example
+ *   import { suppressWarningType } from '@socketsecurity/lib/warnings/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/warnings/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 → warnings/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/words/article.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Indefinite-article picker — `determineArticle()` returns `'a'` or
+ *   `'an'` based on the leading vowel of a word.
+ */
+/**
+ * Determine the appropriate article (a/an) for a word.
+ *
+ * @example
+ *   ;```typescript
+ *   determineArticle('apple') // 'an'
+ *   determineArticle('banana') // 'a'
+ *   ```
+ */
+export declare function determineArticle(word: string): string;

package/dist/words/article.js

@@ -0,0 +1,33 @@
+"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 article_exports = {};
+__export(article_exports, {
+  determineArticle: () => determineArticle
+});
+module.exports = __toCommonJS(article_exports);
+// @__NO_SIDE_EFFECTS__
+function determineArticle(word) {
+  return /^[aeiou]/i.test(word) ? "an" : "a";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  determineArticle
+});

package/dist/words/capitalize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Word-case helpers — `capitalize()` produces an upper-first / lower-rest
+ *   variant that iterates by code point so surrogate pairs aren't split.
+ */
+/**
+ * Capitalize the first letter of a word.
+ *
+ * @example
+ *   ;```typescript
+ *   capitalize('hello') // 'Hello'
+ *   capitalize('WORLD') // 'World'
+ *   capitalize('') // ''
+ *   ```
+ */
+export declare function capitalize(word: string): string;

package/dist/{words.js → words/capitalize.js}

@@ -18,13 +18,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var words_exports = {};
-__export(words_exports, {
-  capitalize: () => capitalize,
-  determineArticle: () => determineArticle,
-  pluralize: () => pluralize
+var capitalize_exports = {};
+__export(capitalize_exports, {
+  capitalize: () => capitalize
 });
-module.exports = __toCommonJS(words_exports);
+module.exports = __toCommonJS(capitalize_exports);
 // @__NO_SIDE_EFFECTS__
 function capitalize(word) {
   if (word.length === 0) {
@@ -33,18 +31,7 @@ function capitalize(word) {
   const [first, ...rest] = [...word];
   return (first ?? "").toUpperCase() + rest.join("").toLowerCase();
 }
-// @__NO_SIDE_EFFECTS__
-function determineArticle(word) {
-  return /^[aeiou]/i.test(word) ? "an" : "a";
-}
-// @__NO_SIDE_EFFECTS__
-function pluralize(word, options) {
-  const { count = 1 } = { __proto__: null, ...options };
-  return count === 1 ? word : `${word}s`;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  capitalize,
-  determineArticle,
-  pluralize
+  capitalize
 });

package/dist/words/pluralize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Simple count-based pluralization helper — appends a trailing `'s'` when
+ *   the count is anything other than 1.
+ */
+import type { PluralizeOptions } from './types';
+/**
+ * Pluralize a word based on count.
+ *
+ * @example
+ *   ;```typescript
+ *   pluralize('file') // 'file'
+ *   pluralize('file', { count: 3 }) // 'files'
+ *   pluralize('file', { count: 0 }) // 'files'
+ *   ```
+ */
+export declare function pluralize(word: string, options?: PluralizeOptions | undefined): string;

package/dist/words/pluralize.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 pluralize_exports = {};
+__export(pluralize_exports, {
+  pluralize: () => pluralize
+});
+module.exports = __toCommonJS(pluralize_exports);
+// @__NO_SIDE_EFFECTS__
+function pluralize(word, options) {
+  const { count = 1 } = { __proto__: null, ...options };
+  return count === 1 ? word : `${word}s`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluralize
+});

package/dist/words/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Public type surface for `words/*` modules — the `PluralizeOptions`
+ *   record. Pure types, no runtime side effects.
+ */
+export interface PluralizeOptions {
+    count?: number;
+}

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