@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/argv/parse.js

@@ -1,173 +1,155 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var parse_exports = {};
-__export(parse_exports, {
-  commonParseArgsConfig: () => commonParseArgsConfig,
-  getPositionalArgs: () => getPositionalArgs,
-  hasFlag: () => hasFlag,
-  parseArgs: () => parseArgs,
-  parseArgsWithDefaults: () => parseArgsWithDefaults
-});
-module.exports = __toCommonJS(parse_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_yargs_parser = __toESM(require("../external/yargs-parser"));
-var import_array = require("../primordials/array");
-var import_object = require("../primordials/object");
-var import_string = require("../primordials/string");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_string = require('../primordials/string.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_object = require('../primordials/object.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+let src_external_yargs_parser = require("../external/yargs-parser");
+src_external_yargs_parser = require_runtime.__toESM(src_external_yargs_parser);
+
+//#region src/argv/parse.ts
+/**
+* @file Argument parsing utilities for CLI applications. Wraps the vendored
+*   yargs-parser with a Node.js parseArgs-compatible surface for booleans,
+*   strings, arrays, aliases, defaults, and coercion.
+*/
+/**
+* Common parseArgs configuration for Socket registry scripts.
+*/
 const commonParseArgsConfig = {
-  options: {
-    force: {
-      type: "boolean",
-      short: "f",
-      default: false
-    },
-    quiet: {
-      type: "boolean",
-      short: "q",
-      default: false
-    }
-  },
-  strict: false
+	options: {
+		force: {
+			type: "boolean",
+			short: "f",
+			default: false
+		},
+		quiet: {
+			type: "boolean",
+			short: "q",
+			default: false
+		}
+	},
+	strict: false
 };
+/**
+* Extract positional arguments from process.argv. Useful for commands that
+* accept file paths or other positional parameters.
+*
+* @example
+*   ;```typescript
+*   // process.argv = ["node", "script.js", "src", "lib", "--verbose"]
+*   getPositionalArgs() // ["src", "lib"]
+*   ```
+*/
 function getPositionalArgs(startIndex = 2) {
-  const args = import_node_process.default.argv.slice(startIndex);
-  const positionals = [];
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if ((0, import_string.StringPrototypeStartsWith)(arg, "-")) {
-      break;
-    }
-    positionals.push(arg);
-    i++;
-  }
-  return positionals;
+	const args = node_process.default.argv.slice(startIndex);
+	const positionals = [];
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (require_primordials_string.StringPrototypeStartsWith(arg, "-")) break;
+		positionals.push(arg);
+		i++;
+	}
+	return positionals;
 }
-function hasFlag(flag, argv = import_node_process.default.argv) {
-  return (0, import_array.ArrayPrototypeIncludes)(argv, `--${flag}`);
+/**
+* Check if a specific flag is present in argv.
+*
+* @example
+*   ;```typescript
+*   hasFlag('verbose') // true if --verbose is in process.argv
+*   hasFlag('force', ['--force', '--quiet']) // true
+*   ```
+*/
+function hasFlag(flag, argv = node_process.default.argv) {
+	return require_primordials_array.ArrayPrototypeIncludes(argv, `--${flag}`);
 }
+/**
+* Parse command-line arguments with a Node.js parseArgs-compatible API. Uses
+* yargs-parser internally for robust argument parsing.
+*
+* @example
+*   ;```typescript
+*   const { values, positionals } = parseArgs({
+*     args: ['--force', '--quiet', 'file.ts'],
+*     options: {
+*       force: { type: 'boolean' },
+*       quiet: { type: 'boolean', short: 'q' },
+*     },
+*   })
+*   ```
+*/
 function parseArgs(config = {}) {
-  const {
-    allowNegative = false,
-    allowPositionals = true,
-    args = import_node_process.default.argv.slice(2),
-    configuration,
-    options = {},
-    strict = true
-  } = config;
-  const yargsOptions = {
-    // Arrays of option names to treat as specific types.
-    boolean: [],
-    string: [],
-    array: [],
-    // Maps for aliases, defaults, and transformations.
-    alias: {},
-    default: {},
-    coerce: {},
-    "unknown-options-as-args": !strict,
-    "parse-numbers": false,
-    "parse-positional-numbers": false,
-    "boolean-negation": !allowNegative,
-    "halt-at-non-option": !allowPositionals,
-    configuration: {
-      // Enable kebab-case to camelCase conversion (e.g., --temp-dir → tempDir).
-      "camel-case-expansion": true,
-      // Disable dot notation to avoid confusing nested property parsing.
-      "dot-notation": false,
-      // Convert duplicate arguments into arrays automatically.
-      "duplicate-arguments-array": true,
-      // Flatten nested arrays from duplicate arguments for cleaner output.
-      "flatten-duplicate-arrays": true,
-      // Populate the '--' key with arguments after the -- separator.
-      "populate--": true,
-      // Allow short option grouping like -abc for -a -b -c.
-      "short-option-groups": true,
-      // Keep aliased keys in the result for flexibility.
-      "strip-aliased": false,
-      // Keep both kebab-case and camelCase keys for flexibility.
-      "strip-dashed": false,
-      ...configuration
-    }
-  };
-  for (const { 0: key, 1: optionConfig } of (0, import_object.ObjectEntries)(options)) {
-    const {
-      coerce,
-      default: defaultValue,
-      multiple,
-      short,
-      type
-    } = optionConfig;
-    if (type === "boolean") {
-      yargsOptions.boolean?.push(key);
-    } else if (type === "string") {
-      yargsOptions.string?.push(key);
-    }
-    if (multiple) {
-      yargsOptions.array?.push(key);
-    }
-    if (short) {
-      ;
-      yargsOptions.alias[short] = key;
-    }
-    if (defaultValue !== void 0) {
-      ;
-      yargsOptions.default[key] = defaultValue;
-    }
-    if (coerce) {
-      ;
-      yargsOptions.coerce[key] = coerce;
-    }
-  }
-  const parsed = (0, import_yargs_parser.default)(args, yargsOptions);
-  const positionals = parsed._ || [];
-  const { _, ...values } = parsed;
-  const stringPositionals = positionals.map(String);
-  return {
-    values,
-    positionals: stringPositionals,
-    raw: parsed
-  };
+	const { allowNegative = false, allowPositionals = true, args = node_process.default.argv.slice(2), configuration, options = {}, strict = true } = config;
+	const yargsOptions = {
+		boolean: [],
+		string: [],
+		array: [],
+		alias: {},
+		default: {},
+		coerce: {},
+		"unknown-options-as-args": !strict,
+		"parse-numbers": false,
+		"parse-positional-numbers": false,
+		"boolean-negation": !allowNegative,
+		"halt-at-non-option": !allowPositionals,
+		configuration: {
+			"camel-case-expansion": true,
+			"dot-notation": false,
+			"duplicate-arguments-array": true,
+			"flatten-duplicate-arrays": true,
+			"populate--": true,
+			"short-option-groups": true,
+			"strip-aliased": false,
+			"strip-dashed": false,
+			...configuration
+		}
+	};
+	for (const { 0: key, 1: optionConfig } of require_primordials_object.ObjectEntries(options)) {
+		const { coerce, default: defaultValue, multiple, short, type } = optionConfig;
+		if (type === "boolean") yargsOptions.boolean?.push(key);
+		else if (type === "string") yargsOptions.string?.push(key);
+		if (multiple) yargsOptions.array?.push(key);
+		if (short) yargsOptions.alias[short] = key;
+		if (defaultValue !== void 0) yargsOptions.default[key] = defaultValue;
+		if (coerce) yargsOptions.coerce[key] = coerce;
+	}
+	const parsed = (0, src_external_yargs_parser.default)(args, yargsOptions);
+	const positionals = parsed._ || [];
+	const { _, ...values } = parsed;
+	return {
+		values,
+		positionals: positionals.map(String),
+		raw: parsed
+	};
 }
+/**
+* Parse command-line arguments with Socket defaults. Provides sensible defaults
+* for Socket CLI applications.
+*
+* @example
+*   ;```typescript
+*   const { values, positionals } = parseArgsWithDefaults({
+*     args: ['--force', 'file.ts'],
+*     options: { force: { type: 'boolean' } },
+*   })
+*   ```
+*/
 function parseArgsWithDefaults(config = {}) {
-  return parseArgs({
-    strict: false,
-    allowPositionals: true,
-    ...config
-  });
+	return parseArgs({
+		strict: false,
+		allowPositionals: true,
+		...config
+	});
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  commonParseArgsConfig,
-  getPositionalArgs,
-  hasFlag,
-  parseArgs,
-  parseArgsWithDefaults
-});
+
+//#endregion
+exports.commonParseArgsConfig = commonParseArgsConfig;
+exports.getPositionalArgs = getPositionalArgs;
+exports.hasFlag = hasFlag;
+exports.parseArgs = parseArgs;
+exports.parseArgsWithDefaults = parseArgsWithDefaults;

package/dist/arrays/_internal.js

@@ -1,55 +1,72 @@
 "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, {
-  getConjunctionFormatter: () => getConjunctionFormatter,
-  getDisjunctionFormatter: () => getDisjunctionFormatter
-});
-module.exports = __toCommonJS(internal_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/arrays/_internal.ts
+/**
+* @file Private internals for `arrays/*` modules — cached `Intl.ListFormat`
+*   instances for conjunction (and) and disjunction (or) joins. Constructed
+*   lazily because `new Intl.ListFormat(...)` is a measurable startup cost.
+*/
 let _conjunctionFormatter;
 let _disjunctionFormatter;
-// @__NO_SIDE_EFFECTS__
+/**
+* Get a cached Intl.ListFormat instance for conjunction (and) formatting.
+*
+* Creates a singleton formatter for English "and" lists using the long style.
+* The formatter is lazily initialized on first use and reused for performance.
+*
+* @private
+*
+* @example
+*   ;```ts
+*   const formatter = getConjunctionFormatter()
+*   formatter.format(['apple', 'banana', 'cherry'])
+*   // Returns: "apple, banana, and cherry"
+*   ```
+*
+* @returns Cached Intl.ListFormat instance configured for conjunction
+*   formatting.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getConjunctionFormatter() {
-  if (_conjunctionFormatter === void 0) {
-    _conjunctionFormatter = new Intl.ListFormat("en", {
-      style: "long",
-      // "and" lists.
-      type: "conjunction"
-    });
-  }
-  return _conjunctionFormatter;
+	if (_conjunctionFormatter === void 0)
+ /* c8 ignore start */
+	_conjunctionFormatter = new Intl.ListFormat("en", {
+		style: "long",
+		type: "conjunction"
+	});
+	return _conjunctionFormatter;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Get a cached Intl.ListFormat instance for disjunction (or) formatting.
+*
+* Creates a singleton formatter for English "or" lists using the long style.
+* The formatter is lazily initialized on first use and reused for performance.
+*
+* @private
+*
+* @example
+*   ;```ts
+*   const formatter = getDisjunctionFormatter()
+*   formatter.format(['red', 'blue', 'green'])
+*   // Returns: "red, blue, or green"
+*   ```
+*
+* @returns Cached Intl.ListFormat instance configured for disjunction
+*   formatting.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getDisjunctionFormatter() {
-  if (_disjunctionFormatter === void 0) {
-    _disjunctionFormatter = new Intl.ListFormat("en", {
-      style: "long",
-      // "or" lists.
-      type: "disjunction"
-    });
-  }
-  return _disjunctionFormatter;
+	if (_disjunctionFormatter === void 0)
+ /* c8 ignore start */
+	_disjunctionFormatter = new Intl.ListFormat("en", {
+		style: "long",
+		type: "disjunction"
+	});
+	return _disjunctionFormatter;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getConjunctionFormatter,
-  getDisjunctionFormatter
-});
+
+//#endregion
+exports.getConjunctionFormatter = getConjunctionFormatter;
+exports.getDisjunctionFormatter = getDisjunctionFormatter;

package/dist/arrays/chunk.js

@@ -1,43 +1,54 @@
 "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 chunk_exports = {};
-__export(chunk_exports, {
-  arrayChunk: () => arrayChunk
-});
-module.exports = __toCommonJS(chunk_exports);
-var import_error = require("../primordials/error");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+
+//#region src/arrays/chunk.ts
+/**
+* @file Split an array into fixed-size chunks. The last chunk holds the
+*   leftover when length is not evenly divisible.
+*/
+/**
+* Split an array into chunks of a specified size.
+*
+* Divides an array into smaller arrays of the specified chunk size. The last
+* chunk may contain fewer elements if the array length is not evenly divisible
+* by the chunk size.
+*
+* @example
+*   ;```ts
+*   // Split into pairs (default)
+*   arrayChunk([1, 2, 3, 4, 5])
+*   // Returns: [[1, 2], [3, 4], [5]]
+*
+*   // Split into groups of 3
+*   arrayChunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3)
+*   // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+*
+*   // Works with readonly arrays
+*   const readonlyArr = [1, 2, 3] as const
+*   arrayChunk(readonlyArr)
+*   // Returns: [[1, 2], [3]]
+*   ```
+*
+* @default 2
+*
+* @param arr - The array to split into chunks (can be readonly)
+* @param size - Size of each chunk. Must be greater than 0.
+*
+* @returns Array of chunks, where each chunk is an array of elements
+*
+* @throws {Error} If chunk size is less than or equal to 0
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function arrayChunk(arr, size) {
-  const chunkSize = size ?? 2;
-  if (chunkSize <= 0) {
-    throw new import_error.ErrorCtor("Chunk size must be greater than 0");
-  }
-  const { length } = arr;
-  const chunks = [];
-  for (let i = 0; i < length; i += chunkSize) {
-    chunks.push(arr.slice(i, i + chunkSize));
-  }
-  return chunks;
+	const chunkSize = size ?? 2;
+	if (chunkSize <= 0) throw new require_primordials_error.ErrorCtor("Chunk size must be greater than 0");
+	const { length } = arr;
+	const chunks = [];
+	for (let i = 0; i < length; i += chunkSize) chunks.push(arr.slice(i, i + chunkSize));
+	return chunks;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  arrayChunk
-});
+
+//#endregion
+exports.arrayChunk = arrayChunk;