keep-a-changelog 2.5.3 → 2.6.0

package/esm/deps/deno.land/std@0.205.0/semver/_shared.d.ts

@@ -1,42 +0,0 @@
-import { Operator } from "./types.js";
-export declare function compareNumber(a: number, b: number): 1 | 0 | -1;
-export declare function checkIdentifier(v1: ReadonlyArray<string | number>, v2: ReadonlyArray<string | number>): 1 | 0 | -1;
-export declare function compareIdentifier(v1: ReadonlyArray<string | number>, v2: ReadonlyArray<string | number>): 1 | 0 | -1;
-declare const re: RegExp[];
-declare const src: string[];
-declare const NUMERICIDENTIFIER: number;
-declare const FULL: number;
-declare const XRANGE: number;
-declare const TILDE: number;
-declare const CARET: number;
-declare const COMPARATOR: number;
-declare const HYPHENRANGE: number;
-declare const STAR: number;
-/**
- * Returns true if the value is a valid SemVer number.
- *
- * Must be a number. Must not be NaN. Can be positive or negative infinity.
- * Can be between 0 and MAX_SAFE_INTEGER.
- * @param value The value to check
- * @returns True if its a valid semver number
- */
-export declare function isValidNumber(value: unknown): value is number;
-export declare const MAX_LENGTH = 256;
-/**
- * Returns true if the value is a valid semver pre-release or build identifier.
- *
- * Must be a string. Must be between 1 and 256 characters long. Must match
- * the regular expression /[0-9A-Za-z-]+/.
- * @param value The value to check
- * @returns True if the value is a valid semver string.
- */
-export declare function isValidString(value: unknown): value is string;
-/**
- * Checks to see if the value is a valid Operator string.
- *
- * Adds a type assertion if true.
- * @param value The value to check
- * @returns True if the value is a valid Operator string otherwise false.
- */
-export declare function isValidOperator(value: unknown): value is Operator;
-export { CARET, COMPARATOR, FULL, HYPHENRANGE, NUMERICIDENTIFIER, re, src, STAR, TILDE, XRANGE, };

package/esm/deps/deno.land/std@0.205.0/semver/_shared.js

@@ -1,230 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-export function compareNumber(a, b) {
-    if (isNaN(a) || isNaN(b)) {
-        throw new Error("Comparison against non-numbers");
-    }
-    return a === b ? 0 : a < b ? -1 : 1;
-}
-export function checkIdentifier(v1, v2) {
-    // NOT having a prerelease is > having one
-    // But NOT having a build is < having one
-    if (v1.length && !v2.length) {
-        return -1;
-    }
-    else if (!v1.length && v2.length) {
-        return 1;
-    }
-    else {
-        return 0;
-    }
-}
-export function compareIdentifier(v1, v2) {
-    let i = 0;
-    do {
-        const a = v1[i];
-        const b = v2[i];
-        if (a === undefined && b === undefined) {
-            // same length is equal
-            return 0;
-        }
-        else if (b === undefined) {
-            // longer > shorter
-            return 1;
-        }
-        else if (a === undefined) {
-            // shorter < longer
-            return -1;
-        }
-        else if (typeof a === "string" && typeof b === "number") {
-            // string > number
-            return 1;
-        }
-        else if (typeof a === "number" && typeof b === "string") {
-            // number < string
-            return -1;
-        }
-        else if (a < b) {
-            return -1;
-        }
-        else if (a > b) {
-            return 1;
-        }
-        else {
-            // If they're equal, continue comparing segments.
-            continue;
-        }
-    } while (++i);
-    // It can't ever reach here, but typescript doesn't realize that so
-    // add this line so the return type is inferred correctly.
-    return 0;
-}
-// The actual regexps
-const re = [];
-const src = [];
-let R = 0;
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
-const NUMERICIDENTIFIER = R++;
-src[NUMERICIDENTIFIER] = "0|[1-9]\\d*";
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-const NONNUMERICIDENTIFIER = R++;
-src[NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
-// ## Main Version
-// Three dot-separated numeric identifiers.
-const MAINVERSION = R++;
-const nid = src[NUMERICIDENTIFIER];
-src[MAINVERSION] = `(${nid})\\.(${nid})\\.(${nid})`;
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
-const PRERELEASEIDENTIFIER = R++;
-src[PRERELEASEIDENTIFIER] = "(?:" + src[NUMERICIDENTIFIER] + "|" +
-    src[NONNUMERICIDENTIFIER] + ")";
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
-const PRERELEASE = R++;
-src[PRERELEASE] = "(?:-(" +
-    src[PRERELEASEIDENTIFIER] +
-    "(?:\\." +
-    src[PRERELEASEIDENTIFIER] +
-    ")*))";
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
-const BUILDIDENTIFIER = R++;
-src[BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
-const BUILD = R++;
-src[BUILD] = "(?:\\+(" + src[BUILDIDENTIFIER] + "(?:\\." +
-    src[BUILDIDENTIFIER] + ")*))";
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups.  The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
-const FULL = R++;
-const FULLPLAIN = "v?" + src[MAINVERSION] + src[PRERELEASE] + "?" + src[BUILD] +
-    "?";
-src[FULL] = "^" + FULLPLAIN + "$";
-const GTLT = R++;
-src[GTLT] = "((?:<|>)?=?)";
-// Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifier, meaning "any version"
-// Only the first item is strictly required.
-const XRANGEIDENTIFIER = R++;
-src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + "|x|X|\\*";
-const XRANGEPLAIN = R++;
-src[XRANGEPLAIN] = "[v=\\s]*(" +
-    src[XRANGEIDENTIFIER] +
-    ")" +
-    "(?:\\.(" +
-    src[XRANGEIDENTIFIER] +
-    ")" +
-    "(?:\\.(" +
-    src[XRANGEIDENTIFIER] +
-    ")" +
-    "(?:" +
-    src[PRERELEASE] +
-    ")?" +
-    src[BUILD] +
-    "?" +
-    ")?)?";
-const XRANGE = R++;
-src[XRANGE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAIN] + "$";
-// Tilde ranges.
-// Meaning is "reasonably at or greater than"
-const LONETILDE = R++;
-src[LONETILDE] = "(?:~>?)";
-const TILDE = R++;
-src[TILDE] = "^" + src[LONETILDE] + src[XRANGEPLAIN] + "$";
-// Caret ranges.
-// Meaning is "at least and backwards compatible with"
-const LONECARET = R++;
-src[LONECARET] = "(?:\\^)";
-const CARET = R++;
-src[CARET] = "^" + src[LONECARET] + src[XRANGEPLAIN] + "$";
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-const COMPARATOR = R++;
-src[COMPARATOR] = "^" + src[GTLT] + "\\s*(" + FULLPLAIN + ")$|^$";
-// Something like `1.2.3 - 1.2.4`
-const HYPHENRANGE = R++;
-src[HYPHENRANGE] = "^\\s*(" +
-    src[XRANGEPLAIN] +
-    ")" +
-    "\\s+-\\s+" +
-    "(" +
-    src[XRANGEPLAIN] +
-    ")" +
-    "\\s*$";
-// Star ranges basically just allow anything at all.
-const STAR = R++;
-src[STAR] = "(<|>)?=?\\s*\\*";
-// Compile to actual regexp objects.
-// All are flag-free, unless they were created above with a flag.
-for (let i = 0; i < R; i++) {
-    if (!re[i]) {
-        re[i] = new RegExp(src[i]);
-    }
-}
-/**
- * Returns true if the value is a valid SemVer number.
- *
- * Must be a number. Must not be NaN. Can be positive or negative infinity.
- * Can be between 0 and MAX_SAFE_INTEGER.
- * @param value The value to check
- * @returns True if its a valid semver number
- */
-export function isValidNumber(value) {
-    return (typeof value === "number" &&
-        !Number.isNaN(value) && (!Number.isFinite(value) ||
-        (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
-}
-export const MAX_LENGTH = 256;
-/**
- * Returns true if the value is a valid semver pre-release or build identifier.
- *
- * Must be a string. Must be between 1 and 256 characters long. Must match
- * the regular expression /[0-9A-Za-z-]+/.
- * @param value The value to check
- * @returns True if the value is a valid semver string.
- */
-export function isValidString(value) {
-    return (typeof value === "string" &&
-        value.length > 0 &&
-        value.length <= MAX_LENGTH &&
-        !!value.match(/[0-9A-Za-z-]+/));
-}
-/**
- * Checks to see if the value is a valid Operator string.
- *
- * Adds a type assertion if true.
- * @param value The value to check
- * @returns True if the value is a valid Operator string otherwise false.
- */
-export function isValidOperator(value) {
-    if (typeof value !== "string")
-        return false;
-    switch (value) {
-        case "":
-        case "=":
-        case "==":
-        case "===":
-        case "!==":
-        case "!=":
-        case ">":
-        case ">=":
-        case "<":
-        case "<=":
-            return true;
-        default:
-            return false;
-    }
-}
-export { CARET, COMPARATOR, FULL, HYPHENRANGE, NUMERICIDENTIFIER, re, src, STAR, TILDE, XRANGE, };

package/esm/deps/deno.land/std@0.205.0/semver/cmp.d.ts

@@ -1,9 +0,0 @@
-import type { Operator, SemVer } from "./types.js";
-/**
- * Do a comparison of two semantic version objects based on the given operator
- * @param s0 The left side of the comparison
- * @param operator The operator to use for the comparison
- * @param s1 The right side of the comparison
- * @returns True or false based on the operator
- */
-export declare function cmp(s0: SemVer, operator: Operator, s1: SemVer): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/cmp.js

@@ -1,35 +0,0 @@
-import { eq } from "./eq.js";
-import { neq } from "./neq.js";
-import { gte } from "./gte.js";
-import { gt } from "./gt.js";
-import { lt } from "./lt.js";
-import { lte } from "./lte.js";
-/**
- * Do a comparison of two semantic version objects based on the given operator
- * @param s0 The left side of the comparison
- * @param operator The operator to use for the comparison
- * @param s1 The right side of the comparison
- * @returns True or false based on the operator
- */
-export function cmp(s0, operator, s1) {
-    switch (operator) {
-        case "":
-        case "=":
-        case "==":
-        case "===":
-            return eq(s0, s1);
-        case "!=":
-        case "!==":
-            return neq(s0, s1);
-        case ">":
-            return gt(s0, s1);
-        case ">=":
-            return gte(s0, s1);
-        case "<":
-            return lt(s0, s1);
-        case "<=":
-            return lte(s0, s1);
-        default:
-            throw new TypeError(`Invalid operator: ${operator}`);
-    }
-}

package/esm/deps/deno.land/std@0.205.0/semver/comparator_format.d.ts

@@ -1,8 +0,0 @@
-import type { SemVerComparator } from "./types.js";
-/**
- * Formats the comparator into a string
- * @example >=0.0.0
- * @param comparator
- * @returns A string representation of the comparator
- */
-export declare function comparatorFormat(comparator: SemVerComparator): string;

package/esm/deps/deno.land/std@0.205.0/semver/comparator_format.js

@@ -1,11 +0,0 @@
-import { format } from "./format.js";
-/**
- * Formats the comparator into a string
- * @example >=0.0.0
- * @param comparator
- * @returns A string representation of the comparator
- */
-export function comparatorFormat(comparator) {
-    const { semver, operator } = comparator;
-    return `${operator}${format(semver)}`;
-}

package/esm/deps/deno.land/std@0.205.0/semver/comparator_intersects.d.ts

@@ -1,8 +0,0 @@
-import type { SemVerComparator } from "./types.js";
-/**
- * Returns true if the range of possible versions intersects with the other comparators set of possible versions
- * @param c0 The left side comparator
- * @param c1 The right side comparator
- * @returns True if any part of the comparators intersect
- */
-export declare function comparatorIntersects(c0: SemVerComparator, c1: SemVerComparator): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/comparator_intersects.js

@@ -1,45 +0,0 @@
-import { gte } from "./gte.js";
-import { lte } from "./lte.js";
-/**
- * Returns true if the range of possible versions intersects with the other comparators set of possible versions
- * @param c0 The left side comparator
- * @param c1 The right side comparator
- * @returns True if any part of the comparators intersect
- */
-export function comparatorIntersects(c0, c1) {
-    const l0 = c0.min;
-    const l1 = c0.max;
-    const r0 = c1.min;
-    const r1 = c1.max;
-    // We calculate the min and max ranges of both comparators.
-    // The minimum min is 0.0.0, the maximum max is ANY.
-    //
-    // Comparators with equality operators have the same min and max.
-    //
-    // We then check to see if the min's of either range falls within the span of the other range.
-    //
-    // A couple of intersection examples:
-    // ```
-    // l0 ---- l1
-    //     r0 ---- r1
-    // ```
-    // ```
-    //     l0 ---- l1
-    // r0 ---- r1
-    // ```
-    // ```
-    // l0 ------ l1
-    //    r0--r1
-    // ```
-    // ```
-    // l0 - l1
-    // r0 - r1
-    // ```
-    //
-    // non-intersection example
-    // ```
-    // l0 -- l1
-    //          r0 -- r1
-    // ```
-    return (gte(l0, r0) && lte(l0, r1)) || (gte(r0, l0) && lte(r0, l1));
-}

package/esm/deps/deno.land/std@0.205.0/semver/comparator_max.d.ts

@@ -1,9 +0,0 @@
-import type { Operator, SemVer } from "./types.js";
-/**
- * The maximum version that could match this comparator.
- *
- * If an invalid comparator is given such as <0.0.0 then
- * an out of range semver will be returned.
- * @returns the version, the MAX version or the next smallest patch version
- */
-export declare function comparatorMax(semver: SemVer, operator: Operator): SemVer;

package/esm/deps/deno.land/std@0.205.0/semver/comparator_max.js

@@ -1,45 +0,0 @@
-import { ANY, INVALID, MAX } from "./constants.js";
-/**
- * The maximum version that could match this comparator.
- *
- * If an invalid comparator is given such as <0.0.0 then
- * an out of range semver will be returned.
- * @returns the version, the MAX version or the next smallest patch version
- */
-export function comparatorMax(semver, operator) {
-    if (semver === ANY) {
-        return MAX;
-    }
-    switch (operator) {
-        case "!=":
-        case "!==":
-        case ">":
-        case ">=":
-            return MAX;
-        case "":
-        case "=":
-        case "==":
-        case "===":
-        case "<=":
-            return semver;
-        case "<": {
-            const patch = semver.patch - 1;
-            const minor = patch >= 0 ? semver.minor : semver.minor - 1;
-            const major = minor >= 0 ? semver.major : semver.major - 1;
-            // if you try to do <0.0.0 it will Give you -∞.∞.∞
-            // which means no SemVer can compare successfully to it.
-            if (major < 0) {
-                return INVALID;
-            }
-            else {
-                return {
-                    major,
-                    minor: minor >= 0 ? minor : Number.POSITIVE_INFINITY,
-                    patch: patch >= 0 ? patch : Number.POSITIVE_INFINITY,
-                    prerelease: [],
-                    build: [],
-                };
-            }
-        }
-    }
-}

package/esm/deps/deno.land/std@0.205.0/semver/comparator_min.d.ts

@@ -1,8 +0,0 @@
-import type { Operator, SemVer } from "./types.js";
-/**
- * The minimum semantic version that could match this comparator
- * @param semver The semantic version of the comparator
- * @param operator The operator of the comparator
- * @returns The minimum valid semantic version
- */
-export declare function comparatorMin(semver: SemVer, operator: Operator): SemVer;

package/esm/deps/deno.land/std@0.205.0/semver/comparator_min.js

@@ -1,32 +0,0 @@
-import { ANY, MAX, MIN } from "./constants.js";
-import { gt } from "./gt.js";
-import { increment } from "./increment.js";
-/**
- * The minimum semantic version that could match this comparator
- * @param semver The semantic version of the comparator
- * @param operator The operator of the comparator
- * @returns The minimum valid semantic version
- */
-export function comparatorMin(semver, operator) {
-    if (semver === ANY) {
-        return MIN;
-    }
-    switch (operator) {
-        case ">":
-            return semver.prerelease.length > 0
-                ? increment(semver, "pre")
-                : increment(semver, "patch");
-        case "!=":
-        case "!==":
-        case "<=":
-        case "<":
-            // The min(<0.0.0) is MAX
-            return gt(semver, MIN) ? MIN : MAX;
-        case ">=":
-        case "":
-        case "=":
-        case "==":
-        case "===":
-            return semver;
-    }
-}

package/esm/deps/deno.land/std@0.205.0/semver/compare.d.ts

@@ -1,10 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * Compare two semantic version objects.
- *
- * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
- * greater.
- *
- * Sorts in ascending order if passed to `Array.sort()`,
- */
-export declare function compare(s0: SemVer, s1: SemVer): 1 | 0 | -1;

package/esm/deps/deno.land/std@0.205.0/semver/compare.js

@@ -1,18 +0,0 @@
-import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
-/**
- * Compare two semantic version objects.
- *
- * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
- * greater.
- *
- * Sorts in ascending order if passed to `Array.sort()`,
- */
-export function compare(s0, s1) {
-    if (s0 === s1)
-        return 0;
-    return (compareNumber(s0.major, s1.major) ||
-        compareNumber(s0.minor, s1.minor) ||
-        compareNumber(s0.patch, s1.patch) ||
-        checkIdentifier(s0.prerelease, s1.prerelease) ||
-        compareIdentifier(s0.prerelease, s1.prerelease));
-}

package/esm/deps/deno.land/std@0.205.0/semver/compare_build.d.ts

@@ -1,13 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * Compare two semantic version objects including build metadata.
- *
- * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
- * greater.
- *
- * Sorts in ascending order if passed to `Array.sort()`,
- * @param s0
- * @param s1
- * @returns
- */
-export declare function compareBuild(s0: SemVer, s1: SemVer): 1 | 0 | -1;

package/esm/deps/deno.land/std@0.205.0/semver/compare_build.js

@@ -1,23 +0,0 @@
-import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
-/**
- * Compare two semantic version objects including build metadata.
- *
- * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
- * greater.
- *
- * Sorts in ascending order if passed to `Array.sort()`,
- * @param s0
- * @param s1
- * @returns
- */
-export function compareBuild(s0, s1) {
-    if (s0 === s1)
-        return 0;
-    return (compareNumber(s0.major, s1.major) ||
-        compareNumber(s0.minor, s1.minor) ||
-        compareNumber(s0.patch, s1.patch) ||
-        checkIdentifier(s0.prerelease, s1.prerelease) ||
-        compareIdentifier(s0.prerelease, s1.prerelease) ||
-        checkIdentifier(s1.build, s0.build) ||
-        compareIdentifier(s0.build, s1.build));
-}

package/esm/deps/deno.land/std@0.205.0/semver/constants.d.ts

@@ -1,42 +0,0 @@
-import type { SemVer, SemVerComparator } from "./types.js";
-/**
- * MAX is a sentinel value used by some range calculations.
- * It is equivalent to `∞.∞.∞`.
- */
-export declare const MAX: SemVer;
-/**
- * The minimum valid SemVer object. Equivalent to `0.0.0`.
- */
-export declare const MIN: SemVer;
-/**
- * A sentinel value used to denote an invalid SemVer object
- * which may be the result of impossible ranges or comparator operations.
- * @example
- * ```ts
- * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
- * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
- * import { INVALID } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
- * eq(parse("1.2.3"), INVALID);
- * ```
- */
-export declare const INVALID: SemVer;
-/**
- * ANY is a sentinel value used by some range calculations. It is not a valid
- * SemVer object and should not be used directly.
- * @example
- * ```ts
- * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
- * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
- * import { ANY } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
- * eq(parse("1.2.3"), ANY); // false
- * ```
- */
-export declare const ANY: SemVer;
-/**
- * A comparator which will span all valid semantic versions
- */
-export declare const ALL: SemVerComparator;
-/**
- * A comparator which will not span any semantic versions
- */
-export declare const NONE: SemVerComparator;

package/esm/deps/deno.land/std@0.205.0/semver/constants.js

@@ -1,75 +0,0 @@
-/**
- * MAX is a sentinel value used by some range calculations.
- * It is equivalent to `∞.∞.∞`.
- */
-export const MAX = {
-    major: Number.POSITIVE_INFINITY,
-    minor: Number.POSITIVE_INFINITY,
-    patch: Number.POSITIVE_INFINITY,
-    prerelease: [],
-    build: [],
-};
-/**
- * The minimum valid SemVer object. Equivalent to `0.0.0`.
- */
-export const MIN = {
-    major: 0,
-    minor: 0,
-    patch: 0,
-    prerelease: [],
-    build: [],
-};
-/**
- * A sentinel value used to denote an invalid SemVer object
- * which may be the result of impossible ranges or comparator operations.
- * @example
- * ```ts
- * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
- * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
- * import { INVALID } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
- * eq(parse("1.2.3"), INVALID);
- * ```
- */
-export const INVALID = {
-    major: Number.NEGATIVE_INFINITY,
-    minor: Number.POSITIVE_INFINITY,
-    patch: Number.POSITIVE_INFINITY,
-    prerelease: [],
-    build: [],
-};
-/**
- * ANY is a sentinel value used by some range calculations. It is not a valid
- * SemVer object and should not be used directly.
- * @example
- * ```ts
- * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
- * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
- * import { ANY } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
- * eq(parse("1.2.3"), ANY); // false
- * ```
- */
-export const ANY = {
-    major: Number.NaN,
-    minor: Number.NaN,
-    patch: Number.NaN,
-    prerelease: [],
-    build: [],
-};
-/**
- * A comparator which will span all valid semantic versions
- */
-export const ALL = {
-    operator: "",
-    semver: ANY,
-    min: MIN,
-    max: MAX,
-};
-/**
- * A comparator which will not span any semantic versions
- */
-export const NONE = {
-    operator: "<",
-    semver: MIN,
-    min: MAX,
-    max: MIN,
-};