@helpers4/version 2.0.0-alpha.3 → 2.0.0-alpha.6

package/README.md

@@ -12,10 +12,11 @@ A set of helpers for working with URLs.
 [https://helpers4.js.org/version](https://helpers4.js.org/version)
 
 <!-- AUTOMATIC-METHODS -->
-- stripV
 - compare
-- satisfiesRange
 - increment
+- parse
+- satisfiesRange
+- stripV
 <!-- /AUTOMATIC-METHODS -->
 
 ## See
@@ -24,6 +25,7 @@ A set of helpers for working with URLs.
 - [array](../array)
 - [date](../date)
 - [function](../function)
+- [math](../math)
 - [number](../number)
 - [object](../object)
 - [observable](../observable)
@@ -41,6 +43,7 @@ A set of helpers for working with URLs.
 | array | [@helpers4/array](https://www.npmjs.com/package/@helpers4/array) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/array) | Array manipulation utilities |
 | date | [@helpers4/date](https://www.npmjs.com/package/@helpers4/date) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/date) | date utilities |
 | function | [@helpers4/function](https://www.npmjs.com/package/@helpers4/function) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/function) | Function utilities and type guards |
+| math | [@helpers4/math](https://www.npmjs.com/package/@helpers4/math) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/math) | math utilities |
 | number | [@helpers4/number](https://www.npmjs.com/package/@helpers4/number) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/number) | number utilities |
 | object | [@helpers4/object](https://www.npmjs.com/package/@helpers4/object) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/object) | Object manipulation utilities |
 | observable | [@helpers4/observable](https://www.npmjs.com/package/@helpers4/observable) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/observable) | Observable utilities and combinators |

package/api.json

@@ -0,0 +1,104 @@
+{
+  "category": "version",
+  "members": [
+    {
+      "name": "compare",
+      "kind": "function",
+      "description": "Compares two semantic version strings according to SemVer 2.0.0 specification\n\nSupports:\n- Core version: MAJOR.MINOR.PATCH\n- Pre-release: -alpha, -beta.1, -rc.1, etc.\n- Build metadata: +build, +sha.abc123 (ignored in comparison per spec)\n- Optional 'v' prefix",
+      "signature": "compare(version1: string, version2: string): number",
+      "params": [
+        {
+          "name": "version1",
+          "type": "string",
+          "description": "First version string"
+        },
+        {
+          "name": "version2",
+          "type": "string",
+          "description": "Second version string"
+        }
+      ],
+      "returns": "number",
+      "examples": [
+        "```ts\ncompare('1.0.0', '2.0.0') // -1\ncompare('1.0.0-alpha', '1.0.0') // -1 (prerelease < release)\ncompare('1.0.0-alpha', '1.0.0-beta') // -1\ncompare('1.0.0-alpha.1', '1.0.0-alpha.2') // -1\ncompare('1.0.0+build1', '1.0.0+build2') // 0 (build metadata ignored)\n```"
+      ]
+    },
+    {
+      "name": "increment",
+      "kind": "function",
+      "description": "Increments a semantic version",
+      "signature": "increment(version: string, type: \"major\" | \"minor\" | \"patch\"): string",
+      "params": [
+        {
+          "name": "version",
+          "type": "string",
+          "description": "The version to increment"
+        },
+        {
+          "name": "type",
+          "type": "\"major\" | \"minor\" | \"patch\"",
+          "description": "The increment type ('major', 'minor', 'patch')"
+        }
+      ],
+      "returns": "string"
+    },
+    {
+      "name": "parse",
+      "kind": "function",
+      "description": "Parses a semantic version string into its components according to SemVer 2.0.0 specification\n\nSupports:\n- Core version: MAJOR.MINOR.PATCH\n- Pre-release: -alpha, -beta.1, -rc.1, -0.3.7, -x.7.z.92\n- Build metadata: +build, +sha.abc123, +20130313144700\n- Optional 'v' prefix (commonly used in git tags)",
+      "signature": "parse(version: string): ParsedVersion",
+      "params": [
+        {
+          "name": "version",
+          "type": "string",
+          "description": "Version string to parse"
+        }
+      ],
+      "returns": "ParsedVersion",
+      "examples": [
+        "```ts\nparse('1.2.3') // { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }\nparse('v1.0.0-alpha.1') // { major: 1, minor: 0, patch: 0, prerelease: ['alpha', '1'], build: [] }\nparse('2.0.0+build.123') // { major: 2, minor: 0, patch: 0, prerelease: [], build: ['build', '123'] }\nparse('1.0.0-beta+exp.sha.5114f85') // { major: 1, minor: 0, patch: 0, prerelease: ['beta'], build: ['exp', 'sha', '5114f85'] }\n```"
+      ]
+    },
+    {
+      "name": "ParsedVersion",
+      "kind": "interface",
+      "description": "Represents a parsed semantic version according to SemVer 2.0.0 specification"
+    },
+    {
+      "name": "satisfiesRange",
+      "kind": "function",
+      "description": "Checks if a version satisfies a range (simple implementation)",
+      "signature": "satisfiesRange(version: string, range: string): boolean",
+      "params": [
+        {
+          "name": "version",
+          "type": "string",
+          "description": "Version to check"
+        },
+        {
+          "name": "range",
+          "type": "string",
+          "description": "Range pattern (e.g., \">=1.0.0\", \"~1.2.0\", \"^1.0.0\")"
+        }
+      ],
+      "returns": "boolean"
+    },
+    {
+      "name": "stripV",
+      "kind": "function",
+      "description": "Strip the leading \"v\" from a version string if it exists.",
+      "signature": "stripV(version: string): string",
+      "params": [
+        {
+          "name": "version",
+          "type": "string",
+          "description": "The version string to process"
+        }
+      ],
+      "returns": "string",
+      "examples": [
+        "```typescript\nstripV(\"v1.2.3\")     // \"1.2.3\"\nstripV(\"1.2.3\")      // \"1.2.3\"\nstripV(\"v20.1.0\")    // \"20.1.0\"\nstripV(null)         // null\nstripV(undefined)    // undefined\nstripV(\"\")           // \"\"\nstripV(\"1.0.0-beta\") // \"1.0.0-beta\"\n```"
+      ]
+    }
+  ]
+}

package/examples.json

@@ -0,0 +1,90 @@
+{
+  "category": "version",
+  "helpers": [
+    {
+      "helper": "compare",
+      "examples": [
+        {
+          "title": "Compare two semver versions",
+          "description": "Returns -1, 0, or 1 based on SemVer ordering.",
+          "code": "compare('1.0.0', '2.0.0') // => -1\ncompare('1.0.0', '1.0.0') // => 0\ncompare('2.0.0', '1.0.0') // => 1"
+        },
+        {
+          "title": "Prerelease is lower than release",
+          "description": "A prerelease version is always less than the release.",
+          "code": "compare('1.0.0-alpha', '1.0.0')\n// => -1"
+        }
+      ]
+    },
+    {
+      "helper": "increment",
+      "examples": [
+        {
+          "title": "Increment the patch version",
+          "description": "Bumps the patch number while keeping major and minor.",
+          "code": "increment('1.2.3', 'patch')\n// => '1.2.4'"
+        },
+        {
+          "title": "Increment the minor version",
+          "description": "Bumps the minor number and resets patch to 0.",
+          "code": "increment('1.2.3', 'minor')\n// => '1.3.0'"
+        },
+        {
+          "title": "Preserve the v prefix",
+          "description": "The v prefix is preserved if present in the input.",
+          "code": "increment('v1.0.0', 'major')\n// => 'v2.0.0'"
+        }
+      ]
+    },
+    {
+      "helper": "parse",
+      "examples": [
+        {
+          "title": "Parse a semver string",
+          "description": "Breaks a semantic version string into its components.",
+          "code": "parse('1.2.3')\n// => { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }"
+        },
+        {
+          "title": "Parse a prerelease version",
+          "description": "Handles prerelease identifiers and optional v prefix.",
+          "code": "parse('v2.0.0-alpha.1')\n// => { major: 2, minor: 0, patch: 0, prerelease: ['alpha', '1'], build: [] }"
+        }
+      ]
+    },
+    {
+      "helper": "satisfiesRange",
+      "examples": [
+        {
+          "title": "Check caret range",
+          "description": "Caret (^) allows patch and minor updates within the same major.",
+          "code": "satisfiesRange('1.2.3', '^1.0.0')\n// => true"
+        },
+        {
+          "title": "Check greater-than-or-equal range",
+          "description": "The >= operator checks if the version is at least the specified value.",
+          "code": "satisfiesRange('2.0.0', '>=1.5.0')\n// => true"
+        },
+        {
+          "title": "Out of range",
+          "description": "Returns false when the version does not satisfy the range.",
+          "code": "satisfiesRange('0.9.0', '>=1.0.0')\n// => false"
+        }
+      ]
+    },
+    {
+      "helper": "stripV",
+      "examples": [
+        {
+          "title": "Remove v prefix from a version string",
+          "description": "Strips the leading \"v\" from a git tag-style version string.",
+          "code": "stripV('v1.2.3')\n// => '1.2.3'"
+        },
+        {
+          "title": "No-op when there is no v prefix",
+          "description": "Returns the string unchanged when it does not start with \"v\".",
+          "code": "stripV('1.2.3')\n// => '1.2.3'"
+        }
+      ]
+    }
+  ]
+}

package/lib/index.d.ts

@@ -1,4 +1,119 @@
-export declare function stripV(version: string): string; export function stripV(version: null): null; export function stripV(version: undefined): undefined; export function stripV(version: string | null | undefined): string | null | undefined;
-export declare function compare(version1: string, version2: string): number;
-export declare function satisfiesRange(version: string, range: string): boolean;
-export declare function increment(version: string, type: 'major' | 'minor' | 'patch'): string;
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Compares two semantic version strings according to SemVer 2.0.0 specification
+ *
+ * Supports:
+ * - Core version: MAJOR.MINOR.PATCH
+ * - Pre-release: -alpha, -beta.1, -rc.1, etc.
+ * - Build metadata: +build, +sha.abc123 (ignored in comparison per spec)
+ * - Optional 'v' prefix
+ *
+ * @param version1 - First version string
+ * @param version2 - Second version string
+ * @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+ * @example
+ * compare('1.0.0', '2.0.0') // -1
+ * compare('1.0.0-alpha', '1.0.0') // -1 (prerelease < release)
+ * compare('1.0.0-alpha', '1.0.0-beta') // -1
+ * compare('1.0.0-alpha.1', '1.0.0-alpha.2') // -1
+ * compare('1.0.0+build1', '1.0.0+build2') // 0 (build metadata ignored)
+ */
+declare function compare(version1: string, version2: string): number;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Increments a semantic version
+ * @param version - The version to increment
+ * @param type - The increment type ('major', 'minor', 'patch')
+ * @returns Incremented version string
+ */
+declare function increment(version: string, type: 'major' | 'minor' | 'patch'): string;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Represents a parsed semantic version according to SemVer 2.0.0 specification
+ */
+interface ParsedVersion {
+    /** Major version number */
+    major: number;
+    /** Minor version number */
+    minor: number;
+    /** Patch version number */
+    patch: number;
+    /** Pre-release identifiers (e.g., ['alpha', '1'] for -alpha.1) */
+    prerelease: string[];
+    /** Build metadata identifiers (e.g., ['build', '123'] for +build.123) */
+    build: string[];
+}
+/**
+ * Parses a semantic version string into its components according to SemVer 2.0.0 specification
+ *
+ * Supports:
+ * - Core version: MAJOR.MINOR.PATCH
+ * - Pre-release: -alpha, -beta.1, -rc.1, -0.3.7, -x.7.z.92
+ * - Build metadata: +build, +sha.abc123, +20130313144700
+ * - Optional 'v' prefix (commonly used in git tags)
+ *
+ * @param version - Version string to parse
+ * @returns Parsed version object with major, minor, patch, prerelease, and build
+ * @example
+ * parse('1.2.3') // { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }
+ * parse('v1.0.0-alpha.1') // { major: 1, minor: 0, patch: 0, prerelease: ['alpha', '1'], build: [] }
+ * parse('2.0.0+build.123') // { major: 2, minor: 0, patch: 0, prerelease: [], build: ['build', '123'] }
+ * parse('1.0.0-beta+exp.sha.5114f85') // { major: 1, minor: 0, patch: 0, prerelease: ['beta'], build: ['exp', 'sha', '5114f85'] }
+ */
+declare function parse(version: string): ParsedVersion;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Checks if a version satisfies a range (simple implementation)
+ * @param version - Version to check
+ * @param range - Range pattern (e.g., ">=1.0.0", "~1.2.0", "^1.0.0")
+ * @returns True if version satisfies the range
+ */
+declare function satisfiesRange(version: string, range: string): boolean;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Strip the leading "v" from a version string if it exists.
+ *
+ * @param version - The version string to process
+ * @returns The version string without leading "v", or the original value if it's not a string or doesn't start with "v"
+ *
+ * @example
+ * ```typescript
+ * stripV("v1.2.3")     // "1.2.3"
+ * stripV("1.2.3")      // "1.2.3"
+ * stripV("v20.1.0")    // "20.1.0"
+ * stripV(null)         // null
+ * stripV(undefined)    // undefined
+ * stripV("")           // ""
+ * stripV("1.0.0-beta") // "1.0.0-beta"
+ * ```
+ */
+declare function stripV(version: string): string;
+declare function stripV(version: null): null;
+declare function stripV(version: undefined): undefined;
+
+export { compare, increment, parse, satisfiesRange, stripV };
+export type { ParsedVersion };

package/lib/index.js

@@ -1,108 +1,195 @@
-// helpers/version/stripV.ts
-function stripV(version) {
-  return typeof version === "string" && version.startsWith("v") ? version.slice(1) : version;
+//#region helpers/version/parse.ts
+/**
+* Parses a semantic version string into its components according to SemVer 2.0.0 specification
+*
+* Supports:
+* - Core version: MAJOR.MINOR.PATCH
+* - Pre-release: -alpha, -beta.1, -rc.1, -0.3.7, -x.7.z.92
+* - Build metadata: +build, +sha.abc123, +20130313144700
+* - Optional 'v' prefix (commonly used in git tags)
+*
+* @param version - Version string to parse
+* @returns Parsed version object with major, minor, patch, prerelease, and build
+* @example
+* parse('1.2.3') // { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }
+* parse('v1.0.0-alpha.1') // { major: 1, minor: 0, patch: 0, prerelease: ['alpha', '1'], build: [] }
+* parse('2.0.0+build.123') // { major: 2, minor: 0, patch: 0, prerelease: [], build: ['build', '123'] }
+* parse('1.0.0-beta+exp.sha.5114f85') // { major: 1, minor: 0, patch: 0, prerelease: ['beta'], build: ['exp', 'sha', '5114f85'] }
+*/
+function parse(version) {
+	const [versionWithPrerelease, buildString] = version.replace(/^v/, "").split("+");
+	const build = buildString ? buildString.split(".") : [];
+	const [coreVersion, prereleaseString] = versionWithPrerelease.split("-");
+	const prerelease = prereleaseString ? prereleaseString.split(".") : [];
+	const parts = coreVersion.split(".").map(Number);
+	return {
+		major: parts[0] || 0,
+		minor: parts[1] || 0,
+		patch: parts[2] || 0,
+		prerelease,
+		build
+	};
+}
+//#endregion
+//#region helpers/version/compare.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Compares two prerelease identifier arrays according to SemVer spec
+* Rules:
+* - Numeric identifiers are compared as integers
+* - Alphanumeric identifiers are compared lexically (ASCII)
+* - Numeric identifiers have lower precedence than alphanumeric
+* - A larger set of prerelease fields has higher precedence if all preceding are equal
+* @param pre1 - First prerelease array
+* @param pre2 - Second prerelease array
+* @returns -1, 0, or 1
+*/
+function comparePrerelease(pre1, pre2) {
+	if (pre1.length === 0 && pre2.length === 0) return 0;
+	if (pre1.length === 0) return 1;
+	if (pre2.length === 0) return -1;
+	const maxLength = Math.max(pre1.length, pre2.length);
+	for (let i = 0; i < maxLength; i++) {
+		if (i >= pre1.length) return -1;
+		if (i >= pre2.length) return 1;
+		const id1 = pre1[i];
+		const id2 = pre2[i];
+		const isNum1 = /^\d+$/.test(id1);
+		const isNum2 = /^\d+$/.test(id2);
+		if (isNum1 && isNum2) {
+			const num1 = parseInt(id1, 10);
+			const num2 = parseInt(id2, 10);
+			if (num1 < num2) return -1;
+			if (num1 > num2) return 1;
+		} else if (isNum1) return -1;
+		else if (isNum2) return 1;
+		else {
+			if (id1 < id2) return -1;
+			if (id1 > id2) return 1;
+		}
+	}
+	return 0;
 }
-// helpers/version/compare.ts
+/**
+* Compares two semantic version strings according to SemVer 2.0.0 specification
+*
+* Supports:
+* - Core version: MAJOR.MINOR.PATCH
+* - Pre-release: -alpha, -beta.1, -rc.1, etc.
+* - Build metadata: +build, +sha.abc123 (ignored in comparison per spec)
+* - Optional 'v' prefix
+*
+* @param version1 - First version string
+* @param version2 - Second version string
+* @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+* @example
+* compare('1.0.0', '2.0.0') // -1
+* compare('1.0.0-alpha', '1.0.0') // -1 (prerelease < release)
+* compare('1.0.0-alpha', '1.0.0-beta') // -1
+* compare('1.0.0-alpha.1', '1.0.0-alpha.2') // -1
+* compare('1.0.0+build1', '1.0.0+build2') // 0 (build metadata ignored)
+*/
 function compare(version1, version2) {
-  const normalize = (v) => v.replace(/^v/, "");
-  const v1 = normalize(version1);
-  const v2 = normalize(version2);
-  const parts1 = v1.split(".").map(Number);
-  const parts2 = v2.split(".").map(Number);
-  const maxLength = Math.max(parts1.length, parts2.length);
-  for (let i = 0;i < maxLength; i++) {
-    const part1 = parts1[i] || 0;
-    const part2 = parts2[i] || 0;
-    if (part1 < part2)
-      return -1;
-    if (part1 > part2)
-      return 1;
-  }
-  return 0;
+	const v1 = parse(version1);
+	const v2 = parse(version2);
+	if (v1.major !== v2.major) return v1.major < v2.major ? -1 : 1;
+	if (v1.minor !== v2.minor) return v1.minor < v2.minor ? -1 : 1;
+	if (v1.patch !== v2.patch) return v1.patch < v2.patch ? -1 : 1;
+	return comparePrerelease(v1.prerelease, v2.prerelease);
+}
+//#endregion
+//#region helpers/version/increment.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Increments a semantic version
+* @param version - The version to increment
+* @param type - The increment type ('major', 'minor', 'patch')
+* @returns Incremented version string
+*/
+function increment(version, type) {
+	const normalize = (v) => v.replace(/^v/, "");
+	const hasV = version.startsWith("v");
+	const parts = normalize(version).split(".").map(Number);
+	while (parts.length < 3) parts.push(0);
+	let [major, minor, patch] = parts;
+	switch (type) {
+		case "major":
+			major++;
+			minor = 0;
+			patch = 0;
+			break;
+		case "minor":
+			minor++;
+			patch = 0;
+			break;
+		case "patch":
+			patch++;
+			break;
+		default: throw new Error(`Invalid increment type: ${type}`);
+	}
+	const result = `${major}.${minor}.${patch}`;
+	return hasV ? `v${result}` : result;
 }
-// helpers/version/satisfiesRange.ts
+//#endregion
+//#region helpers/version/satisfiesRange.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Checks if a version satisfies a range (simple implementation)
+* @param version - Version to check
+* @param range - Range pattern (e.g., ">=1.0.0", "~1.2.0", "^1.0.0")
+* @returns True if version satisfies the range
+*/
 function satisfiesRange(version, range) {
-  const normalize = (v) => v.replace(/^v/, "");
-  const normalizedVersion = normalize(version);
-  if (!range.match(/[~^<>=]/)) {
-    return normalizedVersion === normalize(range);
-  }
-  if (range.startsWith(">=")) {
-    const targetVersion = normalize(range.slice(2));
-    return compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
-  }
-  if (range.startsWith(">")) {
-    const targetVersion = normalize(range.slice(1));
-    return compareVersionsSimple(normalizedVersion, targetVersion) > 0;
-  }
-  if (range.startsWith("<=")) {
-    const targetVersion = normalize(range.slice(2));
-    return compareVersionsSimple(normalizedVersion, targetVersion) <= 0;
-  }
-  if (range.startsWith("<")) {
-    const targetVersion = normalize(range.slice(1));
-    return compareVersionsSimple(normalizedVersion, targetVersion) < 0;
-  }
-  if (range.startsWith("^")) {
-    const targetVersion = normalize(range.slice(1));
-    const [targetMajor] = targetVersion.split(".").map(Number);
-    const [versionMajor] = normalizedVersion.split(".").map(Number);
-    return versionMajor === targetMajor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
-  }
-  if (range.startsWith("~")) {
-    const targetVersion = normalize(range.slice(1));
-    const [targetMajor, targetMinor] = targetVersion.split(".").map(Number);
-    const [versionMajor, versionMinor] = normalizedVersion.split(".").map(Number);
-    return versionMajor === targetMajor && versionMinor === targetMinor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
-  }
-  return false;
+	const normalize = (v) => v.replace(/^v/, "");
+	const normalizedVersion = normalize(version);
+	if (!range.match(/[~^<>=]/)) return normalizedVersion === normalize(range);
+	if (range.startsWith(">=")) return compareVersionsSimple(normalizedVersion, normalize(range.slice(2))) >= 0;
+	if (range.startsWith(">")) return compareVersionsSimple(normalizedVersion, normalize(range.slice(1))) > 0;
+	if (range.startsWith("<=")) return compareVersionsSimple(normalizedVersion, normalize(range.slice(2))) <= 0;
+	if (range.startsWith("<")) return compareVersionsSimple(normalizedVersion, normalize(range.slice(1))) < 0;
+	if (range.startsWith("^")) {
+		const targetVersion = normalize(range.slice(1));
+		const [targetMajor] = targetVersion.split(".").map(Number);
+		const [versionMajor] = normalizedVersion.split(".").map(Number);
+		return versionMajor === targetMajor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
+	}
+	if (range.startsWith("~")) {
+		const targetVersion = normalize(range.slice(1));
+		const [targetMajor, targetMinor] = targetVersion.split(".").map(Number);
+		const [versionMajor, versionMinor] = normalizedVersion.split(".").map(Number);
+		return versionMajor === targetMajor && versionMinor === targetMinor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
+	} else return false;
 }
 function compareVersionsSimple(version1, version2) {
-  const parts1 = version1.split(".").map(Number);
-  const parts2 = version2.split(".").map(Number);
-  const maxLength = Math.max(parts1.length, parts2.length);
-  for (let i = 0;i < maxLength; i++) {
-    const part1 = parts1[i] || 0;
-    const part2 = parts2[i] || 0;
-    if (part1 < part2)
-      return -1;
-    if (part1 > part2)
-      return 1;
-  }
-  return 0;
+	const parts1 = version1.split(".").map(Number);
+	const parts2 = version2.split(".").map(Number);
+	const maxLength = Math.max(parts1.length, parts2.length);
+	for (let i = 0; i < maxLength; i++) {
+		const part1 = parts1[i] || 0;
+		const part2 = parts2[i] || 0;
+		if (part1 < part2) return -1;
+		if (part1 > part2) return 1;
+	}
+	return 0;
 }
-// helpers/version/increment.ts
-function increment(version, type) {
-  const normalize = (v) => v.replace(/^v/, "");
-  const hasV = version.startsWith("v");
-  const normalizedVersion = normalize(version);
-  const parts = normalizedVersion.split(".").map(Number);
-  while (parts.length < 3) {
-    parts.push(0);
-  }
-  let [major, minor, patch] = parts;
-  switch (type) {
-    case "major":
-      major++;
-      minor = 0;
-      patch = 0;
-      break;
-    case "minor":
-      minor++;
-      patch = 0;
-      break;
-    case "patch":
-      patch++;
-      break;
-    default:
-      throw new Error(`Invalid increment type: ${type}`);
-  }
-  const result = `${major}.${minor}.${patch}`;
-  return hasV ? `v${result}` : result;
+//#endregion
+//#region helpers/version/stripV.ts
+function stripV(version) {
+	return typeof version === "string" && version.startsWith("v") ? version.slice(1) : version;
 }
-export {
-  stripV,
-  satisfiesRange,
-  increment,
-  compare
-};
+//#endregion
+export { compare, increment, parse, satisfiesRange, stripV };
+
+//# sourceMappingURL=index.js.map