@vltpkg/semver 0.0.0-0.1730239248325

package/dist/esm/index.d.ts

@@ -0,0 +1,246 @@
+import { Range } from './range.js';
+import { IncrementType, Version } from './version.js';
+export * from './comparator.js';
+export * from './range.js';
+export * from './version.js';
+/** Return the parsed version string, or `undefined` if invalid */
+export declare const parse: (version: Version | string) => Version | undefined;
+/** Return the parsed version range, or `undefined` if invalid */
+export declare const parseRange: (range: Range | string, includePrerelease?: boolean) => Range | undefined;
+/**
+ * return true if the version is valid
+ *
+ * Note: do not use this if you intend to immediately parse the version if it's
+ * valid. Just use {@link parse}, and guard the possible undefined value, or
+ * use `Version.parse(..)` to throw on invalid values.
+ */
+export declare const valid: (version: Version | string) => boolean;
+/**
+ * return true if the range is valid
+ *
+ * Note: do not use this if you intend to immediately parse the range if it's
+ * valid. Just use {@link parseRange}, and guard the possible undefined value,
+ * or use `new Range(..)` to throw on invalid values.
+ */
+export declare const validRange: (range: Range | string) => boolean;
+/**
+ * Return true if the version satisfies the range.
+ */
+export declare const satisfies: (version: Version | string, range: Range | string, includePrerelease?: boolean) => boolean;
+/**
+ * Increment the specified part of the version, and return the resulting
+ * object. If a Version object is provided, it will be modified in-place.
+ *
+ * Part behaviors:
+ *
+ * - `'major'` If the version is a `M.0.0-...` version with a prerelease, then
+ * simply drop the prerelease. Otherwise, set the minor and patch to 0, and
+ * increment the major. So `1.0.0-beta` becomes `1.0.0`, and `1.2.3` becomes
+ * `2.0.0`
+ *
+ * - `'minor'` If the version is a `M.m.0-...` version with a prerelease, then
+ * simply drop the prerelease. Otherwise, set the patch to 0, and increment the
+ * minor. So `1.2.0-beta` becomes `1.2.0`, and `1.2.3` becomes `1.3.0`.
+ *
+ * - `'patch'` If the version has a prerelease, then simply drop the
+ * prerelease. Otherwise, increment the patch value. So `1.2.3-beta` becomes
+ * `1.2.3` and `1.2.3` becomes `1.2.4`.
+ *
+ * - `'premajor'` Set the patch and minor versions to `0`, increment the major
+ * version, and add a prerelease, using the optional identifier.
+ *
+ * - `'preminor'` Set the patch version to `0`, increment the minor version,
+ * and add a prerelease, using the optional identifier.
+ *
+ * - `'prepatch'` If a prerelease is already present, increment the patch
+ * version, otherwise leave it untouched, and add a prerelease, using the
+ * optional identifier.
+ *
+ * - `'prerelease'` If a prerelease version is present, then behave the same as
+ * `'prepatch'`. Otherwise, add a prerelease, using the optional identifier.
+ *
+ * - `'pre'` This is mostly for use by the other prerelease incrementers.
+ *
+ *     - If a prerelease identifier is provided:
+ *
+ *        Update that named portion of the prerelease. For example,
+ *        `inc('1.2.3-beta.4', 'pre', 'beta')` would result in `1.2.3-beta.5`.
+ *
+ *        If there is no prerelease identifier by that name, then replace the
+ *        prerelease with `[name]`. So `inc('1.2.3-alpha.4', 'pre', 'beta')`
+ *        would result in `1.2.3-beta`.
+ *
+ *        If the prerelease identifer is present, but has no numeric value
+ *        following it, then add `0`. So `inc('1.2.3-beta', 'pre', 'beta')`
+ *        would result in `1.2.3-beta.0`.
+ *
+ *     - If no prerelease identifier is provided:
+ *
+ *       If there is no current prerelease, then set the prerelease to `0`. So,
+ *       `inc('1.2.3', 'pre')` becomes `1.2.3-0`.
+ *
+ *       If the last item in the prerelease is numeric, then increment it. So,
+ *       `inc('1.2.3-beta.3', 'pre')` becomes `1.2.3-beta.4`.
+ */
+export declare const inc: (version: Version | string, part: IncrementType, prereleaseIdentifier?: string) => Version;
+/**
+ * The method used by {@link sort}, exported for passing directly to
+ * `Array.sort`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { sortMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.sort(sortMethod))
+ * // ['1.2.3', '2.3.4', '5.2.3']
+ * ```
+ */
+export declare const sortMethod: (a: Version | string, b: Version | string) => number;
+/**
+ * Sort an array of version strings or objects in ascending SemVer precedence
+ * order (ie, lowest versions first).
+ *
+ * Invalid version strings are sorted to the end of the array in ascending
+ * alphabetical order.
+ *
+ * Note: when using this method, the list is cloned prior to sorting, to
+ * prevent surprising mutation. To sort the list in place, see
+ * {@link sortMethod}.
+ */
+export declare const sort: <T extends Version | string = string | Version>(list: T[]) => T[];
+/**
+ * Sort an array of version strings or objects in descending SemVer
+ * precedence order (ie, highest versions first).
+ *
+ * Invalid version strings are sorted to the end of the array in ascending
+ * alphabetical order.
+ *
+ * Note: when using this method, the list is cloned prior to sorting, to
+ * prevent surprising mutation. To sort the list in place, see
+ * {@link rsortMethod}.
+ */
+export declare const rsort: <T extends Version | string = string | Version>(list: T[]) => T[];
+/**
+ * The method used by {@link rsort}, exported for passing directly to
+ * `Array.sort`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { rsortMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.sort(rsortMethod))
+ * // ['5.2.3', '2.3.4', '1.2.3']
+ * ```
+ */
+export declare const rsortMethod: (a: Version | string, b: Version | string) => number;
+/**
+ * Method used by {@link filter}, for use in `Array.filter` directly.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { filterMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.filter(filterMethod('>=2.x')))
+ * // ['5.2.3', '2.3.4']
+ * ```
+ */
+export declare const filterMethod: (range: Range | string, includePrerelease?: boolean) => ((version: Version | string) => boolean);
+/**
+ * Filter a list of versions to find all that match a given range.
+ */
+export declare const filter: <T extends Version | string = string | Version>(list: T[], range: Range | string, includePrerelease?: boolean) => T[];
+/**
+ * Find the highest-precedence match for a range within a list of versions
+ *
+ * Returns `undefined` if no match was found.
+ */
+export declare const highest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Faster form of {@link highest}, for use when the list is sorted
+ * in precedence order (lower-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export declare const sortedHighest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Faster form of {@link highest}, for use when the list is sorted
+ * in reverse precedence order (higher-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export declare const rsortedHighest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Find the lowest-precedence match for a range within a list of versions
+ *
+ * Returns `undefined` if no match was found.
+ */
+export declare const lowest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Faster form of {@link lowest}, for use when the list is sorted
+ * in precedence order (lower-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export declare const sortedLowest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Faster form of {@link lowest}, for use when the list is sorted
+ * in reverse precedence order (higher-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export declare const rsortedLowest: (list: (Version | string)[], range: Range | string, includePrerelease?: boolean) => Version | undefined;
+/**
+ * Same as {@link sortMethod}, but throws if either version is not valid.
+ * 1 if versionA is higher precedence than versionB
+ * -1 if versionA is lower precedence than versionB
+ * 0 if they have equal precedence
+ */
+export declare const compare: (versionA: Version | string, versionB: Version | string) => 0 | 1 | -1;
+/**
+ * Inverse of {@link compare}
+ *
+ * Same as {@link rsortMethod}, but throws if either version is not valid.
+ *
+ * -1 if versionA is higher precedence than versionB
+ * 1 if versionA is lower precedence than versionB
+ * 0 if they have equal precedence
+ */
+export declare const rcompare: (versionA: Version | string, versionB: Version | string) => 0 | 1 | -1;
+/** true if versionA is > versionB. throws on invalid values */
+export declare const gt: (versionA: Version | string, versionB: Version | string) => boolean;
+/** true if versionA is >= versionB. throws on invalid values */
+export declare const gte: (versionA: Version | string, versionB: Version | string) => boolean;
+/** true if versionA is < versionB. throws on invalid values */
+export declare const lt: (versionA: Version | string, versionB: Version | string) => boolean;
+/** true if versionA is <= versionB. throws on invalid values */
+export declare const lte: (versionA: Version | string, versionB: Version | string) => boolean;
+/** true if versionA is not equal to versionB. throws on invalid values */
+export declare const neq: (versionA: Version | string, versionB: Version | string) => boolean;
+/** true if versionA is equal to versionB. throws on invalid values */
+export declare const eq: (versionA: Version | string, versionB: Version | string) => boolean;
+/** extract the major version number, or undefined if invalid */
+export declare const major: (version: Version | string) => number | undefined;
+/** extract the minor version number, or undefined if invalid */
+export declare const minor: (version: Version | string) => number | undefined;
+/** extract the patch version number, or undefined if invalid */
+export declare const patch: (version: Version | string) => number | undefined;
+/**
+ * extract the list of prerelease identifiers, or undefined if the version
+ * is invalid. If no prerelease identifiers are present, returns `[]`.
+ */
+export declare const prerelease: (version: Version | string) => (string | number)[] | undefined;
+/**
+ * extract the list of build identifiers, or undefined if the version
+ * is invalid. If no build identifiers are present, returns `[]`.
+ */
+export declare const build: (version: Version | string) => string[] | undefined;
+/** return all versions that do not have any prerelease identifiers */
+export declare const stable: <T extends Version | string = string | Version>(versions: T[]) => T[];
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/index.js

@@ -0,0 +1,400 @@
+import { Range } from './range.js';
+import { Version } from './version.js';
+import { syntaxError } from '@vltpkg/error-cause';
+export * from './comparator.js';
+export * from './range.js';
+export * from './version.js';
+/** Return the parsed version string, or `undefined` if invalid */
+export const parse = (version) => {
+    if (version instanceof Version)
+        return version;
+    try {
+        return Version.parse(String(version));
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Return the parsed version range, or `undefined` if invalid */
+export const parseRange = (range, includePrerelease = false) => {
+    if (typeof range === 'object') {
+        if (range.includePrerelease === includePrerelease)
+            return range;
+        range = range.raw;
+    }
+    try {
+        return new Range(range, includePrerelease);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * return true if the version is valid
+ *
+ * Note: do not use this if you intend to immediately parse the version if it's
+ * valid. Just use {@link parse}, and guard the possible undefined value, or
+ * use `Version.parse(..)` to throw on invalid values.
+ */
+export const valid = (version) => !!parse(version);
+/**
+ * return true if the range is valid
+ *
+ * Note: do not use this if you intend to immediately parse the range if it's
+ * valid. Just use {@link parseRange}, and guard the possible undefined value,
+ * or use `new Range(..)` to throw on invalid values.
+ */
+export const validRange = (range) => !!parseRange(range);
+/**
+ * Return true if the version satisfies the range.
+ */
+export const satisfies = (version, range, includePrerelease = false) => {
+    if (typeof version === 'string') {
+        const parsed = parse(version);
+        if (!parsed)
+            return false;
+        version = parsed;
+    }
+    if (typeof range === 'string') {
+        const parsed = parseRange(range, includePrerelease);
+        if (!parsed)
+            return false;
+        range = parsed;
+    }
+    return version.satisfies(range);
+};
+/**
+ * Increment the specified part of the version, and return the resulting
+ * object. If a Version object is provided, it will be modified in-place.
+ *
+ * Part behaviors:
+ *
+ * - `'major'` If the version is a `M.0.0-...` version with a prerelease, then
+ * simply drop the prerelease. Otherwise, set the minor and patch to 0, and
+ * increment the major. So `1.0.0-beta` becomes `1.0.0`, and `1.2.3` becomes
+ * `2.0.0`
+ *
+ * - `'minor'` If the version is a `M.m.0-...` version with a prerelease, then
+ * simply drop the prerelease. Otherwise, set the patch to 0, and increment the
+ * minor. So `1.2.0-beta` becomes `1.2.0`, and `1.2.3` becomes `1.3.0`.
+ *
+ * - `'patch'` If the version has a prerelease, then simply drop the
+ * prerelease. Otherwise, increment the patch value. So `1.2.3-beta` becomes
+ * `1.2.3` and `1.2.3` becomes `1.2.4`.
+ *
+ * - `'premajor'` Set the patch and minor versions to `0`, increment the major
+ * version, and add a prerelease, using the optional identifier.
+ *
+ * - `'preminor'` Set the patch version to `0`, increment the minor version,
+ * and add a prerelease, using the optional identifier.
+ *
+ * - `'prepatch'` If a prerelease is already present, increment the patch
+ * version, otherwise leave it untouched, and add a prerelease, using the
+ * optional identifier.
+ *
+ * - `'prerelease'` If a prerelease version is present, then behave the same as
+ * `'prepatch'`. Otherwise, add a prerelease, using the optional identifier.
+ *
+ * - `'pre'` This is mostly for use by the other prerelease incrementers.
+ *
+ *     - If a prerelease identifier is provided:
+ *
+ *        Update that named portion of the prerelease. For example,
+ *        `inc('1.2.3-beta.4', 'pre', 'beta')` would result in `1.2.3-beta.5`.
+ *
+ *        If there is no prerelease identifier by that name, then replace the
+ *        prerelease with `[name]`. So `inc('1.2.3-alpha.4', 'pre', 'beta')`
+ *        would result in `1.2.3-beta`.
+ *
+ *        If the prerelease identifer is present, but has no numeric value
+ *        following it, then add `0`. So `inc('1.2.3-beta', 'pre', 'beta')`
+ *        would result in `1.2.3-beta.0`.
+ *
+ *     - If no prerelease identifier is provided:
+ *
+ *       If there is no current prerelease, then set the prerelease to `0`. So,
+ *       `inc('1.2.3', 'pre')` becomes `1.2.3-0`.
+ *
+ *       If the last item in the prerelease is numeric, then increment it. So,
+ *       `inc('1.2.3-beta.3', 'pre')` becomes `1.2.3-beta.4`.
+ */
+export const inc = (version, part, prereleaseIdentifier) => (typeof version === 'string' ?
+    Version.parse(version)
+    : version).inc(part, prereleaseIdentifier);
+/**
+ * The method used by {@link sort}, exported for passing directly to
+ * `Array.sort`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { sortMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.sort(sortMethod))
+ * // ['1.2.3', '2.3.4', '5.2.3']
+ * ```
+ */
+export const sortMethod = (a, b) => {
+    const pa = parse(a);
+    const pb = parse(b);
+    /* c8 ignore start - nondeterministic */
+    if (!pa && !pb)
+        return String(a).localeCompare(String(b), 'en');
+    if (!pa)
+        return 1;
+    if (!pb)
+        return -1;
+    /* c8 ignore stop */
+    return pa.compare(pb);
+};
+/**
+ * Sort an array of version strings or objects in ascending SemVer precedence
+ * order (ie, lowest versions first).
+ *
+ * Invalid version strings are sorted to the end of the array in ascending
+ * alphabetical order.
+ *
+ * Note: when using this method, the list is cloned prior to sorting, to
+ * prevent surprising mutation. To sort the list in place, see
+ * {@link sortMethod}.
+ */
+export const sort = (list) => list.slice().sort(sortMethod);
+/**
+ * Sort an array of version strings or objects in descending SemVer
+ * precedence order (ie, highest versions first).
+ *
+ * Invalid version strings are sorted to the end of the array in ascending
+ * alphabetical order.
+ *
+ * Note: when using this method, the list is cloned prior to sorting, to
+ * prevent surprising mutation. To sort the list in place, see
+ * {@link rsortMethod}.
+ */
+export const rsort = (list) => list.slice().sort(rsortMethod);
+/**
+ * The method used by {@link rsort}, exported for passing directly to
+ * `Array.sort`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { rsortMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.sort(rsortMethod))
+ * // ['5.2.3', '2.3.4', '1.2.3']
+ * ```
+ */
+export const rsortMethod = (a, b) => {
+    const pa = parse(a);
+    const pb = parse(b);
+    /* c8 ignore start - nondeterministic */
+    if (!pa && !pb)
+        return String(a).localeCompare(String(b), 'en');
+    if (!pa)
+        return 1;
+    if (!pb)
+        return -1;
+    /* c8 ignore stop */
+    return pa.rcompare(pb);
+};
+/**
+ * Method used by {@link filter}, for use in `Array.filter` directly.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { filterMethod } from '@vltpkg/semver'
+ * const versions = ['1.2.3', '5.2.3', '2.3.4']
+ * console.log(versions.filter(filterMethod('>=2.x')))
+ * // ['5.2.3', '2.3.4']
+ * ```
+ */
+export const filterMethod = (range, includePrerelease = false) => {
+    const r = parseRange(range, includePrerelease);
+    return !r ?
+        () => false
+        : version => satisfies(version, r, r.includePrerelease);
+};
+/**
+ * Filter a list of versions to find all that match a given range.
+ */
+export const filter = (list, range, includePrerelease = false) => list.filter(filterMethod(range, includePrerelease));
+/**
+ * Find the highest-precedence match for a range within a list of versions
+ *
+ * Returns `undefined` if no match was found.
+ */
+export const highest = (list, range, includePrerelease = false) => {
+    const r = parseRange(range, includePrerelease);
+    if (!r)
+        return undefined;
+    let max = undefined;
+    for (const v of list) {
+        const version = parse(v);
+        if (!version)
+            continue;
+        if (!version.satisfies(r))
+            continue;
+        if (!max)
+            max = version;
+        else if (version.greaterThan(max))
+            max = version;
+    }
+    return max;
+};
+/**
+ * Faster form of {@link highest}, for use when the list is sorted
+ * in precedence order (lower-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export const sortedHighest = (list, range, includePrerelease = false) => {
+    const r = parseRange(range, includePrerelease);
+    if (!r)
+        return undefined;
+    for (let i = list.length - 1; i >= 0; i--) {
+        const v = list[i];
+        /* c8 ignore next */
+        if (!v)
+            continue;
+        const version = parse(v);
+        if (!version)
+            continue;
+        if (!version.satisfies(r))
+            continue;
+        return version;
+    }
+};
+/**
+ * Faster form of {@link highest}, for use when the list is sorted
+ * in reverse precedence order (higher-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export const rsortedHighest = (list, range, includePrerelease = false) => {
+    const r = parseRange(range, includePrerelease);
+    if (!r)
+        return undefined;
+    for (const v of list) {
+        const version = parse(v);
+        if (!version)
+            continue;
+        if (!version.satisfies(r))
+            continue;
+        return version;
+    }
+};
+/**
+ * Find the lowest-precedence match for a range within a list of versions
+ *
+ * Returns `undefined` if no match was found.
+ */
+export const lowest = (list, range, includePrerelease = false) => {
+    const r = parseRange(range, includePrerelease);
+    if (!r)
+        return undefined;
+    let min = undefined;
+    for (const v of list) {
+        const version = parse(v);
+        if (!version)
+            continue;
+        if (!version.satisfies(r))
+            continue;
+        if (!min)
+            min = version;
+        else if (version.lessThan(min))
+            min = version;
+    }
+    return min;
+};
+/**
+ * Faster form of {@link lowest}, for use when the list is sorted
+ * in precedence order (lower-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export const sortedLowest = (list, range, includePrerelease = false) => rsortedHighest(list, range, includePrerelease);
+/**
+ * Faster form of {@link lowest}, for use when the list is sorted
+ * in reverse precedence order (higher-precedence versions first).
+ *
+ * Note: This stops at the first match, and will produce incorrect results
+ * when the list is not properly sorted!
+ */
+export const rsortedLowest = (list, range, includePrerelease = false) => sortedHighest(list, range, includePrerelease);
+/**
+ * Same as {@link sortMethod}, but throws if either version is not valid.
+ * 1 if versionA is higher precedence than versionB
+ * -1 if versionA is lower precedence than versionB
+ * 0 if they have equal precedence
+ */
+export const compare = (versionA, versionB) => {
+    const a = parse(versionA);
+    if (!a) {
+        throw syntaxError('invalid version', { found: versionA });
+    }
+    const b = parse(versionB);
+    if (!b) {
+        throw syntaxError('invalid version', { found: versionB });
+    }
+    return a.compare(b);
+};
+/**
+ * Inverse of {@link compare}
+ *
+ * Same as {@link rsortMethod}, but throws if either version is not valid.
+ *
+ * -1 if versionA is higher precedence than versionB
+ * 1 if versionA is lower precedence than versionB
+ * 0 if they have equal precedence
+ */
+export const rcompare = (versionA, versionB) => compare(versionB, versionA);
+/** true if versionA is > versionB. throws on invalid values */
+export const gt = (versionA, versionB) => compare(versionA, versionB) > 0;
+/** true if versionA is >= versionB. throws on invalid values */
+export const gte = (versionA, versionB) => compare(versionA, versionB) >= 0;
+/** true if versionA is < versionB. throws on invalid values */
+export const lt = (versionA, versionB) => compare(versionA, versionB) < 0;
+/** true if versionA is <= versionB. throws on invalid values */
+export const lte = (versionA, versionB) => compare(versionA, versionB) <= 0;
+/** true if versionA is not equal to versionB. throws on invalid values */
+export const neq = (versionA, versionB) => compare(versionA, versionB) !== 0;
+/** true if versionA is equal to versionB. throws on invalid values */
+export const eq = (versionA, versionB) => compare(versionA, versionB) === 0;
+/** extract the major version number, or undefined if invalid */
+export const major = (version) => parse(version)?.major;
+/** extract the minor version number, or undefined if invalid */
+export const minor = (version) => parse(version)?.minor;
+/** extract the patch version number, or undefined if invalid */
+export const patch = (version) => parse(version)?.patch;
+/**
+ * extract the list of prerelease identifiers, or undefined if the version
+ * is invalid. If no prerelease identifiers are present, returns `[]`.
+ */
+export const prerelease = (version) => {
+    const p = parse(version);
+    if (!p)
+        return undefined;
+    return p.prerelease ?? [];
+};
+/**
+ * extract the list of build identifiers, or undefined if the version
+ * is invalid. If no build identifiers are present, returns `[]`.
+ */
+export const build = (version) => {
+    const p = parse(version);
+    if (!p)
+        return undefined;
+    return p.build ?? [];
+};
+/** return all versions that do not have any prerelease identifiers */
+export const stable = (versions) => versions.filter(v => {
+    const p = parse(v);
+    if (!p)
+        return false;
+    return !p.prerelease?.length;
+});
+//# sourceMappingURL=index.js.map