@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/argv/flag-predicates.js

@@ -0,0 +1,118 @@
+"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 flag_predicates_exports = {};
+__export(flag_predicates_exports, {
+  getLogLevel: () => getLogLevel,
+  isAll: () => isAll,
+  isChanged: () => isChanged,
+  isCoverage: () => isCoverage,
+  isDebug: () => isDebug,
+  isDryRun: () => isDryRun,
+  isFix: () => isFix,
+  isForce: () => isForce,
+  isHelp: () => isHelp,
+  isJson: () => isJson,
+  isQuiet: () => isQuiet,
+  isStaged: () => isStaged,
+  isUpdate: () => isUpdate,
+  isVerbose: () => isVerbose,
+  isWatch: () => isWatch,
+  makeFlagPredicate: () => makeFlagPredicate
+});
+module.exports = __toCommonJS(flag_predicates_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_array = require("../primordials/array");
+const processArg = [...import_node_process.default.argv];
+function makeFlagPredicate(longFlags, shortFlags = [], keys = [longFlags[0].replace(/^--/, "")]) {
+  const argvForms = [...longFlags, ...shortFlags];
+  return function check(input) {
+    if (!input) {
+      return argvForms.some((f) => processArg.includes(f));
+    }
+    if ((0, import_array.ArrayIsArray)(input)) {
+      return argvForms.some((f) => (0, import_array.ArrayPrototypeIncludes)(input, f));
+    }
+    return keys.some((k) => !!input[k]);
+  };
+}
+const isAll = makeFlagPredicate(["--all"]);
+const isChanged = makeFlagPredicate(["--changed"]);
+const isCoverage = makeFlagPredicate(
+  ["--coverage", "--cover"],
+  [],
+  ["coverage", "cover"]
+);
+const isDebug = makeFlagPredicate(["--debug"]);
+const isDryRun = makeFlagPredicate(["--dry-run"], [], ["dry-run"]);
+const isFix = makeFlagPredicate(["--fix"]);
+const isForce = makeFlagPredicate(["--force"]);
+const isHelp = makeFlagPredicate(["--help"], ["-h"]);
+const isJson = makeFlagPredicate(["--json"]);
+const isQuiet = makeFlagPredicate(
+  ["--quiet", "--silent"],
+  [],
+  ["quiet", "silent"]
+);
+const isStaged = makeFlagPredicate(["--staged"]);
+const isUpdate = makeFlagPredicate(["--update"], ["-u"]);
+const isVerbose = makeFlagPredicate(["--verbose"]);
+const isWatch = makeFlagPredicate(["--watch"], ["-w"]);
+function getLogLevel(input) {
+  if (isQuiet(input)) {
+    return "silent";
+  }
+  if (isDebug(input)) {
+    return "debug";
+  }
+  if (isVerbose(input)) {
+    return "verbose";
+  }
+  return "info";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLogLevel,
+  isAll,
+  isChanged,
+  isCoverage,
+  isDebug,
+  isDryRun,
+  isFix,
+  isForce,
+  isHelp,
+  isJson,
+  isQuiet,
+  isStaged,
+  isUpdate,
+  isVerbose,
+  isWatch,
+  makeFlagPredicate
+});

package/dist/argv/flag-types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * @file Types + `COMMON_FLAGS` table for argv flag parsing. Split out of
+ *   `argv/flags.ts` for size hygiene. Pure values + types only; no I/O or
+ *   runtime side effects so this module stays cheap to import everywhere.
+ */
+/**
+ * Flag values object from parsed arguments.
+ */
+export interface FlagValues {
+    [key: string]: unknown;
+    quiet?: boolean;
+    silent?: boolean;
+    verbose?: boolean;
+    help?: boolean;
+    all?: boolean;
+    fix?: boolean;
+    force?: boolean;
+    'dry-run'?: boolean;
+    json?: boolean;
+    debug?: boolean;
+    watch?: boolean;
+    coverage?: boolean;
+    cover?: boolean;
+    update?: boolean;
+    staged?: boolean;
+    changed?: boolean;
+}
+/**
+ * Accepted input types for flag checking functions. Can be parsed flag values,
+ * process.argv array, or undefined (uses process.argv).
+ */
+export type FlagInput = FlagValues | string[] | readonly string[] | undefined;
+/**
+ * Common flag definitions for parseArgs configuration. Can be spread into
+ * parseArgs options for consistency.
+ */
+export declare const COMMON_FLAGS: {
+    all: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    changed: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    coverage: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    cover: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    debug: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    'dry-run': {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    fix: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    force: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    help: {
+        type: 'boolean';
+        default: boolean;
+        short: string;
+        description: string;
+    };
+    json: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    quiet: {
+        type: 'boolean';
+        default: boolean;
+        short: string;
+        description: string;
+    };
+    silent: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    staged: {
+        type: 'boolean';
+        default: boolean;
+        description: string;
+    };
+    update: {
+        type: 'boolean';
+        default: boolean;
+        short: string;
+        description: string;
+    };
+    verbose: {
+        type: 'boolean';
+        default: boolean;
+        short: string;
+        description: string;
+    };
+    watch: {
+        type: 'boolean';
+        default: boolean;
+        short: string;
+        description: string;
+    };
+};

package/dist/argv/flag-types.js

@@ -0,0 +1,116 @@
+"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 flag_types_exports = {};
+__export(flag_types_exports, {
+  COMMON_FLAGS: () => COMMON_FLAGS
+});
+module.exports = __toCommonJS(flag_types_exports);
+const COMMON_FLAGS = {
+  all: {
+    type: "boolean",
+    default: false,
+    description: "Target all files"
+  },
+  changed: {
+    type: "boolean",
+    default: false,
+    description: "Target changed files"
+  },
+  coverage: {
+    type: "boolean",
+    default: false,
+    description: "Run with coverage"
+  },
+  cover: {
+    type: "boolean",
+    default: false,
+    description: "Run with coverage (alias)"
+  },
+  debug: {
+    type: "boolean",
+    default: false,
+    description: "Enable debug output"
+  },
+  "dry-run": {
+    type: "boolean",
+    default: false,
+    description: "Perform a dry run"
+  },
+  fix: {
+    type: "boolean",
+    default: false,
+    description: "Automatically fix issues"
+  },
+  force: {
+    type: "boolean",
+    default: false,
+    description: "Force the operation"
+  },
+  help: {
+    type: "boolean",
+    default: false,
+    short: "h",
+    description: "Show help"
+  },
+  json: {
+    type: "boolean",
+    default: false,
+    description: "Output as JSON"
+  },
+  quiet: {
+    type: "boolean",
+    default: false,
+    short: "q",
+    description: "Suppress output"
+  },
+  silent: {
+    type: "boolean",
+    default: false,
+    description: "Suppress all output"
+  },
+  staged: {
+    type: "boolean",
+    default: false,
+    description: "Target staged files"
+  },
+  update: {
+    type: "boolean",
+    default: false,
+    short: "u",
+    description: "Update snapshots/deps"
+  },
+  verbose: {
+    type: "boolean",
+    default: false,
+    short: "v",
+    description: "Verbose output"
+  },
+  watch: {
+    type: "boolean",
+    default: false,
+    short: "w",
+    description: "Watch mode"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMMON_FLAGS
+});

package/dist/argv/parse-args-string.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Tokenize a shell-style command string into an argv array. Modernized
+ *   port of the `string-argv` npm package (MIT) — same regex-driven recognizer,
+ *   native ES module shape, typed signature, no env/file prepend baggage.
+ *   Supports bare tokens, single + double quoted tokens, and mixed tokens like
+ *   `key="value"`. No backslash-escape processing — `\"` inside a double-quoted
+ *   segment is two literal characters, not an escaped quote. No env-var
+ *   expansion, no command substitution, no pipes / redirects / `&&` chains;
+ *   this is purely a tokenizer. Common use case: turning a `string`
+ *   representation of a command (e.g. from a config file, a `bin` field, or a
+ *   shellout test fixture) into an argv array that `execFileSync` /
+ *   `child_process.spawn` accepts directly — bypassing the platform shell + its
+ *   quoting differences (`cmd.exe` vs `bash`).
+ */
+/**
+ * Tokenize a shell-style command string into argv. Single + double quote pairs
+ * are recognized; the quote characters are stripped from the resulting token.
+ * Whitespace outside of quotes separates tokens.
+ *
+ * @example
+ *   parseArgsString('git commit -m "hello world"')
+ *   // → ['git', 'commit', '-m', 'hello world']
+ *
+ *   parseArgsString('foo --bar="x y" baz')
+ *   // → ['foo', '--bar=x y', 'baz']
+ *
+ *   parseArgsString("echo 'one two' three")
+ *   // → ['echo', 'one two', 'three']
+ */
+export declare function parseArgsString(cmd: string): string[];

package/dist/argv/parse-args-string.js

@@ -0,0 +1,42 @@
+"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 parse_args_string_exports = {};
+__export(parse_args_string_exports, {
+  parseArgsString: () => parseArgsString
+});
+module.exports = __toCommonJS(parse_args_string_exports);
+const TOKEN_REGEXP = /([^\s'"]([^\s'"]*(['"])([^]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^]*?)\5/g;
+function parseArgsString(cmd) {
+  const argv = [];
+  let match;
+  TOKEN_REGEXP.lastIndex = 0;
+  while ((match = TOKEN_REGEXP.exec(cmd)) !== null) {
+    const token = match[1] ?? match[6] ?? match[0];
+    if (typeof token === "string") {
+      argv.push(token);
+    }
+  }
+  return argv;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseArgsString
+});

package/dist/argv/parse.d.ts

@@ -1,7 +1,7 @@
 /**
- * @fileoverview 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.
+ * @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.
  */
 /**
  * Yargs parser result interface.
@@ -21,7 +21,8 @@ export interface ParseArgsOptionsConfig {
     coerce?: (value: unknown) => unknown | undefined;
 }
 /**
- * Configuration object for parseArgs function, similar to Node.js util.parseArgs.
+ * Configuration object for parseArgs function, similar to Node.js
+ * util.parseArgs.
  */
 export interface ParseArgsConfig {
     args?: readonly string[] | undefined;
@@ -45,53 +46,53 @@ export interface ParsedArgs<T = Record<string, unknown>> {
  */
 export declare const commonParseArgsConfig: ParseArgsConfig;
 /**
- * Extract positional arguments from process.argv.
- * Useful for commands that accept file paths or other positional parameters.
+ * 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"]
- * ```
+ *   ;```typescript
+ *   // process.argv = ["node", "script.js", "src", "lib", "--verbose"]
+ *   getPositionalArgs() // ["src", "lib"]
+ *   ```
  */
 export declare function getPositionalArgs(startIndex?: number): string[];
 /**
  * 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
- * ```
+ *   ;```typescript
+ *   hasFlag('verbose') // true if --verbose is in process.argv
+ *   hasFlag('force', ['--force', '--quiet']) // true
+ *   ```
  */
 export declare function hasFlag(flag: string, argv?: string[]): boolean;
 /**
- * Parse command-line arguments with a Node.js parseArgs-compatible API.
- * Uses yargs-parser internally for robust argument parsing.
+ * 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' },
- *   },
- * })
- * ```
+ *   ;```typescript
+ *   const { values, positionals } = parseArgs({
+ *     args: ['--force', '--quiet', 'file.ts'],
+ *     options: {
+ *       force: { type: 'boolean' },
+ *       quiet: { type: 'boolean', short: 'q' },
+ *     },
+ *   })
+ *   ```
  */
 export declare function parseArgs<T = Record<string, unknown>>(config?: ParseArgsConfig): ParsedArgs<T>;
 /**
- * Parse command-line arguments with Socket defaults.
- * Provides sensible defaults for Socket CLI applications.
+ * 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' } },
- * })
- * ```
+ *   ;```typescript
+ *   const { values, positionals } = parseArgsWithDefaults({
+ *     args: ['--force', 'file.ts'],
+ *     options: { force: { type: 'boolean' } },
+ *   })
+ *   ```
  */
 export declare function parseArgsWithDefaults<T = Record<string, unknown>>(config?: ParseArgsConfig): ParsedArgs<T>;
 export {};

package/dist/argv/parse.js

@@ -39,7 +39,9 @@ __export(parse_exports, {
 module.exports = __toCommonJS(parse_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_yargs_parser = __toESM(require("../external/yargs-parser"));
-var import_primordials = require("../primordials");
+var import_array = require("../primordials/array");
+var import_object = require("../primordials/object");
+var import_string = require("../primordials/string");
 const commonParseArgsConfig = {
   options: {
     force: {
@@ -61,7 +63,7 @@ function getPositionalArgs(startIndex = 2) {
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
-    if ((0, import_primordials.StringPrototypeStartsWith)(arg, "-")) {
+    if ((0, import_string.StringPrototypeStartsWith)(arg, "-")) {
       break;
     }
     positionals.push(arg);
@@ -70,7 +72,7 @@ function getPositionalArgs(startIndex = 2) {
   return positionals;
 }
 function hasFlag(flag, argv = import_node_process.default.argv) {
-  return (0, import_primordials.ArrayPrototypeIncludes)(argv, `--${flag}`);
+  return (0, import_array.ArrayPrototypeIncludes)(argv, `--${flag}`);
 }
 function parseArgs(config = {}) {
   const {
@@ -115,7 +117,7 @@ function parseArgs(config = {}) {
       ...configuration
     }
   };
-  for (const { 0: key, 1: optionConfig } of (0, import_primordials.ObjectEntries)(options)) {
+  for (const { 0: key, 1: optionConfig } of (0, import_object.ObjectEntries)(options)) {
     const {
       coerce,
       default: defaultValue,

package/dist/arrays/_internal.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @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.
+ */
+/**
+ * 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.
+ */
+export declare function getConjunctionFormatter(): Intl.ListFormat;
+/**
+ * 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.
+ */
+export declare function getDisjunctionFormatter(): Intl.ListFormat;

package/dist/{arrays.js → arrays/_internal.js}

@@ -18,17 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var arrays_exports = {};
-__export(arrays_exports, {
-  arrayChunk: () => arrayChunk,
-  arrayUnique: () => arrayUnique,
-  isArray: () => isArray,
-  joinAnd: () => joinAnd,
-  joinOr: () => joinOr
+var internal_exports = {};
+__export(internal_exports, {
+  getConjunctionFormatter: () => getConjunctionFormatter,
+  getDisjunctionFormatter: () => getDisjunctionFormatter
 });
-module.exports = __toCommonJS(arrays_exports);
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(internal_exports);
 let _conjunctionFormatter;
+let _disjunctionFormatter;
 // @__NO_SIDE_EFFECTS__
 function getConjunctionFormatter() {
   if (_conjunctionFormatter === void 0) {
@@ -40,7 +37,6 @@ function getConjunctionFormatter() {
   }
   return _conjunctionFormatter;
 }
-let _disjunctionFormatter;
 // @__NO_SIDE_EFFECTS__
 function getDisjunctionFormatter() {
   if (_disjunctionFormatter === void 0) {
@@ -52,37 +48,8 @@ function getDisjunctionFormatter() {
   }
   return _disjunctionFormatter;
 }
-// @__NO_SIDE_EFFECTS__
-function arrayChunk(arr, size) {
-  const chunkSize = size ?? 2;
-  if (chunkSize <= 0) {
-    throw new import_primordials.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;
-}
-// @__NO_SIDE_EFFECTS__
-function arrayUnique(arr) {
-  return [...new import_primordials.SetCtor(arr)];
-}
-const isArray = Array.isArray;
-// @__NO_SIDE_EFFECTS__
-function joinAnd(arr) {
-  return (/* @__PURE__ */ getConjunctionFormatter()).format(arr);
-}
-// @__NO_SIDE_EFFECTS__
-function joinOr(arr) {
-  return (/* @__PURE__ */ getDisjunctionFormatter()).format(arr);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  arrayChunk,
-  arrayUnique,
-  isArray,
-  joinAnd,
-  joinOr
+  getConjunctionFormatter,
+  getDisjunctionFormatter
 });