@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/versions/compare.js

@@ -0,0 +1,65 @@
+"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 compare_exports = {};
+__export(compare_exports, {
+  compare: () => compare,
+  eq: () => eq,
+  gt: () => gt,
+  gte: () => gte,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  rsort: () => rsort,
+  sort: () => sort
+});
+module.exports = __toCommonJS(compare_exports);
+var import_internal = require("./_internal");
+function compare(a, b) {
+  try {
+    return import_internal.impl.compare(a, b);
+  } catch {
+    return void 0;
+  }
+}
+const eq = import_internal.impl.eq.bind(import_internal.impl);
+const neq = typeof import_internal.impl.neq === "function" ? import_internal.impl.neq.bind(import_internal.impl) : (a, b) => !import_internal.impl.eq(a, b);
+const gt = import_internal.impl.gt.bind(import_internal.impl);
+const gte = import_internal.impl.gte.bind(import_internal.impl);
+const lt = import_internal.impl.lt.bind(import_internal.impl);
+const lte = import_internal.impl.lte.bind(import_internal.impl);
+function rsort(versions) {
+  return import_internal.impl.rsort([...versions]);
+}
+function sort(versions) {
+  return import_internal.impl.sort([...versions]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compare,
+  eq,
+  gt,
+  gte,
+  lt,
+  lte,
+  neq,
+  rsort,
+  sort
+});

package/dist/versions/modify.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Mutation helpers — `incrementVersion` bumps a version by release type
+ *   ('major' | 'minor' | 'patch' | 'pre*'), and `versionDiff` returns the kind
+ *   of step between two versions. Both use the vendored `semver` directly
+ *   because the increment / diff APIs aren't on the smol-versions surface.
+ */
+/**
+ * Increment a version by the specified release type.
+ *
+ * @example
+ *   ;```typescript
+ *   incrementVersion('1.2.3', 'patch') // '1.2.4'
+ *   incrementVersion('1.2.3', 'minor') // '1.3.0'
+ *   incrementVersion('1.2.3', 'major') // '2.0.0'
+ *   ```
+ */
+export declare function incrementVersion(version: string, release: 'major' | 'minor' | 'patch' | 'premajor' | 'preminor' | 'prepatch' | 'prerelease', identifier?: string | undefined): string | undefined;
+/**
+ * Get the difference between two versions.
+ *
+ * @example
+ *   ;```typescript
+ *   versionDiff('1.0.0', '2.0.0') // 'major'
+ *   versionDiff('1.0.0', '1.1.0') // 'minor'
+ *   versionDiff('1.0.0', '1.0.1') // 'patch'
+ *   ```
+ */
+export declare function versionDiff(version1: string, version2: string): 'major' | 'premajor' | 'minor' | 'preminor' | 'patch' | 'prepatch' | 'prerelease' | 'release' | undefined;

package/dist/versions/modify.js

@@ -0,0 +1,44 @@
+"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 modify_exports = {};
+__export(modify_exports, {
+  incrementVersion: () => incrementVersion,
+  versionDiff: () => versionDiff
+});
+module.exports = __toCommonJS(modify_exports);
+var import_internal = require("./_internal");
+function incrementVersion(version, release, identifier) {
+  const semver = (0, import_internal.getSemver)();
+  return semver.inc(version, release, identifier) || void 0;
+}
+function versionDiff(version1, version2) {
+  try {
+    const semver = (0, import_internal.getSemver)();
+    return semver.diff(version1, version2) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  incrementVersion,
+  versionDiff
+});

package/dist/versions/parse.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @file Parsing helpers — `coerceVersion` rounds a sloppy input ("1.2") up to a
+ *   valid semver triple, `parseVersion` returns `{major, minor, patch,
+ *   prerelease, build}`, and the `getMajor*` / `getMinor*` / `getPatchVersion`
+ *   accessors return a single component. `isValidVersion` is also here because
+ *   validation is effectively "did parse succeed". All go through the vendored
+ *   `semver` directly — smol-versions doesn't expose the parsed shape.
+ */
+import type { ParsedVersion } from './types';
+/**
+ * Coerce a version string to valid semver format.
+ *
+ * @example
+ *   ;```typescript
+ *   coerceVersion('1.2') // '1.2.0'
+ *   coerceVersion('v3') // '3.0.0'
+ *   coerceVersion('abc') // undefined
+ *   ```
+ */
+export declare function coerceVersion(version: string): string | undefined;
+/**
+ * Get the major version number from a version string.
+ *
+ * @example
+ *   ;```typescript
+ *   getMajorVersion('3.2.1') // 3
+ *   ```
+ */
+export declare function getMajorVersion(version: string): number | undefined;
+/**
+ * Get the minor version number from a version string.
+ *
+ * @example
+ *   ;```typescript
+ *   getMinorVersion('3.2.1') // 2
+ *   ```
+ */
+export declare function getMinorVersion(version: string): number | undefined;
+/**
+ * Get the patch version number from a version string.
+ *
+ * @example
+ *   ;```typescript
+ *   getPatchVersion('3.2.1') // 1
+ *   ```
+ */
+export declare function getPatchVersion(version: string): number | undefined;
+/**
+ * Validate if a string is a valid semantic version.
+ *
+ * @example
+ *   ;```typescript
+ *   isValidVersion('1.2.3') // true
+ *   isValidVersion('abc') // false
+ *   ```
+ */
+export declare function isValidVersion(version: string): boolean;
+/**
+ * Parse a version string and return major, minor, patch components.
+ *
+ * @example
+ *   ;```typescript
+ *   parseVersion('1.2.3')
+ *   // { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }
+ *   ```
+ */
+export declare function parseVersion(version: string): ParsedVersion | undefined;

package/dist/versions/parse.js

@@ -0,0 +1,77 @@
+"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_exports = {};
+__export(parse_exports, {
+  coerceVersion: () => coerceVersion,
+  getMajorVersion: () => getMajorVersion,
+  getMinorVersion: () => getMinorVersion,
+  getPatchVersion: () => getPatchVersion,
+  isValidVersion: () => isValidVersion,
+  parseVersion: () => parseVersion
+});
+module.exports = __toCommonJS(parse_exports);
+var import_internal = require("./_internal");
+function coerceVersion(version) {
+  const semver = (0, import_internal.getSemver)();
+  const coerced = semver.coerce(version);
+  return coerced?.version;
+}
+function getMajorVersion(version) {
+  const semver = (0, import_internal.getSemver)();
+  const parsed = semver.parse(version);
+  return parsed?.major;
+}
+function getMinorVersion(version) {
+  const semver = (0, import_internal.getSemver)();
+  const parsed = semver.parse(version);
+  return parsed?.minor;
+}
+function getPatchVersion(version) {
+  const semver = (0, import_internal.getSemver)();
+  const parsed = semver.parse(version);
+  return parsed?.patch;
+}
+function isValidVersion(version) {
+  return import_internal.impl.valid(version) != null;
+}
+function parseVersion(version) {
+  const semver = (0, import_internal.getSemver)();
+  const parsed = semver.parse(version);
+  if (!parsed) {
+    return void 0;
+  }
+  return {
+    major: parsed.major,
+    minor: parsed.minor,
+    patch: parsed.patch,
+    prerelease: parsed.prerelease,
+    build: parsed.build
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  coerceVersion,
+  getMajorVersion,
+  getMinorVersion,
+  getPatchVersion,
+  isValidVersion,
+  parseVersion
+});

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/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);