@vltpkg/semver 1.0.0-rc.23 → 1.0.0-rc.25

package/dist/index.d.ts

@@ -0,0 +1,203 @@
+import { Range } from './range.ts';
+import { Version } from './version.ts';
+import type { IncrementType } from './version.ts';
+export * from './comparator.ts';
+export * from './range.ts';
+export * from './version.ts';
+/** 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.
+ *
+ * See {@link Version.inc} for full description.
+ */
+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 &lt;= 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[];
+/**
+ * Return true if the range r1 intersects any of the ranges r2
+ * r1 and r2 are either Range objects or range strings.
+ * Returns true if any version would satisfy both ranges.
+ */
+export declare const intersects: (r1: Range | string, r2: Range | string, includePrerelease?: boolean) => boolean;

package/dist/index.js

@@ -0,0 +1,457 @@
+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 (!(typeof version === 'string'))
+        return version;
+    try {
+        return Version.parse(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.
+ *
+ * See {@link Version.inc} for full description.
+ */
+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 &lt;= 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;
+});
+/**
+ * Return true if the range r1 intersects any of the ranges r2
+ * r1 and r2 are either Range objects or range strings.
+ * Returns true if any version would satisfy both ranges.
+ */
+export const intersects = (r1, r2, includePrerelease) => {
+    const range1 = typeof r1 === 'string' ? parseRange(r1, includePrerelease) : r1;
+    const range2 = typeof r2 === 'string' ? parseRange(r2, includePrerelease) : r2;
+    if (!range1 || !range2)
+        return false;
+    // If either range is 'any', they intersect
+    if (range1.isAny || range2.isAny)
+        return true;
+    // Check if any set from range1 intersects with any set from range2
+    return range1.set.some(set1 => range2.set.some(set2 => intersectComparators(set1, set2)));
+};
+/**
+ * Check if two comparators can be satisfied simultaneously
+ */
+const intersectComparators = (comp1, comp2) => {
+    // Collect all tuples from both comparators
+    const tuples1 = comp1.tuples.filter((t) => Array.isArray(t));
+    const tuples2 = comp2.tuples.filter((t) => Array.isArray(t));
+    // Check if there's a satisfiable combination
+    return satisfiableRange(tuples1.concat(tuples2));
+};
+/**
+ * Check if a set of operator-version tuples represents a satisfiable range
+ * This is a simplified implementation that handles the most common cases
+ */
+const satisfiableRange = (tuples) => {
+    // Find bounds
+    let lowerBound = null;
+    let lowerInclusive = false;
+    let upperBound = null;
+    let upperInclusive = false;
+    let hasExact = null;
+    for (const [op, ver] of tuples) {
+        switch (op) {
+            case '':
+                // Exact match - if we already have a different exact match, no intersection
+                if (hasExact && !eq(hasExact, ver))
+                    return false;
+                hasExact = ver;
+                break;
+            case '>=':
+                /* c8 ignore start */
+                if (!lowerBound ||
+                    gt(ver, lowerBound) ||
+                    (eq(ver, lowerBound) && !lowerInclusive)) {
+                    lowerBound = ver;
+                    lowerInclusive = true;
+                }
+                /* c8 ignore stop */
+                break;
+            case '>':
+                if (!lowerBound || gt(ver, lowerBound)) {
+                    lowerBound = ver;
+                    lowerInclusive = false;
+                }
+                break;
+            case '<=':
+                if (!upperBound || lt(ver, upperBound)) {
+                    upperBound = ver;
+                    upperInclusive = true;
+                }
+                break;
+            case '<':
+                /* c8 ignore start */
+                if (!upperBound ||
+                    lt(ver, upperBound) ||
+                    eq(ver, upperBound)) {
+                    upperBound = ver;
+                    upperInclusive = false;
+                }
+                /* c8 ignore stop */
+                break;
+        }
+    }
+    // If we have an exact match, check if it's within bounds
+    if (hasExact) {
+        if (lowerBound) {
+            if (lowerInclusive ?
+                lt(hasExact, lowerBound)
+                : lte(hasExact, lowerBound)) {
+                return false;
+            }
+        }
+        if (upperBound) {
+            if (upperInclusive ?
+                gt(hasExact, upperBound)
+                : gte(hasExact, upperBound)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Check if lower bound is less than or equal to upper bound
+    if (lowerBound && upperBound) {
+        if (gt(lowerBound, upperBound))
+            return false;
+        if (eq(lowerBound, upperBound) &&
+            !(lowerInclusive && upperInclusive))
+            return false;
+    }
+    return true;
+};

package/dist/range.d.ts

@@ -0,0 +1,34 @@
+import { Comparator } from './comparator.ts';
+import type { Version } from './version.ts';
+export declare const isRange: (range: unknown) => range is Range;
+/**
+ * A representation of a semver range, used to test versions.
+ *
+ * Includes a set of comparators representing the `||`-separated
+ * sections of the range string
+ */
+export declare class Range {
+    #private;
+    /** raw string used to create this Range */
+    raw: string;
+    /** true if the range is `*` */
+    isAny: boolean;
+    /** true if the range is a single semver version */
+    isSingle: boolean;
+    /** true if the range cannot match anything */
+    /**
+     * set of {@link Comparator} objects representing the `||`-separated sections
+     * of the range. If at least one of these matches, then the version is a
+     * match.
+     */
+    set: Comparator[];
+    /** true if all prerelease versions should be included */
+    includePrerelease: boolean;
+    constructor(range: string, includePrerelease?: boolean);
+    /**
+     * test a {@link Version} against the range
+     */
+    test(v: Version): boolean;
+    /** return the simplified canonical form of this range */
+    toString(): string;
+}