@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/arrays/join.js

@@ -1,40 +1,92 @@
 "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 join_exports = {};
-__export(join_exports, {
-  joinAnd: () => joinAnd,
-  joinOr: () => joinOr
-});
-module.exports = __toCommonJS(join_exports);
-var import_internal = require("./_internal");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_arrays__internal = require('./_internal.js');
+
+//#region src/arrays/join.ts
+/**
+* @file Grammatical list joiners via `Intl.ListFormat` — Oxford-comma aware and
+*   locale-correct. `joinAnd` ("a, b, and c"), `joinOr` ("a, b, or c").
+*/
+/**
+* Join array elements with proper "and" conjunction formatting.
+*
+* Formats an array of strings into a grammatically correct list using "and" as
+* the conjunction. Uses `Intl.ListFormat` for proper English formatting with
+* Oxford comma support.
+*
+* @example
+*   ```ts
+*   // Two items
+*   joinAnd(['apples', 'oranges'])
+*   // Returns: "apples and oranges"
+*
+*   // Three or more items (Oxford comma)
+*   joinAnd(['apples', 'oranges', 'bananas'])
+*   // Returns: "apples, oranges, and bananas"
+*
+*   // Single item
+*   joinAnd(['apples'])
+*   // Returns: "apples"
+*
+*   // Empty array
+*   joinAnd([])
+*   // Returns: ""
+*
+*   // Usage in messages
+*   const items = ['React', 'Vue', 'Angular']
+*   console.log(`You can choose ${joinAnd(items)}`)
+*   // Outputs: "You can choose React, Vue, and Angular"
+*   ```
+*
+* @param arr - Array of strings to join (can be readonly)
+*
+* @returns Formatted string with proper "and" conjunction
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function joinAnd(arr) {
-  return (0, import_internal.getConjunctionFormatter)().format(arr);
+	return (/* @__PURE__ */ require_arrays__internal.getConjunctionFormatter()).format(arr);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Join array elements with proper "or" disjunction formatting.
+*
+* Formats an array of strings into a grammatically correct list using "or" as
+* the disjunction. Uses `Intl.ListFormat` for proper English formatting with
+* Oxford comma support.
+*
+* @example
+*   ```ts
+*   // Two items
+*   joinOr(['yes', 'no'])
+*   // Returns: "yes or no"
+*
+*   // Three or more items (Oxford comma)
+*   joinOr(['red', 'green', 'blue'])
+*   // Returns: "red, green, or blue"
+*
+*   // Single item
+*   joinOr(['maybe'])
+*   // Returns: "maybe"
+*
+*   // Empty array
+*   joinOr([])
+*   // Returns: ""
+*
+*   // Usage in prompts
+*   const options = ['npm', 'yarn', 'pnpm']
+*   console.log(`Choose a package manager: ${joinOr(options)}`)
+*   // Outputs: "Choose a package manager: npm, yarn, or pnpm"
+*   ```
+*
+* @param arr - Array of strings to join (can be readonly)
+*
+* @returns Formatted string with proper "or" disjunction
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function joinOr(arr) {
-  return (0, import_internal.getDisjunctionFormatter)().format(arr);
+	return (/* @__PURE__ */ require_arrays__internal.getDisjunctionFormatter()).format(arr);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  joinAnd,
-  joinOr
-});
+
+//#endregion
+exports.joinAnd = joinAnd;
+exports.joinOr = joinOr;

package/dist/arrays/predicates.js

@@ -1,30 +1,48 @@
 "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 predicates_exports = {};
-__export(predicates_exports, {
-  isArray: () => isArray
-});
-module.exports = __toCommonJS(predicates_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/arrays/predicates.ts
+/**
+* @file Array type-guard predicates. Currently just a re-export of native
+*   `Array.isArray` for consistency with the rest of the arrays surface — kept
+*   in its own leaf because it's runtime-trivial but conceptually a different
+*   concern from `chunk` / `unique` / `join`.
+*/
+/**
+* Alias for native Array.isArray. Determines whether the passed value is an
+* array.
+*
+* This is a direct reference to the native `Array.isArray` method, providing a
+* type guard that narrows the type to an array type. Exported for consistency
+* with other array utilities in this module.
+*
+* @example
+*   ;```ts
+*   // Check if value is an array
+*   isArray([1, 2, 3])
+*   // Returns: true
+*
+*   isArray('not an array')
+*   // Returns: false
+*
+*   isArray(null)
+*   // Returns: false
+*
+*   // Type guard usage
+*   function processValue(value: unknown) {
+*     if (isArray(value)) {
+*       // TypeScript knows value is an array here
+*       console.log(value.length)
+*     }
+*   }
+*   ```
+*
+* @param value - The value to check.
+*
+* @returns `true` if the value is an array, `false` otherwise
+*/
 const isArray = Array.isArray;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isArray
-});
+
+//#endregion
+exports.isArray = isArray;

package/dist/arrays/unique.js

@@ -1,34 +1,48 @@
 "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 unique_exports = {};
-__export(unique_exports, {
-  arrayUnique: () => arrayUnique
-});
-module.exports = __toCommonJS(unique_exports);
-var import_map_set = require("../primordials/map-set");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_map_set = require('../primordials/map-set.js');
+
+//#region src/arrays/unique.ts
+/**
+* @file Deduplicate an array via `Set`. Preserves
+* first-occurrence order.
+*/
+/**
+* Get unique values from an array.
+*
+* Returns a new array containing only the unique values from the input array.
+* Uses `Set` internally for efficient deduplication. Order of first occurrence
+* is preserved.
+*
+* @example
+*   ;```ts
+*   // Remove duplicate numbers
+*   arrayUnique([1, 2, 2, 3, 1, 4])
+*   // Returns: [1, 2, 3, 4]
+*
+*   // Remove duplicate strings
+*   arrayUnique(['apple', 'banana', 'apple', 'cherry'])
+*   // Returns: ['apple', 'banana', 'cherry']
+*
+*   // Works with readonly arrays
+*   const readonlyArr = [1, 1, 2] as const
+*   arrayUnique(readonlyArr)
+*   // Returns: [1, 2]
+*
+*   // Empty arrays return empty
+*   arrayUnique([])
+*   // Returns: []
+*   ```
+*
+* @param arr - The array to deduplicate (can be readonly)
+*
+* @returns New array with duplicate values removed
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function arrayUnique(arr) {
-  return [...new import_map_set.SetCtor(arr)];
+	return [...new require_primordials_map_set.SetCtor(arr)];
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  arrayUnique
-});
+
+//#endregion
+exports.arrayUnique = arrayUnique;

package/dist/bin/_internal.js

@@ -1,43 +1,35 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var internal_exports = {};
-__export(internal_exports, {
-  binPathAllCache: () => binPathAllCache,
-  binPathCache: () => binPathCache,
-  getFs: () => import_fs.getNodeFs,
-  getPath: () => import_path.getNodePath,
-  voltaBinCache: () => voltaBinCache
-});
-module.exports = __toCommonJS(internal_exports);
-var import_map_set = require("../primordials/map-set");
-var import_fs = require("../node/fs");
-var import_path = require("../node/path");
-const binPathCache = new import_map_set.MapCtor();
-const binPathAllCache = new import_map_set.MapCtor();
-const voltaBinCache = new import_map_set.MapCtor();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  binPathAllCache,
-  binPathCache,
-  getFs,
-  getPath,
-  voltaBinCache
-});
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+
+//#region src/bin/_internal.ts
+/**
+* @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
+*   and the binary-resolution caches. Underscore prefix keeps this file out of
+*   the public exports map (see the `dist/<dir>/_<file>` ignore in
+*   scripts/fix/generate-package-exports.mts). Two caches:
+*
+*   1. `binPathCache` — maps a binary name to its first resolved path. Validated
+*      with `existsSync` before reuse so a stale cache doesn't survive a tool
+*      reinstall mid-session.
+*   2. `binPathAllCache` — same shape but stores all-match arrays for callers that
+*      pass `{ all: true }`. Separate cache because the two return shapes can't
+*      be reconciled without losing type info.
+*   3. `voltaBinCache` — maps a `${voltaPath}:${basename}` composite key to the
+*      resolved Volta-managed binary path. Volta resolves npm / pnpm / yarn
+*      through a layered tools/image directory and the lookup is expensive
+*      enough that caching is worth the memory.
+*/
+const binPathCache = new require_primordials_map_set.MapCtor();
+const binPathAllCache = new require_primordials_map_set.MapCtor();
+const voltaBinCache = new require_primordials_map_set.MapCtor();
+
+//#endregion
+exports.binPathAllCache = binPathAllCache;
+exports.binPathCache = binPathCache;
+exports.getFs = require_node_fs.getNodeFs;
+exports.getPath = require_node_path.getNodePath;
+exports.voltaBinCache = voltaBinCache;