@helpers4/version 2.0.0-alpha.1 → 2.0.0-alpha.10

package/README.md

@@ -9,13 +9,14 @@ A set of helpers for working with URLs.
 
 ## Documentation
 
-[https://helpers4.js.org/version](https://helpers4.js.org/version)
+[https://helpers4.dev/typescript/categories/version/](https://helpers4.dev/typescript/categories/version/)
 
 <!-- AUTOMATIC-METHODS -->
 - compare
-- stripV
-- 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/lib/index.d.ts

@@ -1,4 +1,125 @@
-export * from './compare';
-export * from './stripV';
-export * from './satisfiesRange';
-export * from './increment';
+/**
+ * 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)
+ * @since 1.9.0
+ */
+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
+ * @since 1.9.0
+ */
+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
+ * @since 2.0.0
+ */
+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'] }
+ * @since 2.0.0
+ */
+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
+ * @since 1.9.0
+ */
+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"
+ * ```
+ * @since 1.9.0
+ */
+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,5 +1,199 @@
-// helpers/version/index.ts
-export * from "./compare";
-export * from "./stripV";
-export * from "./satisfiesRange";
-export * from "./increment";
+//#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'] }
+* @since 2.0.0
+*/
+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;
+}
+/**
+* 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)
+* @since 1.9.0
+*/
+function compare(version1, version2) {
+	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
+* @since 1.9.0
+*/
+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;
+}
+//#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
+* @since 1.9.0
+*/
+function satisfiesRange(version, range) {
+	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;
+}
+//#endregion
+//#region helpers/version/stripV.ts
+function stripV(version) {
+	return typeof version === "string" && version.startsWith("v") ? version.slice(1) : version;
+}
+//#endregion
+export { compare, increment, parse, satisfiesRange, stripV };
+
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/version/parse.ts","../../../helpers/version/compare.ts","../../../helpers/version/increment.ts","../../../helpers/version/satisfiesRange.ts","../../../helpers/version/stripV.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Represents a parsed semantic version according to SemVer 2.0.0 specification\n * @since 2.0.0\n */\nexport interface ParsedVersion {\n  /** Major version number */\n  major: number;\n  /** Minor version number */\n  minor: number;\n  /** Patch version number */\n  patch: number;\n  /** Pre-release identifiers (e.g., ['alpha', '1'] for -alpha.1) */\n  prerelease: string[];\n  /** Build metadata identifiers (e.g., ['build', '123'] for +build.123) */\n  build: string[];\n}\n\n/**\n * Parses a semantic version string into its components according to SemVer 2.0.0 specification\n *\n * Supports:\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)\n *\n * @param version - Version string to parse\n * @returns Parsed version object with major, minor, patch, prerelease, and build\n * @example\n * parse('1.2.3') // { major: 1, minor: 2, patch: 3, prerelease: [], build: [] }\n * parse('v1.0.0-alpha.1') // { major: 1, minor: 0, patch: 0, prerelease: ['alpha', '1'], build: [] }\n * parse('2.0.0+build.123') // { major: 2, minor: 0, patch: 0, prerelease: [], build: ['build', '123'] }\n * parse('1.0.0-beta+exp.sha.5114f85') // { major: 1, minor: 0, patch: 0, prerelease: ['beta'], build: ['exp', 'sha', '5114f85'] }\n * @since 2.0.0\n */\nexport function parse(version: string): ParsedVersion {\n  // Remove optional 'v' prefix\n  const normalized = version.replace(/^v/, '');\n\n  // Split build metadata first (everything after +)\n  const [versionWithPrerelease, buildString] = normalized.split('+');\n  const build = buildString ? buildString.split('.') : [];\n\n  // Split prerelease (everything after -)\n  const [coreVersion, prereleaseString] = versionWithPrerelease.split('-');\n  const prerelease = prereleaseString ? prereleaseString.split('.') : [];\n\n  // Parse core version\n  const parts = coreVersion.split('.').map(Number);\n\n  return {\n    major: parts[0] || 0,\n    minor: parts[1] || 0,\n    patch: parts[2] || 0,\n    prerelease,\n    build,\n  };\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { parse } from './parse';\n\n/**\n * Compares two prerelease identifier arrays according to SemVer spec\n * Rules:\n * - Numeric identifiers are compared as integers\n * - Alphanumeric identifiers are compared lexically (ASCII)\n * - Numeric identifiers have lower precedence than alphanumeric\n * - A larger set of prerelease fields has higher precedence if all preceding are equal\n * @param pre1 - First prerelease array\n * @param pre2 - Second prerelease array\n * @returns -1, 0, or 1\n */\nfunction comparePrerelease(pre1: string[], pre2: string[]): number {\n  // No prerelease has higher precedence than prerelease\n  // e.g., 1.0.0 > 1.0.0-alpha\n  if (pre1.length === 0 && pre2.length === 0) return 0;\n  if (pre1.length === 0) return 1; // No prerelease > prerelease\n  if (pre2.length === 0) return -1; // prerelease < no prerelease\n\n  const maxLength = Math.max(pre1.length, pre2.length);\n\n  for (let i = 0; i < maxLength; i++) {\n    // A larger set has higher precedence if all preceding are equal\n    if (i >= pre1.length) return -1;\n    if (i >= pre2.length) return 1;\n\n    const id1 = pre1[i];\n    const id2 = pre2[i];\n\n    const isNum1 = /^\\d+$/.test(id1);\n    const isNum2 = /^\\d+$/.test(id2);\n\n    // Both numeric: compare as integers\n    if (isNum1 && isNum2) {\n      const num1 = parseInt(id1, 10);\n      const num2 = parseInt(id2, 10);\n      if (num1 < num2) return -1;\n      if (num1 > num2) return 1;\n      // num1 === num2, continue to next identifier\n    }\n    // Numeric has lower precedence than alphanumeric\n    else if (isNum1) {\n      return -1;\n    } else if (isNum2) {\n      return 1;\n    }\n    // Both alphanumeric: compare lexically (ASCII sort)\n    else {\n      if (id1 < id2) return -1;\n      if (id1 > id2) return 1;\n      // id1 === id2, continue to next identifier\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Compares two semantic version strings according to SemVer 2.0.0 specification\n *\n * Supports:\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\n *\n * @param version1 - First version string\n * @param version2 - Second version string\n * @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2\n * @example\n * compare('1.0.0', '2.0.0') // -1\n * compare('1.0.0-alpha', '1.0.0') // -1 (prerelease < release)\n * compare('1.0.0-alpha', '1.0.0-beta') // -1\n * compare('1.0.0-alpha.1', '1.0.0-alpha.2') // -1\n * compare('1.0.0+build1', '1.0.0+build2') // 0 (build metadata ignored)\n * @since 1.9.0\n */\nexport function compare(version1: string, version2: string): number {\n  const v1 = parse(version1);\n  const v2 = parse(version2);\n\n  // Compare major, minor, patch\n  if (v1.major !== v2.major) return v1.major < v2.major ? -1 : 1;\n  if (v1.minor !== v2.minor) return v1.minor < v2.minor ? -1 : 1;\n  if (v1.patch !== v2.patch) return v1.patch < v2.patch ? -1 : 1;\n\n  // Compare prerelease (build metadata is ignored per SemVer spec)\n  return comparePrerelease(v1.prerelease, v2.prerelease);\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Increments a semantic version\n * @param version - The version to increment\n * @param type - The increment type ('major', 'minor', 'patch')\n * @returns Incremented version string\n * @since 1.9.0\n */\nexport function increment(\n  version: string,\n  type: 'major' | 'minor' | 'patch'\n): string {\n  const normalize = (v: string) => v.replace(/^v/, '');\n  const hasV = version.startsWith('v');\n  const normalizedVersion = normalize(version);\n\n  const parts = normalizedVersion.split('.').map(Number);\n\n  // Ensure we have at least major.minor.patch\n  while (parts.length < 3) {\n    parts.push(0);\n  }\n\n  let [major, minor, patch] = parts;\n\n  switch (type) {\n    case 'major':\n      major++;\n      minor = 0;\n      patch = 0;\n      break;\n    case 'minor':\n      minor++;\n      patch = 0;\n      break;\n    case 'patch':\n      patch++;\n      break;\n    default:\n      throw new Error(`Invalid increment type: ${type}`);\n  }\n\n  const result = `${major}.${minor}.${patch}`;\n  return hasV ? `v${result}` : result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a version satisfies a range (simple implementation)\n * @param version - Version to check\n * @param range - Range pattern (e.g., \">=1.0.0\", \"~1.2.0\", \"^1.0.0\")\n * @returns True if version satisfies the range\n * @since 1.9.0\n */\nexport function satisfiesRange(version: string, range: string): boolean {\n  const normalize = (v: string) => v.replace(/^v/, '');\n  const normalizedVersion = normalize(version);\n\n  // Handle exact match\n  if (!range.match(/[~^<>=]/)) {\n    return normalizedVersion === normalize(range);\n  }\n\n  // Handle >= operator\n  if (range.startsWith('>=')) {\n    const targetVersion = normalize(range.slice(2));\n    return compareVersionsSimple(normalizedVersion, targetVersion) >= 0;\n  }\n\n  // Handle > operator\n  if (range.startsWith('>')) {\n    const targetVersion = normalize(range.slice(1));\n    return compareVersionsSimple(normalizedVersion, targetVersion) > 0;\n  }\n\n  // Handle <= operator\n  if (range.startsWith('<=')) {\n    const targetVersion = normalize(range.slice(2));\n    return compareVersionsSimple(normalizedVersion, targetVersion) <= 0;\n  }\n\n  // Handle < operator\n  if (range.startsWith('<')) {\n    const targetVersion = normalize(range.slice(1));\n    return compareVersionsSimple(normalizedVersion, targetVersion) < 0;\n  }\n\n  // Handle caret range (^1.2.3 allows patch and minor updates)\n  if (range.startsWith('^')) {\n    const targetVersion = normalize(range.slice(1));\n    const [targetMajor] = targetVersion.split('.').map(Number);\n    const [versionMajor] = normalizedVersion.split('.').map(Number);\n\n    return versionMajor === targetMajor &&\n      compareVersionsSimple(normalizedVersion, targetVersion) >= 0;\n  }\n\n  // Handle tilde range (~1.2.3 allows patch updates)\n  if (range.startsWith('~')) {\n    const targetVersion = normalize(range.slice(1));\n    const [targetMajor, targetMinor] = targetVersion.split('.').map(Number);\n    const [versionMajor, versionMinor] = normalizedVersion.split('.').map(Number);\n\n    return versionMajor === targetMajor &&\n      versionMinor === targetMinor &&\n      compareVersionsSimple(normalizedVersion, targetVersion) >= 0;\n  } else {\n    // Unsupported range format\n    return false;\n  }\n}\n\nfunction compareVersionsSimple(version1: string, version2: string): number {\n  const parts1 = version1.split('.').map(Number);\n  const parts2 = version2.split('.').map(Number);\n\n  const maxLength = Math.max(parts1.length, parts2.length);\n\n  for (let i = 0; i < maxLength; i++) {\n    const part1 = parts1[i] || 0;\n    const part2 = parts2[i] || 0;\n\n    if (part1 < part2) return -1;\n    if (part1 > part2) return 1;\n  }\n\n  return 0;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Strip the leading \"v\" from a version string if it exists.\n * \n * @param version - The version string to process\n * @returns The version string without leading \"v\", or the original value if it's not a string or doesn't start with \"v\"\n * \n * @example\n * ```typescript\n * stripV(\"v1.2.3\")     // \"1.2.3\"\n * stripV(\"1.2.3\")      // \"1.2.3\"\n * stripV(\"v20.1.0\")    // \"20.1.0\"\n * stripV(null)         // null\n * stripV(undefined)    // undefined\n * stripV(\"\")           // \"\"\n * stripV(\"1.0.0-beta\") // \"1.0.0-beta\"\n * ```\n * @since 1.9.0\n */\nexport function stripV(version: string): string;\nexport function stripV(version: null): null;\nexport function stripV(version: undefined): undefined;\nexport function stripV(version: string | null | undefined): string | null | undefined {\n  return typeof version === \"string\" && version.startsWith(\"v\") ? version.slice(1) : version;\n}\n"],"mappings":"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"}

package/meta/api.json

@@ -0,0 +1,250 @@
+{
+  "category": "version",
+  "version": "2.0.0-alpha.10",
+  "functions": [
+    {
+      "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",
+      "since": "1.9.0",
+      "signatures": [
+        {
+          "signature": "compare(version1: string, version2: string): number",
+          "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",
+          "params": [
+            {
+              "name": "version1",
+              "type": "string",
+              "description": "First version string"
+            },
+            {
+              "name": "version2",
+              "type": "string",
+              "description": "Second version string"
+            }
+          ],
+          "returns": {
+            "type": "number",
+            "description": "-1 if version1 < version2, 0 if equal, 1 if version1 > version2"
+          }
+        }
+      ],
+      "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"
+        }
+      ],
+      "sourceFile": "compare.ts"
+    },
+    {
+      "name": "increment",
+      "kind": "function",
+      "description": "Increments a semantic version",
+      "since": "1.9.0",
+      "signatures": [
+        {
+          "signature": "increment(version: string, type: \"major\" | \"minor\" | \"patch\"): string",
+          "description": "Increments a semantic version",
+          "params": [
+            {
+              "name": "version",
+              "type": "string",
+              "description": "The version to increment"
+            },
+            {
+              "name": "type",
+              "type": "\"major\" | \"minor\" | \"patch\"",
+              "description": "The increment type ('major', 'minor', 'patch')"
+            }
+          ],
+          "returns": {
+            "type": "string",
+            "description": "Incremented version string"
+          }
+        }
+      ],
+      "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'"
+        }
+      ],
+      "sourceFile": "increment.ts"
+    },
+    {
+      "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)",
+      "since": "2.0.0",
+      "signatures": [
+        {
+          "signature": "parse(version: string): ParsedVersion",
+          "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)",
+          "params": [
+            {
+              "name": "version",
+              "type": "string",
+              "description": "Version string to parse"
+            }
+          ],
+          "returns": {
+            "type": "ParsedVersion",
+            "description": "Parsed version object with major, minor, patch, prerelease, and build"
+          }
+        }
+      ],
+      "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: [] }"
+        }
+      ],
+      "sourceFile": "parse.ts"
+    },
+    {
+      "name": "ParsedVersion",
+      "kind": "interface",
+      "description": "Represents a parsed semantic version according to SemVer 2.0.0 specification",
+      "since": "2.0.0",
+      "signatures": [],
+      "examples": [],
+      "sourceFile": "parse.ts"
+    },
+    {
+      "name": "satisfiesRange",
+      "kind": "function",
+      "description": "Checks if a version satisfies a range (simple implementation)",
+      "since": "1.9.0",
+      "signatures": [
+        {
+          "signature": "satisfiesRange(version: string, range: string): boolean",
+          "description": "Checks if a version satisfies a range (simple implementation)",
+          "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": {
+            "type": "boolean",
+            "description": "True if version satisfies the range"
+          }
+        }
+      ],
+      "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"
+        }
+      ],
+      "sourceFile": "satisfiesRange.ts"
+    },
+    {
+      "name": "stripV",
+      "kind": "function",
+      "description": "Strip the leading \"v\" from a version string if it exists.",
+      "since": "1.9.0",
+      "signatures": [
+        {
+          "signature": "stripV(version: string): string",
+          "description": "Strip the leading \"v\" from a version string if it exists.",
+          "params": [
+            {
+              "name": "version",
+              "type": "string",
+              "description": "The version string to process"
+            }
+          ],
+          "returns": {
+            "type": "string",
+            "description": "The version string without leading \"v\", or the original value if it's not a string or doesn't start with \"v\""
+          }
+        },
+        {
+          "signature": "stripV(version: null): null",
+          "description": "Strip the leading \"v\" from a version string if it exists.",
+          "params": [
+            {
+              "name": "version",
+              "type": "null",
+              "description": "The version string to process"
+            }
+          ],
+          "returns": {
+            "type": "null",
+            "description": "The version string without leading \"v\", or the original value if it's not a string or doesn't start with \"v\""
+          }
+        },
+        {
+          "signature": "stripV(version: undefined): undefined",
+          "description": "Strip the leading \"v\" from a version string if it exists.",
+          "params": [
+            {
+              "name": "version",
+              "type": "undefined",
+              "description": "The version string to process"
+            }
+          ],
+          "returns": {
+            "type": "undefined",
+            "description": "The version string without leading \"v\", or the original value if it's not a string or doesn't start with \"v\""
+          }
+        }
+      ],
+      "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'"
+        }
+      ],
+      "sourceFile": "stripV.ts"
+    }
+  ]
+}