@guanghechen/version 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+<header>
+  <h1 align="center">
+    <a href="https://github.com/guanghechen/sora/tree/@guanghechen/version@1.0.0/packages/version#readme">@guanghechen/version</a>
+  </h1>
+  <div align="center">
+    <a href="https://www.npmjs.com/package/@guanghechen/version">
+      <img
+        alt="Npm Version"
+        src="https://img.shields.io/npm/v/@guanghechen/version.svg"
+      />
+    </a>
+    <a href="https://www.npmjs.com/package/@guanghechen/version">
+      <img
+        alt="Npm Download"
+        src="https://img.shields.io/npm/dm/@guanghechen/version.svg"
+      />
+    </a>
+    <a href="https://www.npmjs.com/package/@guanghechen/version">
+      <img
+        alt="Npm License"
+        src="https://img.shields.io/npm/l/@guanghechen/version.svg"
+      />
+    </a>
+    <a href="#install">
+      <img
+        alt="Module Formats: cjs, esm"
+        src="https://img.shields.io/badge/module_formats-cjs%2C%20esm-green.svg"
+      />
+    </a>
+    <a href="https://github.com/nodejs/node">
+      <img
+        alt="Node.js Version"
+        src="https://img.shields.io/node/v/@guanghechen/version"
+      />
+    </a>
+    <a href="https://github.com/facebook/jest">
+      <img
+        alt="Tested with Jest"
+        src="https://img.shields.io/badge/tested_with-jest-9c465e.svg"
+      />
+    </a>
+    <a href="https://github.com/prettier/prettier">
+      <img
+        alt="Code Style: prettier"
+        src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square"
+      />
+    </a>
+  </div>
+</header>
+<br/>
+
+Lightweight semver version comparison utilities.
+
+## Install
+
+- npm
+
+  ```bash
+  npm install --save @guanghechen/version
+  ```
+
+- yarn
+
+  ```bash
+  yarn add @guanghechen/version
+  ```
+
+## Usage
+
+### Parse and Compare Versions
+
+```typescript
+import { parseVersion, compareVersions, compareSemVer } from '@guanghechen/version'
+
+// Parse a version string
+const v = parseVersion('1.2.3-alpha.1')
+// => { major: 1, minor: 2, patch: 3, prerelease: ['alpha', 1] }
+
+// Compare version strings
+compareVersions('1.2.3', '1.2.4')  // => -1
+compareVersions('2.0.0', '1.9.9')  // => 1
+compareVersions('1.0.0', '1.0.0')  // => 0
+
+// Compare parsed versions
+compareSemVer(
+  { major: 1, minor: 0, patch: 0, prerelease: [] },
+  { major: 2, minor: 0, patch: 0, prerelease: [] }
+)  // => -1
+```
+
+### Check Version Ranges
+
+```typescript
+import { satisfies } from '@guanghechen/version'
+
+// Exact version
+satisfies('1.2.3', '1.2.3')  // => true
+
+// Caret ranges (^)
+satisfies('1.2.3', '^1.0.0')  // => true
+satisfies('2.0.0', '^1.0.0')  // => false
+
+// Tilde ranges (~)
+satisfies('1.2.5', '~1.2.0')  // => true
+satisfies('1.3.0', '~1.2.0')  // => false
+
+// Comparison operators
+satisfies('1.5.0', '>=1.0.0')  // => true
+satisfies('1.5.0', '<2.0.0')   // => true
+satisfies('1.5.0', '>1.0.0 <2.0.0')  // => true
+
+// X-ranges
+satisfies('1.2.3', '1.x')    // => true
+satisfies('1.2.3', '1.2.x')  // => true
+
+// Hyphen ranges
+satisfies('1.5.0', '1.0.0 - 2.0.0')  // => true
+
+// OR ranges
+satisfies('3.0.0', '^1.0.0 || ^2.0.0 || ^3.0.0')  // => true
+
+// Prerelease versions (includePrerelease defaults to true)
+satisfies('1.0.0-alpha', '^1.0.0')  // => true
+
+// Strict mode (node-semver compatible)
+satisfies('1.0.0-alpha', '^1.0.0', { includePrerelease: false })  // => false
+```
+
+## API
+
+### Types
+
+```typescript
+interface ISemVer {
+  major: number
+  minor: number
+  patch: number
+  prerelease: ReadonlyArray<string | number>
+}
+
+interface IPartialSemVer {
+  major: number
+  minor: number | undefined
+  patch: number | undefined
+  prerelease: ReadonlyArray<string | number>
+  isWildcard?: boolean
+}
+
+interface ISatisfiesOptions {
+  includePrerelease?: boolean  // default: true
+}
+```
+
+### Functions
+
+| Function                                              | Description                                    |
+| ----------------------------------------------------- | ---------------------------------------------- |
+| `parseVersion(version: string)`                       | Parse a full semver string to `ISemVer`        |
+| `parsePartialVersion(version: string)`                | Parse a partial version to `IPartialSemVer`    |
+| `compareVersions(v1: string, v2: string)`             | Compare two version strings (-1, 0, 1)         |
+| `compareSemVer(v1: ISemVer, v2: ISemVer)`             | Compare two parsed versions (-1, 0, 1)         |
+| `satisfies(version: string, range: string, options?)` | Check if version satisfies the range           |
+| `formatVersion(v: ISemVer)`                           | Format a parsed version back to string         |
+| `isFullVersion(v: IPartialSemVer)`                    | Check if partial version is a full version     |
+| `toFullVersion(v: IPartialSemVer)`                    | Convert partial version to full (fill with 0s) |
+
+[homepage]:
+  https://github.com/guanghechen/sora/tree/@guanghechen/version@1.0.0/packages/version#readme

package/lib/cjs/index.cjs

@@ -0,0 +1,322 @@
+'use strict';
+
+const SEMVER_REGEX = /^[v=]?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const PARTIAL_SEMVER_REGEX = /^[v=]?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function isWildcardChar(s) {
+    return s === '*' || s === 'x' || s === 'X';
+}
+function parsePrerelease(prereleaseStr) {
+    if (!prereleaseStr)
+        return [];
+    return prereleaseStr.split('.').map(part => {
+        const num = parseInt(part, 10);
+        return String(num) === part ? num : part;
+    });
+}
+function parseVersion(version) {
+    const match = SEMVER_REGEX.exec(version);
+    if (!match)
+        return undefined;
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        prerelease: parsePrerelease(match[4]),
+    };
+}
+function parsePartialVersion(version) {
+    const trimmed = version.trim();
+    if (trimmed === '' || isWildcardChar(trimmed)) {
+        return { major: 0, minor: undefined, patch: undefined, prerelease: [], isWildcard: true };
+    }
+    const match = PARTIAL_SEMVER_REGEX.exec(trimmed);
+    if (!match)
+        return undefined;
+    const minorStr = match[2];
+    const patchStr = match[3];
+    return {
+        major: parseInt(match[1], 10),
+        minor: minorStr === undefined || isWildcardChar(minorStr) ? undefined : parseInt(minorStr, 10),
+        patch: patchStr === undefined || isWildcardChar(patchStr) ? undefined : parseInt(patchStr, 10),
+        prerelease: parsePrerelease(match[4]),
+    };
+}
+function isFullVersion(v) {
+    return v.minor !== undefined && v.patch !== undefined;
+}
+function toFullVersion(v) {
+    return {
+        major: v.major,
+        minor: v.minor ?? 0,
+        patch: v.patch ?? 0,
+        prerelease: v.prerelease,
+    };
+}
+function formatVersion(v) {
+    const base = `${v.major}.${v.minor}.${v.patch}`;
+    return v.prerelease.length === 0 ? base : `${base}-${v.prerelease.join('.')}`;
+}
+
+function comparePrerelease(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (i >= a.length)
+            return -1;
+        if (i >= b.length)
+            return 1;
+        const aVal = a[i];
+        const bVal = b[i];
+        if (aVal === bVal)
+            continue;
+        const aIsNum = typeof aVal === 'number';
+        const bIsNum = typeof bVal === 'number';
+        if (aIsNum !== bIsNum)
+            return aIsNum ? -1 : 1;
+        return aVal < bVal ? -1 : 1;
+    }
+    return 0;
+}
+function compareSemVer(v1, v2) {
+    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);
+}
+function compareVersions(v1, v2) {
+    const parsed1 = parseVersion(v1);
+    const parsed2 = parseVersion(v2);
+    if (!parsed1 || !parsed2) {
+        throw new Error(`Invalid version: ${!parsed1 ? v1 : v2}`);
+    }
+    return compareSemVer(parsed1, parsed2);
+}
+
+const HYPHEN_RANGE_REGEX = /^\s*(\S+)\s+-\s+(\S+)\s*$/;
+const COMPARATOR_REGEX = /^(>=|>|<=|<|=|\^|~)?(.*)$/;
+function createComparator(target, op) {
+    return (v) => {
+        const cmp = compareSemVer(v, target);
+        if (op === 'gt')
+            return cmp > 0;
+        if (op === 'gte')
+            return cmp >= 0;
+        if (op === 'lt')
+            return cmp < 0;
+        if (op === 'lte')
+            return cmp <= 0;
+        return cmp === 0;
+    };
+}
+function createAndComparator(comparators) {
+    return (v) => comparators.every(c => c(v));
+}
+function createSemVer(major, minor, patch, prerelease = []) {
+    return { major, minor, patch, prerelease: [...prerelease] };
+}
+function withResult(comparator, prereleaseVersions) {
+    return { comparator, prereleaseVersions };
+}
+function hasSameBaseVersion(v1, v2) {
+    return v1.major === v2.major && v1.minor === v2.minor && v1.patch === v2.patch;
+}
+function parseHyphenRange(range) {
+    const match = HYPHEN_RANGE_REGEX.exec(range);
+    if (!match)
+        return undefined;
+    const start = parsePartialVersion(match[1]);
+    const end = parsePartialVersion(match[2]);
+    if (!start || !end)
+        return undefined;
+    const startFull = toFullVersion(start);
+    const comparators = [createComparator(startFull, 'gte')];
+    const prereleaseVersions = [];
+    if (start.prerelease.length > 0)
+        prereleaseVersions.push(startFull);
+    if (isFullVersion(end)) {
+        comparators.push(createComparator(end, 'lte'));
+        if (end.prerelease.length > 0)
+            prereleaseVersions.push(end);
+    }
+    else {
+        const endMax = end.minor === undefined
+            ? createSemVer(end.major + 1, 0, 0, [0])
+            : createSemVer(end.major, end.minor + 1, 0, [0]);
+        comparators.push(createComparator(endMax, 'lt'));
+    }
+    return [withResult(createAndComparator(comparators), prereleaseVersions)];
+}
+function parseXRange(partial) {
+    if (partial.minor === undefined) {
+        if (partial.isWildcard)
+            return withResult(() => true, []);
+        const min = createSemVer(partial.major, 0, 0, partial.prerelease);
+        const max = createSemVer(partial.major + 1, 0, 0, [0]);
+        return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), partial.prerelease.length > 0 ? [min] : []);
+    }
+    const min = createSemVer(partial.major, partial.minor, 0, partial.prerelease);
+    const max = createSemVer(partial.major, partial.minor + 1, 0, [0]);
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), partial.prerelease.length > 0 ? [min] : []);
+}
+function parseCaretRange(partial) {
+    const min = toFullVersion(partial);
+    const hasPrerelease = partial.prerelease.length > 0;
+    let max;
+    if (partial.minor === undefined) {
+        max = createSemVer(min.major + 1, 0, 0, [0]);
+    }
+    else if (partial.patch === undefined) {
+        if (min.major === 0 && min.minor === 0) {
+            max = createSemVer(0, 1, 0, [0]);
+        }
+        else if (min.major === 0) {
+            max = createSemVer(0, min.minor + 1, 0, [0]);
+        }
+        else {
+            max = createSemVer(min.major + 1, 0, 0, [0]);
+        }
+    }
+    else if (min.major > 0) {
+        max = createSemVer(min.major + 1, 0, 0, [0]);
+    }
+    else if (min.minor > 0) {
+        max = createSemVer(0, min.minor + 1, 0, [0]);
+    }
+    else {
+        max = createSemVer(0, 0, min.patch + 1, [0]);
+    }
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), hasPrerelease ? [min] : []);
+}
+function parseTildeRange(partial) {
+    const min = toFullVersion(partial);
+    const hasPrerelease = partial.prerelease.length > 0;
+    const max = partial.minor === undefined
+        ? createSemVer(min.major + 1, 0, 0, [0])
+        : createSemVer(min.major, min.minor + 1, 0, [0]);
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), hasPrerelease ? [min] : []);
+}
+function parseComparatorWithOperator(operator, partial) {
+    const hasPrerelease = partial.prerelease.length > 0;
+    switch (operator) {
+        case '':
+        case '=': {
+            if (!isFullVersion(partial))
+                return parseXRange(partial);
+            return withResult(createComparator(partial, 'eq'), hasPrerelease ? [partial] : []);
+        }
+        case '>': {
+            if (!isFullVersion(partial)) {
+                const target = partial.minor === undefined
+                    ? createSemVer(partial.major + 1, 0, 0)
+                    : createSemVer(partial.major, partial.minor + 1, 0);
+                return withResult(createComparator(target, 'gte'), hasPrerelease ? [toFullVersion(partial)] : []);
+            }
+            return withResult(createComparator(partial, 'gt'), hasPrerelease ? [partial] : []);
+        }
+        case '>=': {
+            const full = toFullVersion(partial);
+            return withResult(createComparator(full, 'gte'), hasPrerelease ? [full] : []);
+        }
+        case '<': {
+            if (!isFullVersion(partial)) {
+                const target = toFullVersion(partial);
+                const targetWithPrerelease = createSemVer(target.major, target.minor, target.patch, [0]);
+                return withResult(createComparator(targetWithPrerelease, 'lt'), hasPrerelease ? [target] : []);
+            }
+            return withResult(createComparator(partial, 'lt'), hasPrerelease ? [partial] : []);
+        }
+        case '<=': {
+            if (!isFullVersion(partial)) {
+                const target = partial.minor === undefined
+                    ? createSemVer(partial.major + 1, 0, 0, [0])
+                    : createSemVer(partial.major, partial.minor + 1, 0, [0]);
+                return withResult(createComparator(target, 'lt'), hasPrerelease ? [toFullVersion(partial)] : []);
+            }
+            return withResult(createComparator(partial, 'lte'), hasPrerelease ? [partial] : []);
+        }
+        case '^':
+            return parseCaretRange(partial);
+        case '~':
+            return parseTildeRange(partial);
+    }
+}
+const OPERATORS = ['>=', '>', '<=', '<', '=', '^', '~', ''];
+function isOperator(s) {
+    return OPERATORS.includes(s);
+}
+function parseSingleComparator(comp) {
+    const trimmed = comp.trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'X') {
+        return withResult(() => true, []);
+    }
+    const match = COMPARATOR_REGEX.exec(trimmed);
+    if (!match)
+        return undefined;
+    const operator = match[1] || '';
+    const versionStr = match[2];
+    if (!versionStr) {
+        return operator === '' ? withResult(() => true, []) : undefined;
+    }
+    const partial = parsePartialVersion(versionStr);
+    if (!partial || !isOperator(operator))
+        return undefined;
+    return parseComparatorWithOperator(operator, partial);
+}
+function parseComparatorSet(set) {
+    const hyphenResult = parseHyphenRange(set);
+    if (hyphenResult)
+        return hyphenResult;
+    const parts = set.trim().split(/\s+/);
+    const results = [];
+    for (const part of parts) {
+        if (part === '')
+            continue;
+        const parsed = parseSingleComparator(part);
+        if (!parsed)
+            return undefined;
+        results.push(parsed);
+    }
+    return results.length === 0 ? [withResult(() => true, [])] : results;
+}
+function checkPrereleaseAllowed(version, prereleaseVersions) {
+    if (version.prerelease.length === 0)
+        return true;
+    return prereleaseVersions.some(pv => hasSameBaseVersion(version, pv));
+}
+function satisfies(version, range, options) {
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return false;
+    const includePrerelease = options?.includePrerelease ?? true;
+    for (const orPart of range.split('||')) {
+        const comparatorSet = parseComparatorSet(orPart);
+        if (!comparatorSet)
+            continue;
+        const allMatch = comparatorSet.every(c => c.comparator(parsed));
+        if (!allMatch)
+            continue;
+        if (includePrerelease)
+            return true;
+        const prereleaseVersions = comparatorSet.flatMap(c => c.prereleaseVersions);
+        if (checkPrereleaseAllowed(parsed, prereleaseVersions))
+            return true;
+    }
+    return false;
+}
+
+exports.compareSemVer = compareSemVer;
+exports.compareVersions = compareVersions;
+exports.formatVersion = formatVersion;
+exports.isFullVersion = isFullVersion;
+exports.parsePartialVersion = parsePartialVersion;
+exports.parseVersion = parseVersion;
+exports.satisfies = satisfies;
+exports.toFullVersion = toFullVersion;

package/lib/esm/index.mjs

@@ -0,0 +1,313 @@
+const SEMVER_REGEX = /^[v=]?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const PARTIAL_SEMVER_REGEX = /^[v=]?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function isWildcardChar(s) {
+    return s === '*' || s === 'x' || s === 'X';
+}
+function parsePrerelease(prereleaseStr) {
+    if (!prereleaseStr)
+        return [];
+    return prereleaseStr.split('.').map(part => {
+        const num = parseInt(part, 10);
+        return String(num) === part ? num : part;
+    });
+}
+function parseVersion(version) {
+    const match = SEMVER_REGEX.exec(version);
+    if (!match)
+        return undefined;
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        prerelease: parsePrerelease(match[4]),
+    };
+}
+function parsePartialVersion(version) {
+    const trimmed = version.trim();
+    if (trimmed === '' || isWildcardChar(trimmed)) {
+        return { major: 0, minor: undefined, patch: undefined, prerelease: [], isWildcard: true };
+    }
+    const match = PARTIAL_SEMVER_REGEX.exec(trimmed);
+    if (!match)
+        return undefined;
+    const minorStr = match[2];
+    const patchStr = match[3];
+    return {
+        major: parseInt(match[1], 10),
+        minor: minorStr === undefined || isWildcardChar(minorStr) ? undefined : parseInt(minorStr, 10),
+        patch: patchStr === undefined || isWildcardChar(patchStr) ? undefined : parseInt(patchStr, 10),
+        prerelease: parsePrerelease(match[4]),
+    };
+}
+function isFullVersion(v) {
+    return v.minor !== undefined && v.patch !== undefined;
+}
+function toFullVersion(v) {
+    return {
+        major: v.major,
+        minor: v.minor ?? 0,
+        patch: v.patch ?? 0,
+        prerelease: v.prerelease,
+    };
+}
+function formatVersion(v) {
+    const base = `${v.major}.${v.minor}.${v.patch}`;
+    return v.prerelease.length === 0 ? base : `${base}-${v.prerelease.join('.')}`;
+}
+
+function comparePrerelease(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (i >= a.length)
+            return -1;
+        if (i >= b.length)
+            return 1;
+        const aVal = a[i];
+        const bVal = b[i];
+        if (aVal === bVal)
+            continue;
+        const aIsNum = typeof aVal === 'number';
+        const bIsNum = typeof bVal === 'number';
+        if (aIsNum !== bIsNum)
+            return aIsNum ? -1 : 1;
+        return aVal < bVal ? -1 : 1;
+    }
+    return 0;
+}
+function compareSemVer(v1, v2) {
+    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);
+}
+function compareVersions(v1, v2) {
+    const parsed1 = parseVersion(v1);
+    const parsed2 = parseVersion(v2);
+    if (!parsed1 || !parsed2) {
+        throw new Error(`Invalid version: ${!parsed1 ? v1 : v2}`);
+    }
+    return compareSemVer(parsed1, parsed2);
+}
+
+const HYPHEN_RANGE_REGEX = /^\s*(\S+)\s+-\s+(\S+)\s*$/;
+const COMPARATOR_REGEX = /^(>=|>|<=|<|=|\^|~)?(.*)$/;
+function createComparator(target, op) {
+    return (v) => {
+        const cmp = compareSemVer(v, target);
+        if (op === 'gt')
+            return cmp > 0;
+        if (op === 'gte')
+            return cmp >= 0;
+        if (op === 'lt')
+            return cmp < 0;
+        if (op === 'lte')
+            return cmp <= 0;
+        return cmp === 0;
+    };
+}
+function createAndComparator(comparators) {
+    return (v) => comparators.every(c => c(v));
+}
+function createSemVer(major, minor, patch, prerelease = []) {
+    return { major, minor, patch, prerelease: [...prerelease] };
+}
+function withResult(comparator, prereleaseVersions) {
+    return { comparator, prereleaseVersions };
+}
+function hasSameBaseVersion(v1, v2) {
+    return v1.major === v2.major && v1.minor === v2.minor && v1.patch === v2.patch;
+}
+function parseHyphenRange(range) {
+    const match = HYPHEN_RANGE_REGEX.exec(range);
+    if (!match)
+        return undefined;
+    const start = parsePartialVersion(match[1]);
+    const end = parsePartialVersion(match[2]);
+    if (!start || !end)
+        return undefined;
+    const startFull = toFullVersion(start);
+    const comparators = [createComparator(startFull, 'gte')];
+    const prereleaseVersions = [];
+    if (start.prerelease.length > 0)
+        prereleaseVersions.push(startFull);
+    if (isFullVersion(end)) {
+        comparators.push(createComparator(end, 'lte'));
+        if (end.prerelease.length > 0)
+            prereleaseVersions.push(end);
+    }
+    else {
+        const endMax = end.minor === undefined
+            ? createSemVer(end.major + 1, 0, 0, [0])
+            : createSemVer(end.major, end.minor + 1, 0, [0]);
+        comparators.push(createComparator(endMax, 'lt'));
+    }
+    return [withResult(createAndComparator(comparators), prereleaseVersions)];
+}
+function parseXRange(partial) {
+    if (partial.minor === undefined) {
+        if (partial.isWildcard)
+            return withResult(() => true, []);
+        const min = createSemVer(partial.major, 0, 0, partial.prerelease);
+        const max = createSemVer(partial.major + 1, 0, 0, [0]);
+        return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), partial.prerelease.length > 0 ? [min] : []);
+    }
+    const min = createSemVer(partial.major, partial.minor, 0, partial.prerelease);
+    const max = createSemVer(partial.major, partial.minor + 1, 0, [0]);
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), partial.prerelease.length > 0 ? [min] : []);
+}
+function parseCaretRange(partial) {
+    const min = toFullVersion(partial);
+    const hasPrerelease = partial.prerelease.length > 0;
+    let max;
+    if (partial.minor === undefined) {
+        max = createSemVer(min.major + 1, 0, 0, [0]);
+    }
+    else if (partial.patch === undefined) {
+        if (min.major === 0 && min.minor === 0) {
+            max = createSemVer(0, 1, 0, [0]);
+        }
+        else if (min.major === 0) {
+            max = createSemVer(0, min.minor + 1, 0, [0]);
+        }
+        else {
+            max = createSemVer(min.major + 1, 0, 0, [0]);
+        }
+    }
+    else if (min.major > 0) {
+        max = createSemVer(min.major + 1, 0, 0, [0]);
+    }
+    else if (min.minor > 0) {
+        max = createSemVer(0, min.minor + 1, 0, [0]);
+    }
+    else {
+        max = createSemVer(0, 0, min.patch + 1, [0]);
+    }
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), hasPrerelease ? [min] : []);
+}
+function parseTildeRange(partial) {
+    const min = toFullVersion(partial);
+    const hasPrerelease = partial.prerelease.length > 0;
+    const max = partial.minor === undefined
+        ? createSemVer(min.major + 1, 0, 0, [0])
+        : createSemVer(min.major, min.minor + 1, 0, [0]);
+    return withResult(createAndComparator([createComparator(min, 'gte'), createComparator(max, 'lt')]), hasPrerelease ? [min] : []);
+}
+function parseComparatorWithOperator(operator, partial) {
+    const hasPrerelease = partial.prerelease.length > 0;
+    switch (operator) {
+        case '':
+        case '=': {
+            if (!isFullVersion(partial))
+                return parseXRange(partial);
+            return withResult(createComparator(partial, 'eq'), hasPrerelease ? [partial] : []);
+        }
+        case '>': {
+            if (!isFullVersion(partial)) {
+                const target = partial.minor === undefined
+                    ? createSemVer(partial.major + 1, 0, 0)
+                    : createSemVer(partial.major, partial.minor + 1, 0);
+                return withResult(createComparator(target, 'gte'), hasPrerelease ? [toFullVersion(partial)] : []);
+            }
+            return withResult(createComparator(partial, 'gt'), hasPrerelease ? [partial] : []);
+        }
+        case '>=': {
+            const full = toFullVersion(partial);
+            return withResult(createComparator(full, 'gte'), hasPrerelease ? [full] : []);
+        }
+        case '<': {
+            if (!isFullVersion(partial)) {
+                const target = toFullVersion(partial);
+                const targetWithPrerelease = createSemVer(target.major, target.minor, target.patch, [0]);
+                return withResult(createComparator(targetWithPrerelease, 'lt'), hasPrerelease ? [target] : []);
+            }
+            return withResult(createComparator(partial, 'lt'), hasPrerelease ? [partial] : []);
+        }
+        case '<=': {
+            if (!isFullVersion(partial)) {
+                const target = partial.minor === undefined
+                    ? createSemVer(partial.major + 1, 0, 0, [0])
+                    : createSemVer(partial.major, partial.minor + 1, 0, [0]);
+                return withResult(createComparator(target, 'lt'), hasPrerelease ? [toFullVersion(partial)] : []);
+            }
+            return withResult(createComparator(partial, 'lte'), hasPrerelease ? [partial] : []);
+        }
+        case '^':
+            return parseCaretRange(partial);
+        case '~':
+            return parseTildeRange(partial);
+    }
+}
+const OPERATORS = ['>=', '>', '<=', '<', '=', '^', '~', ''];
+function isOperator(s) {
+    return OPERATORS.includes(s);
+}
+function parseSingleComparator(comp) {
+    const trimmed = comp.trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'X') {
+        return withResult(() => true, []);
+    }
+    const match = COMPARATOR_REGEX.exec(trimmed);
+    if (!match)
+        return undefined;
+    const operator = match[1] || '';
+    const versionStr = match[2];
+    if (!versionStr) {
+        return operator === '' ? withResult(() => true, []) : undefined;
+    }
+    const partial = parsePartialVersion(versionStr);
+    if (!partial || !isOperator(operator))
+        return undefined;
+    return parseComparatorWithOperator(operator, partial);
+}
+function parseComparatorSet(set) {
+    const hyphenResult = parseHyphenRange(set);
+    if (hyphenResult)
+        return hyphenResult;
+    const parts = set.trim().split(/\s+/);
+    const results = [];
+    for (const part of parts) {
+        if (part === '')
+            continue;
+        const parsed = parseSingleComparator(part);
+        if (!parsed)
+            return undefined;
+        results.push(parsed);
+    }
+    return results.length === 0 ? [withResult(() => true, [])] : results;
+}
+function checkPrereleaseAllowed(version, prereleaseVersions) {
+    if (version.prerelease.length === 0)
+        return true;
+    return prereleaseVersions.some(pv => hasSameBaseVersion(version, pv));
+}
+function satisfies(version, range, options) {
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return false;
+    const includePrerelease = options?.includePrerelease ?? true;
+    for (const orPart of range.split('||')) {
+        const comparatorSet = parseComparatorSet(orPart);
+        if (!comparatorSet)
+            continue;
+        const allMatch = comparatorSet.every(c => c.comparator(parsed));
+        if (!allMatch)
+            continue;
+        if (includePrerelease)
+            return true;
+        const prereleaseVersions = comparatorSet.flatMap(c => c.prereleaseVersions);
+        if (checkPrereleaseAllowed(parsed, prereleaseVersions))
+            return true;
+    }
+    return false;
+}
+
+export { compareSemVer, compareVersions, formatVersion, isFullVersion, parsePartialVersion, parseVersion, satisfies, toFullVersion };

package/lib/types/index.d.ts

@@ -0,0 +1,41 @@
+interface ISemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: ReadonlyArray<string | number>;
+}
+interface IPartialSemVer {
+    major: number;
+    minor: number | undefined;
+    patch: number | undefined;
+    prerelease: ReadonlyArray<string | number>;
+    isWildcard?: boolean;
+}
+type IComparator = (version: ISemVer) => boolean;
+interface IComparatorWithPrerelease {
+    comparator: IComparator;
+    prereleaseVersions: ISemVer[];
+}
+interface ISatisfiesOptions {
+    /**
+     * Include prerelease versions in the comparison.
+     * When true, prerelease versions will match ranges even if the range
+     * doesn't include a prerelease tag.
+     * @default true (for compatibility with compare-versions)
+     */
+    includePrerelease?: boolean;
+}
+
+declare function compareSemVer(v1: ISemVer, v2: ISemVer): -1 | 0 | 1;
+declare function compareVersions(v1: string, v2: string): -1 | 0 | 1;
+
+declare function parseVersion(version: string): ISemVer | undefined;
+declare function parsePartialVersion(version: string): IPartialSemVer | undefined;
+declare function isFullVersion(v: IPartialSemVer): v is ISemVer;
+declare function toFullVersion(v: IPartialSemVer): ISemVer;
+declare function formatVersion(v: ISemVer): string;
+
+declare function satisfies(version: string, range: string, options?: ISatisfiesOptions): boolean;
+
+export { compareSemVer, compareVersions, formatVersion, isFullVersion, parsePartialVersion, parseVersion, satisfies, toFullVersion };
+export type { IComparator, IComparatorWithPrerelease, IPartialSemVer, ISatisfiesOptions, ISemVer };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@guanghechen/version",
+  "version": "1.0.0",
+  "description": "Lightweight semver version comparison utilities.",
+  "author": {
+    "name": "guanghechen",
+    "url": "https://github.com/guanghechen/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/version@0.0.1",
+    "directory": "packages/version"
+  },
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/version@0.0.1/packages/version#readme",
+  "keywords": [
+    "semver",
+    "version",
+    "compare"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./lib/esm/index.mjs",
+      "require": "./lib/cjs/index.cjs",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "source": "./src/index.ts",
+  "main": "./lib/cjs/index.cjs",
+  "module": "./lib/esm/index.mjs",
+  "types": "./lib/types/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup -c ../../rollup.config.mjs",
+    "clean": "rimraf lib",
+    "test": "vitest run --config ../../vitest.config.ts",
+    "test:coverage": "vitest run --config ../../vitest.config.ts --coverage",
+    "test:update": "vitest run --config ../../vitest.config.ts -u"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "gitHead": "12990a720b31d50d217e2e17a6191256dc94eda6"
+}