@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/url/predicates.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 predicates_exports = {};
+__export(predicates_exports, {
+  isUrl: () => isUrl
+});
+module.exports = __toCommonJS(predicates_exports);
+var import_parse = require("./parse");
+// @__NO_SIDE_EFFECTS__
+function isUrl(value) {
+  return (typeof value === "string" && value !== "" || value !== null && typeof value === "object") && !!(0, import_parse.parseUrl)(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isUrl
+});

package/dist/url/search-params.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @file URL search-param coercion helpers — `urlSearchParamsAs*` normalise a
+ *   raw `string | null | undefined` value into a typed shape (array / boolean /
+ *   number / string) with a default. `urlSearchParamsGet*` take a
+ *   `URLSearchParams` instance and a key.
+ */
+import type { UrlSearchParamsAsBooleanOptions, UrlSearchParamsAsNumberOptions, UrlSearchParamsAsStringOptions, UrlSearchParamsGetBooleanOptions } from './types';
+/**
+ * Convert a URL search parameter to an array.
+ *
+ * @example
+ *   ;```typescript
+ *   urlSearchParamsAsArray('a, b, c') // ['a', 'b', 'c']
+ *   urlSearchParamsAsArray(null) // []
+ *   ```
+ */
+export declare function urlSearchParamsAsArray(value: string | null | undefined): string[];
+/**
+ * Convert a URL search parameter to a boolean.
+ *
+ * @example
+ *   ;```typescript
+ *   urlSearchParamsAsBoolean('true') // true
+ *   urlSearchParamsAsBoolean('0') // false
+ *   urlSearchParamsAsBoolean(null) // false
+ *   ```
+ */
+export declare function urlSearchParamsAsBoolean(value: string | null | undefined, options?: UrlSearchParamsAsBooleanOptions | undefined): boolean;
+/**
+ * Get number value from URLSearchParams with a default.
+ *
+ * @example
+ *   ;```typescript
+ *   const params = new URLSearchParams('limit=10')
+ *   urlSearchParamsAsNumber(params, 'limit') // 10
+ *   urlSearchParamsAsNumber(params, 'other') // 0
+ *   ```
+ */
+export declare function urlSearchParamsAsNumber(params: URLSearchParams | null | undefined, key: string, options?: UrlSearchParamsAsNumberOptions | undefined): number;
+/**
+ * Get string value from URLSearchParams with a default.
+ *
+ * @example
+ *   ;```typescript
+ *   const params = new URLSearchParams('name=socket')
+ *   urlSearchParamsAsString(params, 'name') // 'socket'
+ *   urlSearchParamsAsString(params, 'other') // ''
+ *   ```
+ */
+export declare function urlSearchParamsAsString(params: URLSearchParams | null | undefined, key: string, options?: UrlSearchParamsAsStringOptions | undefined): string;
+/**
+ * Helper to get array from URLSearchParams.
+ *
+ * @example
+ *   ;```typescript
+ *   const params = new URLSearchParams('tags=a,b,c')
+ *   urlSearchParamsGetArray(params, 'tags') // ['a', 'b', 'c']
+ *   ```
+ */
+export declare function urlSearchParamsGetArray(params: URLSearchParams | null | undefined, key: string): string[];
+/**
+ * Helper to get boolean from URLSearchParams.
+ *
+ * @example
+ *   ;```typescript
+ *   const params = new URLSearchParams('debug=true')
+ *   urlSearchParamsGetBoolean(params, 'debug') // true
+ *   urlSearchParamsGetBoolean(params, 'other') // false
+ *   ```
+ */
+export declare function urlSearchParamsGetBoolean(params: URLSearchParams | null | undefined, key: string, options?: UrlSearchParamsGetBooleanOptions | undefined): boolean;

package/dist/{url.js → url/search-params.js}

@@ -18,56 +18,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var url_exports = {};
-__export(url_exports, {
-  createRelativeUrl: () => createRelativeUrl,
-  isUrl: () => isUrl,
-  parseUrl: () => parseUrl,
-  urlSearchParamAsArray: () => urlSearchParamAsArray,
-  urlSearchParamAsBoolean: () => urlSearchParamAsBoolean,
-  urlSearchParamAsNumber: () => urlSearchParamAsNumber,
-  urlSearchParamAsString: () => urlSearchParamAsString,
+var search_params_exports = {};
+__export(search_params_exports, {
+  urlSearchParamsAsArray: () => urlSearchParamsAsArray,
+  urlSearchParamsAsBoolean: () => urlSearchParamsAsBoolean,
+  urlSearchParamsAsNumber: () => urlSearchParamsAsNumber,
+  urlSearchParamsAsString: () => urlSearchParamsAsString,
   urlSearchParamsGetArray: () => urlSearchParamsGetArray,
   urlSearchParamsGetBoolean: () => urlSearchParamsGetBoolean
 });
-module.exports = __toCommonJS(url_exports);
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(search_params_exports);
+var import_number = require("../primordials/number");
 const BooleanCtor = Boolean;
-const UrlCtor = URL;
 // @__NO_SIDE_EFFECTS__
-function createRelativeUrl(path, options) {
-  const { base = "" } = {
-    __proto__: null,
-    ...options
-  };
-  const relativePath = (0, import_primordials.StringPrototypeReplace)(path, /^\//, "");
-  if (base) {
-    let baseUrl = base;
-    if (!(0, import_primordials.StringPrototypeEndsWith)(baseUrl, "/")) {
-      baseUrl += "/";
-    }
-    return baseUrl + relativePath;
-  }
-  return relativePath;
-}
-// @__NO_SIDE_EFFECTS__
-function isUrl(value) {
-  return (typeof value === "string" && value !== "" || value !== null && typeof value === "object") && !!/* @__PURE__ */ parseUrl(value);
-}
-// @__NO_SIDE_EFFECTS__
-function parseUrl(value) {
-  try {
-    return new UrlCtor(value);
-  } catch {
-  }
-  return void 0;
-}
-// @__NO_SIDE_EFFECTS__
-function urlSearchParamAsArray(value) {
+function urlSearchParamsAsArray(value) {
   return typeof value === "string" ? value.trim().split(/, */).map((v) => v.trim()).filter(BooleanCtor) : [];
 }
 // @__NO_SIDE_EFFECTS__
-function urlSearchParamAsBoolean(value, options) {
+function urlSearchParamsAsBoolean(value, options) {
   const { defaultValue = false } = {
     __proto__: null,
     ...options
@@ -86,7 +54,7 @@ function urlSearchParamAsBoolean(value, options) {
   return !!value;
 }
 // @__NO_SIDE_EFFECTS__
-function urlSearchParamAsNumber(params, key, options) {
+function urlSearchParamsAsNumber(params, key, options) {
   const { defaultValue = 0 } = {
     __proto__: null,
     ...options
@@ -95,13 +63,13 @@ function urlSearchParamAsNumber(params, key, options) {
     const value = params.get(key);
     if (value !== null) {
       const num = Number(value);
-      return !(0, import_primordials.NumberIsNaN)(num) ? num : defaultValue;
+      return !(0, import_number.NumberIsNaN)(num) ? num : defaultValue;
     }
   }
   return defaultValue;
 }
 // @__NO_SIDE_EFFECTS__
-function urlSearchParamAsString(params, key, options) {
+function urlSearchParamsAsString(params, key, options) {
   const { defaultValue = "" } = {
     __proto__: null,
     ...options
@@ -118,7 +86,7 @@ function urlSearchParamsGetArray(params, key) {
     const values = params.getAll(key);
     const firstValue = values[0];
     if (values.length === 1 && firstValue && firstValue.includes(",")) {
-      return /* @__PURE__ */ urlSearchParamAsArray(firstValue);
+      return /* @__PURE__ */ urlSearchParamsAsArray(firstValue);
     }
     return values;
   }
@@ -132,19 +100,16 @@ function urlSearchParamsGetBoolean(params, key, options) {
   };
   if (params && typeof params.get === "function") {
     const value = params.get(key);
-    return value !== null ? /* @__PURE__ */ urlSearchParamAsBoolean(value, { defaultValue }) : defaultValue;
+    return value !== null ? /* @__PURE__ */ urlSearchParamsAsBoolean(value, { defaultValue }) : defaultValue;
   }
   return defaultValue;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createRelativeUrl,
-  isUrl,
-  parseUrl,
-  urlSearchParamAsArray,
-  urlSearchParamAsBoolean,
-  urlSearchParamAsNumber,
-  urlSearchParamAsString,
+  urlSearchParamsAsArray,
+  urlSearchParamsAsBoolean,
+  urlSearchParamsAsNumber,
+  urlSearchParamsAsString,
   urlSearchParamsGetArray,
   urlSearchParamsGetBoolean
 });

package/dist/url/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file Public type surface for `url/*` modules — option interfaces consumed by
+ *   `createRelativeUrl`, `urlSearchParamsAs*`, and `urlSearchParamsGet*`. Pure
+ *   types, no runtime side effects.
+ */
+export interface CreateRelativeUrlOptions {
+    base?: string;
+}
+export interface UrlSearchParamsAsBooleanOptions {
+    defaultValue?: boolean;
+}
+export interface UrlSearchParamsAsNumberOptions {
+    defaultValue?: number;
+}
+export interface UrlSearchParamsAsStringOptions {
+    defaultValue?: string;
+}
+export interface UrlSearchParamsGetBooleanOptions {
+    defaultValue?: boolean;
+}

package/dist/url/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/versions/_internal.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file Private internals for `versions/*` modules — eagerly picks the right
+ *   implementation at module load. On socket-btm's smol Node binary, prefers
+ *   `node:smol-versions` (C++-accelerated via
+ *   `internalBinding('smol_versions_native')`); on stock Node, falls through to
+ *   the vendored JS `semver`. Both expose a strict-superset surface for the ops
+ *   `versions/*` calls, so leaves can forward to `impl.<op>` directly without
+ *   per-call branching. `getMajorVersion`-style helpers need the parsed object
+ *   shape (`{major, minor, patch}`) which only `semver.parse` exposes — those
+ *   leaves use `getSemver()` directly instead of going through `impl`.
+ */
+import type * as semverType from '../external/semver';
+import type { SmolVersionsBinding } from '../smol/versions';
+/**
+ * The vendored `semver` JS implementation. Always available — used directly by
+ * the leaves that need the parsed `{major, minor, patch}` shape (which
+ * smol-versions doesn't expose).
+ */
+export declare function getSemver(): typeof semverType;
+/**
+ * Resolved version implementation: smol-versions on the smol Node binary,
+ * otherwise the vendored `semver`. Bound once at module load.
+ */
+export declare const impl: SmolVersionsBinding | typeof semverType;

package/dist/versions/_internal.js

@@ -0,0 +1,37 @@
+"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, {
+  getSemver: () => getSemver,
+  impl: () => impl
+});
+module.exports = __toCommonJS(internal_exports);
+var import_versions = require("../smol/versions");
+const _semver = require("../external/semver");
+function getSemver() {
+  return _semver;
+}
+const impl = (0, import_versions.getSmolVersions)() ?? _semver;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSemver,
+  impl
+});

package/dist/versions/compare.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file Version comparison operators aligned with `node:smol-versions` (the
+ *   C++-accelerated multi-ecosystem version helper shipped by the smol Node
+ *   binary). The same names + signatures also match the vendored `semver` JS
+ *   lib — both impls expose this surface, so we pick one at module load (`impl
+ *   = smol ?? semver`) and each export just forwards to it.
+ *
+ *   - `compare(a, b)` — returns `-1 | 0 | 1` (undefined on invalid input)
+ *   - `eq(a, b)`, `neq(a, b)` — equality / inequality
+ *   - `lt(a, b)`, `lte(a, b)` — less-than / less-or-equal
+ *   - `gt(a, b)`, `gte(a, b)` — greater-than / greater-or-equal
+ *   - `sort(versions)` — ascending sort
+ *   - `rsort(versions)` — descending sort `compare()` swallows the smol/semver
+ *     "invalid version" throw into `undefined` for the caller's convenience;
+ *     all other ops surface whatever the underlying impl returns. The vendored
+ *     `semver` export has no `neq` helper, so when we fall back to it we route
+ *     `neq` through `!eq` to match smol's semantics.
+ */
+/**
+ * Compare two semantic version strings.
+ *
+ * @returns -1 if a < b, 0 if a === b, 1 if a > b, or undefined if invalid.
+ */
+export declare function compare(a: string, b: string): -1 | 0 | 1 | undefined;
+/**
+ * Check if a equals b.
+ */
+export declare const eq: (a: string, b: string) => boolean;
+/**
+ * Check if a does not equal b.
+ */
+export declare const neq: (a: string, b: string) => boolean;
+/**
+ * Check if a is greater than b.
+ */
+export declare const gt: (a: string, b: string) => boolean;
+/**
+ * Check if a is greater than or equal to b.
+ */
+export declare const gte: (a: string, b: string) => boolean;
+/**
+ * Check if a is less than b.
+ */
+export declare const lt: (a: string, b: string) => boolean;
+/**
+ * Check if a is less than or equal to b.
+ */
+export declare const lte: (a: string, b: string) => boolean;
+/**
+ * Sort versions in descending order.
+ */
+export declare function rsort(versions: readonly string[]): string[];
+/**
+ * Sort versions in ascending order. The input is spread so callers can pass a
+ * `readonly string[]` even when the impl mutates internally.
+ */
+export declare function sort(versions: readonly string[]): string[];

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
+});