@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/themes/types.d.ts

@@ -1,67 +1,109 @@
 /**
- * @fileoverview Elegant theme type system.
- * Type-safe theming for spinners, loggers, prompts, and links.
+ * @file Elegant theme type system. Type-safe theming for spinners, loggers,
+ *   prompts, and links.
  */
-import type { ColorValue } from '../colors';
+import type { ColorValue } from '../colors/types';
 import type { ShimmerDirection } from '../effects/shimmer';
-import type { SpinnerStyle } from '../spinner';
+import type { SpinnerStyle } from '../spinner/types';
 /**
- * Color reference — direct value or semantic keyword.
- * Keywords: 'primary', 'secondary', 'inherit', 'rainbow'
+ * Color reference — direct value or semantic keyword. Keywords: 'primary',
+ * 'secondary', 'inherit', 'rainbow'
  */
 export type ColorReference = ColorValue | 'primary' | 'secondary' | 'inherit' | 'rainbow';
 /**
  * Theme color palette — semantic colors for visual harmony.
  */
 export type ThemeColors = {
-    /** Primary brand identity */
+    /**
+     * Primary brand identity.
+     */
     primary: ColorValue;
-    /** Secondary accent (optional) */
+    /**
+     * Secondary accent (optional)
+     */
     secondary?: ColorValue | undefined;
-    /** Success indicator ✓ */
+    /**
+     * Success indicator ✓
+     */
     success: ColorValue;
-    /** Error indicator ✗ */
+    /**
+     * Error indicator ✗
+     */
     error: ColorValue;
-    /** Warning indicator ⚠ */
+    /**
+     * Warning indicator ⚠
+     */
     warning: ColorValue;
-    /** Information indicator ℹ */
+    /**
+     * Information indicator ℹ.
+     */
     info: ColorValue;
-    /** Progress indicator → */
+    /**
+     * Progress indicator →
+     */
     step: ColorValue;
-    /** Primary text */
+    /**
+     * Primary text.
+     */
     text: ColorValue;
-    /** Dimmed text */
+    /**
+     * Dimmed text.
+     */
     textDim: ColorValue;
-    /** Hyperlinks */
+    /**
+     * Hyperlinks.
+     */
     link: ColorReference;
-    /** Interactive prompts */
+    /**
+     * Interactive prompts.
+     */
     prompt: ColorReference;
 };
 /**
  * Theme effects — animations and visual enhancements.
  */
 export type ThemeEffects = {
-    /** Spinner configuration */
+    /**
+     * Spinner configuration.
+     */
     spinner?: {
-        /** Color (supports theme references) */
+        /**
+         * Color (supports theme references)
+         */
         color?: ColorReference | undefined;
-        /** Animation style */
+        /**
+         * Animation style.
+         */
         style?: SpinnerStyle | string | undefined;
     };
-    /** Shimmer configuration */
+    /**
+     * Shimmer configuration.
+     */
     shimmer?: {
-        /** Enable shimmer */
+        /**
+         * Enable shimmer.
+         */
         enabled?: boolean | undefined;
-        /** Color (single, gradient, or keyword) */
+        /**
+         * Color (single, gradient, or keyword)
+         */
         color?: ColorReference | ColorValue[] | undefined;
-        /** Direction */
+        /**
+         * Direction.
+         */
         direction?: ShimmerDirection | undefined;
-        /** Speed (steps per frame) */
+        /**
+         * Speed (steps per frame)
+         */
         speed?: number | undefined;
     };
-    /** Pulse configuration */
+    /**
+     * Pulse configuration.
+     */
     pulse?: {
-        /** Speed (milliseconds) */
+        /**
+         * Speed (milliseconds)
+         */
         speed?: number | undefined;
     };
 };
@@ -69,25 +111,41 @@ export type ThemeEffects = {
  * Theme metadata — descriptive information.
  */
 export type ThemeMeta = {
-    /** Description */
+    /**
+     * Description.
+     */
     description?: string | undefined;
-    /** Author */
+    /**
+     * Author.
+     */
     author?: string | undefined;
-    /** Version */
+    /**
+     * Version.
+     */
     version?: string | undefined;
 };
 /**
  * Theme definition — complete visual identity.
  */
 export type Theme = {
-    /** Unique identifier (kebab-case) */
+    /**
+     * Unique identifier (kebab-case)
+     */
     name: string;
-    /** Display name */
+    /**
+     * Display name.
+     */
     displayName: string;
-    /** Color palette */
+    /**
+     * Color palette.
+     */
     colors: ThemeColors;
-    /** Visual effects (optional) */
+    /**
+     * Visual effects (optional)
+     */
     effects?: ThemeEffects | undefined;
-    /** Metadata (optional) */
+    /**
+     * Metadata (optional)
+     */
     meta?: ThemeMeta | undefined;
 };

package/dist/url/parse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file URL parsing helpers — `parseUrl` (safe `new URL(...)` wrapper that
+ *   returns `undefined` instead of throwing) and `createRelativeUrl` (compose a
+ *   relative path against an optional base).
+ */
+import type { CreateRelativeUrlOptions } from './types';
+/**
+ * Create a relative URL for testing.
+ *
+ * @example
+ *   ;```typescript
+ *   createRelativeUrl('/api/test') // 'api/test'
+ *   createRelativeUrl('/api/test', { base: 'https://example.com' }) // 'https://example.com/api/test'
+ *   ```
+ */
+export declare function createRelativeUrl(path: string, options?: CreateRelativeUrlOptions | undefined): string;
+/**
+ * Parse a value as a URL.
+ *
+ * @example
+ *   ;```typescript
+ *   parseUrl('https://example.com') // URL { href: 'https://example.com/' }
+ *   parseUrl('invalid') // undefined
+ *   ```
+ */
+export declare function parseUrl(value: string | URL): URL | undefined;

package/dist/url/parse.js

@@ -0,0 +1,57 @@
+"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, {
+  createRelativeUrl: () => createRelativeUrl,
+  parseUrl: () => parseUrl
+});
+module.exports = __toCommonJS(parse_exports);
+var import_string = require("../primordials/string");
+const UrlCtor = URL;
+// @__NO_SIDE_EFFECTS__
+function createRelativeUrl(path, options) {
+  const { base = "" } = {
+    __proto__: null,
+    ...options
+  };
+  const relativePath = (0, import_string.StringPrototypeReplace)(path, /^\//, "");
+  if (base) {
+    let baseUrl = base;
+    if (!(0, import_string.StringPrototypeEndsWith)(baseUrl, "/")) {
+      baseUrl += "/";
+    }
+    return baseUrl + relativePath;
+  }
+  return relativePath;
+}
+// @__NO_SIDE_EFFECTS__
+function parseUrl(value) {
+  try {
+    return new UrlCtor(value);
+  } catch {
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRelativeUrl,
+  parseUrl
+});

package/dist/url/predicates.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file URL type-guard predicates — `isUrl` answers whether a value parses as a
+ *   valid URL via `parseUrl`.
+ */
+/**
+ * Check if a value is a valid URL.
+ *
+ * @example
+ *   ;```typescript
+ *   isUrl('https://example.com') // true
+ *   isUrl('not a url') // false
+ *   isUrl(null) // false
+ *   ```
+ */
+export declare function isUrl(value: string | URL | null | undefined): boolean;

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[];