/* eslint-disable max-lines */
/* eslint-disable func-style */
/* eslint-disable function-paren-newline */
/* eslint-disable max-statements */
/* eslint-disable no-param-reassign */
/* eslint-disable complexity */
/* eslint-disable max-params */
/* eslint-disable max-depth */
/* eslint-disable prefer-destructuring */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable arrow-body-style */
/* eslint-disable init-declarations */

// This is a heavily stripped down/reformatted version of https://github.com/npm/node-semver/blob/v5.5.1/semver.js
// Originally licensed under ISC (https://github.com/npm/node-semver/blob/v5.5.1/LICENSE)
// Copyright (c) Isaac Z. Schlueter and Contributors

const MAX_LENGTH = 256;
const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;

// Max safe segment length for coercion.
const MAX_SAFE_COMPONENT_LENGTH = 16;

// The actual regexps go on re
/**
 * @type {RegExp[]}
 */
const re = [];

/**
 * @type {string[]}
 */
const src = [];
const NUMERICIDENTIFIER = 0;
const NUMERICIDENTIFIERLOOSE = 1;
const NONNUMERICIDENTIFIER = 2;
const MAINVERSION = 3;
const MAINVERSIONLOOSE = 4;
const PRERELEASEIDENTIFIER = 5;
const PRERELEASEIDENTIFIERLOOSE = 6;
const PRERELEASE = 7;
const PRERELEASELOOSE = 8;
const BUILDIDENTIFIER = 9;
const BUILD = 10;
const FULL = 11;
const LOOSE = 12;
const GTLT = 13;
const XRANGEIDENTIFIERLOOSE = 14;
const XRANGEIDENTIFIER = 15;
const XRANGEPLAIN = 16;
const XRANGEPLAINLOOSE = 17;
const XRANGE = 18;
const XRANGELOOSE = 19;
const COERCE = 20;
const LONETILDE = 21;
const TILDETRIM = 22;
const TILDE = 23;
const TILDELOOSE = 24;
const LONECARET = 25;
const CARET = 26;
const CARETLOOSE = 27;
const CARETTRIM = 28;
const COMPARATORLOOSE = 29;
const COMPARATOR = 30;
const COMPARATORTRIM = 31;
const HYPHENRANGE = 32;
const HYPHENRANGELOOSE = 33;
const STAR = 34;

// 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.
/* eslint-disable operator-linebreak */
src[NUMERICIDENTIFIER] = "0|[1-9]\\d*";
src[NUMERICIDENTIFIERLOOSE] = "[0-9]+";

// ## Non-numeric Identifier
// Zero or more digits, followed by a letter or hyphen, and then zero or more letters, digits, or hyphens.
src[NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";

// ## Main Version
// Three dot-separated numeric identifiers.
src[MAINVERSION] = `(${src[NUMERICIDENTIFIER]})\\.(${src[NUMERICIDENTIFIER]})\\.(${src[NUMERICIDENTIFIER]})`;
src[MAINVERSIONLOOSE] = `(${src[NUMERICIDENTIFIERLOOSE]})\\.(${src[NUMERICIDENTIFIERLOOSE]})\\.(${src[NUMERICIDENTIFIERLOOSE]})`;

// ## Pre-release Version Identifier
// A numeric identifier, or a non-numeric identifier.
src[PRERELEASEIDENTIFIER] = `(?:${src[NUMERICIDENTIFIER]}|${src[NONNUMERICIDENTIFIER]})`;
src[PRERELEASEIDENTIFIERLOOSE] = `(?:${src[NUMERICIDENTIFIERLOOSE]}|${src[NONNUMERICIDENTIFIER]})`;

// ## Pre-release Version
// Hyphen, followed by one or more dot-separated pre-release version identifiers.
src[PRERELEASE] = `(?:-(${src[PRERELEASEIDENTIFIER]}(?:\\.${src[PRERELEASEIDENTIFIER]})*))`;
src[PRERELEASELOOSE] = `(?:-?(${src[PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[PRERELEASEIDENTIFIERLOOSE]})*))`;

// ## Build Metadata Identifier
// Any combination of digits, letters, or hyphens.
src[BUILDIDENTIFIER] = "[0-9A-Za-z-]+";

// ## Build Metadata
// Plus sign, followed by one or more period-separated build metadata identifiers.
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 FULLPLAIN = `v?${src[MAINVERSION]}${src[PRERELEASE]}?${src[BUILD]}?`;
src[FULL] = `^${FULLPLAIN}$`;

// Like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
// Also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty common in the npm registry.
const LOOSEPLAIN = `[v=\\s]*${src[MAINVERSIONLOOSE]}${src[PRERELEASELOOSE]}?${src[BUILD]}?`;
src[LOOSE] = `^${LOOSEPLAIN}$`;
src[GTLT] = "((?:<|>)?=?)";

// Something like "2.*" or "1.2.x".
// Note that "x.x" is a valid xRange identifer, meaning "any version"
// Only the first item is strictly required.
src[XRANGEIDENTIFIERLOOSE] = `${src[NUMERICIDENTIFIERLOOSE]}|x|X|\\*`;
src[XRANGEIDENTIFIER] = `${src[NUMERICIDENTIFIER]}|x|X|\\*`;

/* eslint-disable-next-line max-len */
src[XRANGEPLAIN] = `[v=\\s]*(${src[XRANGEIDENTIFIER]})(?:\\.(${src[XRANGEIDENTIFIER]})(?:\\.(${src[XRANGEIDENTIFIER]})(?:${src[PRERELEASE]})?${src[BUILD]}?)?)?`;

/* eslint-disable-next-line max-len */
src[XRANGEPLAINLOOSE] = `[v=\\s]*(${src[XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[XRANGEIDENTIFIERLOOSE]})(?:${src[PRERELEASELOOSE]})?${src[BUILD]}?)?)?`;

src[XRANGE] = `^${src[GTLT]}\\s*${src[XRANGEPLAIN]}$`;
src[XRANGELOOSE] = `^${src[GTLT]}\\s*${src[XRANGEPLAINLOOSE]}$`;

// Coercion.
// Extract anything that could conceivably be a part of a valid semver
/* eslint-disable-next-line max-len */
src[COERCE] = `(?:^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`;

// Tilde ranges.
// Meaning is "reasonably at or greater than"
src[LONETILDE] = "(?:~>?)";

src[TILDETRIM] = `(\\s*)${src[LONETILDE]}\\s+`;
re[TILDETRIM] = new RegExp(src[TILDETRIM], "g");
const tildeTrimReplace = "$1~";

src[TILDE] = `^${src[LONETILDE]}${src[XRANGEPLAIN]}$`;
src[TILDELOOSE] = `^${src[LONETILDE]}${src[XRANGEPLAINLOOSE]}$`;

// Caret ranges.
// Meaning is "at least and backwards compatible with"
src[LONECARET] = "(?:\\^)";
src[CARETTRIM] = `(\\s*)${src[LONECARET]}\\s+`;
re[CARETTRIM] = new RegExp(src[CARETTRIM], "g");
const caretTrimReplace = "$1^";
src[CARET] = `^${src[LONECARET]}${src[XRANGEPLAIN]}$`;
src[CARETLOOSE] = `^${src[LONECARET]}${src[XRANGEPLAINLOOSE]}$`;

// A simple gt/lt/eq thing, or just "" to indicate "any version"
src[COMPARATORLOOSE] = `^${src[GTLT]}\\s*(${LOOSEPLAIN})$|^$`;

src[COMPARATOR] = `^${src[GTLT]}\\s*(${FULLPLAIN})$|^$`;

// An expression to strip any whitespace between the gtlt and the thing it modifies, so that `> 1.2.3` ==> `>1.2.3`
src[COMPARATORTRIM] = `(\\s*)${src[GTLT]}\\s*(${LOOSEPLAIN}|${src[XRANGEPLAIN]})`;

// This one has to use the /g flag
re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], "g");
const comparatorTrimReplace = "$1$2$3";

// Something like `1.2.3 - 1.2.4`
// Note that these all use the loose form, because they'll be checked against either the strict or loose comparator form later.
src[HYPHENRANGE] = `^\\s*(${src[XRANGEPLAIN]})\\s+-\\s+(${src[XRANGEPLAIN]})\\s*$`;

src[HYPHENRANGELOOSE] = `^\\s*(${src[XRANGEPLAINLOOSE]})\\s+-\\s+(${src[XRANGEPLAINLOOSE]})\\s*$`;

// Star ranges basically just allow anything at all.
src[STAR] = "(<|>)?=?\\s*\\*";
/* eslint-enable operator-linebreak */

// Compile to actual regexp objects.
// All are flag-free, unless they were created above with a flag.
for (let idx = 0; idx <= STAR; idx++) {
    if (!re[idx]) {
        re[idx] = new RegExp(src[idx]);
    }
}

const ANY = {};
const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";

function compareIdentifiers(left, right) {
    const numeric = /^[0-9]+$/;
    const leftIsNumeric = numeric.test(left);
    const rightIsNumeric = numeric.test(right);
    if (leftIsNumeric && !rightIsNumeric) {
        return -1;
    }

    if (rightIsNumeric && !leftIsNumeric) {
        return 1;
    }

    if (leftIsNumeric && rightIsNumeric) {
        left = Number(left);
        right = Number(right);
    }

    if (left < right) {
        return -1;
    }

    if (left > right) {
        return 1;
    }

    return 0;
}

// This function is passed to string.replace(re[HYPHENRANGE])
// M, m, patch, prerelease, build
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
// 1.2 - 3.4 => >=1.2.0 <3.5.0
function hyphenReplace($0,
    from, fM, fm, fp, fpr, fb,
    to, tM, tm, tp, tpr) {

    if (isX(fM)) {
        from = "";
    } else if (isX(fm)) {
        from = `>=${fM}.0.0`;
    } else if (isX(fp)) {
        from = `>=${fM}.${fm}.0`;
    } else {
        from = `>=${from}`;
    }

    if (isX(tM)) {
        to = "";
    } else if (isX(tm)) {
        to = `<${Number(tM) + 1}.0.0`;
    } else if (isX(tp)) {
        to = `<${tM}.${Number(tm) + 1}.0`;
    } else if (tpr) {
        to = `<=${tM}.${tm}.${tp}-${tpr}`;
    } else {
        to = `<=${to}`;
    }

    return `${from} ${to}`.trim();
}

function replaceTilde(comp, loose) {
    const regex = loose ? re[TILDELOOSE] : re[TILDE];

    return comp.replace(regex, function(match, major, minor, patch, prerelease) {
        let ret;

        if (isX(major)) {
            ret = "";
        } else if (isX(minor)) {
            ret = `>=${major}.0.0 <${Number(major) + 1}.0.0`;
        } else if (isX(patch)) {
            // ~1.2 == >=1.2.0 <1.3.0
            ret = `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0`;
        } else if (prerelease) {
            if (prerelease.charAt(0) !== "-") {
                prerelease = `-${prerelease}`;
            }
            ret = `>=${major}.${minor}.${patch}${prerelease} <${major}.${Number(minor) + 1}.0`;
        } else {
            // ~1.2.3 == >=1.2.3 <1.3.0
            ret = `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0`;
        }

        return ret;
    });
}

// ~, ~> --> * (any, kinda silly)
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
function replaceTildes(comp, loose) {
    return comp
        .trim()
        .split(/\s+/)
        .map((comp1) => replaceTilde(comp1, loose))
        .join(" ");
}

function replaceCaret(comp, loose) {
    const regex = loose ? re[CARETLOOSE] : re[CARET];

    return comp.replace(regex, function(match, major, minor, patch, prerelease) {
        let ret;

        if (isX(major)) {
            ret = "";
        } else if (isX(minor)) {
            ret = `>=${major}.0.0 <${Number(major) + 1}.0.0`;
        } else if (isX(patch)) {
            if (major === "0") {
                ret = `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0`;
            } else {
                ret = `>=${major}.${minor}.0 <${Number(major) + 1}.0.0`;
            }
        } else if (prerelease) {
            if (prerelease.charAt(0) !== "-") {
                prerelease = `-${prerelease}`;
            }
            if (major === "0") {
                if (minor === "0") {
                    ret = `>=${major}.${minor}.${patch}${prerelease} <${major}.${minor}.${Number(patch) + 1}`;
                } else {
                    ret = `>=${major}.${minor}.${patch}${prerelease} <${major}.${Number(minor) + 1}.0`;
                }
            } else {
                ret = `>=${major}.${minor}.${patch}${prerelease} <${Number(major) + 1}.0.0`;
            }
        } else if (major === "0") {
            if (minor === "0") {
                ret = `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}`;
            } else {
                ret = `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0`;
            }
        } else {
            ret = `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0`;
        }

        return ret;
    });
}

// ^ --> * (any, kinda silly)
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
// ^1.2.3 --> >=1.2.3 <2.0.0
// ^1.2.0 --> >=1.2.0 <2.0.0
function replaceCarets(comp, loose) {
    return comp
        .trim()
        .split(/\s+/)
        .map((comp1) => replaceCaret(comp1, loose))
        .join(" ");
}

function replaceXRange(comp, loose) {
    comp = comp.trim();
    const regex = loose ? re[XRANGELOOSE] : re[XRANGE];

    return comp.replace(regex, function(ret, operator, major, minor, patch) {
        const xM = isX(major);
        const xm = xM || isX(minor);
        const xp = xm || isX(patch);
        const anyX = xp;

        if (operator === "=" && anyX) {
            operator = "";
        }

        if (xM) {
            if (operator === ">" || operator === "<") {
                // Nothing is allowed
                ret = "<0.0.0";
            } else {
                // Nothing is forbidden
                ret = "*";
            }
        } else if (operator && anyX) {
            // Replace X with 0
            if (xm) {
                minor = 0;
            }
            if (xp) {
                patch = 0;
            }

            if (operator === ">") {
                // >1 => >=2.0.0
                // >1.2 => >=1.3.0
                // >1.2.3 => >= 1.2.4
                operator = ">=";
                if (xm) {
                    major = Number(major) + 1;
                    minor = 0;
                    patch = 0;
                } else if (xp) {
                    minor = Number(minor) + 1;
                    patch = 0;
                }
            } else if (operator === "<=") {
                // <=0.7.x is actually <0.8.0, since any 0.7.x should pass. Similarly, <=7.x is actually <8.0.0, etc.
                operator = "<";
                if (xm) {
                    major = Number(major) + 1;
                } else {
                    minor = Number(minor) + 1;
                }
            }

            ret = `${operator}${major}.${minor}.${patch}`;
        } else if (xm) {
            ret = `>=${major}.0.0 <${Number(major) + 1}.0.0`;
        } else if (xp) {
            ret = `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0`;
        }

        return ret;
    });
}

function replaceXRanges(comp, loose) {
    return comp
        .split(/\s+/)
        .map((comp1) => replaceXRange(comp1, loose))
        .join(" ");
}

// Because * is AND-ed with everything else in the comparator, and '' means "any version", just remove the *s entirely.
function replaceStars(comp) {
    // Looseness is ignored here.  star is always as loose as it gets!
    return comp.trim().replace(re[STAR], "");
}

// Comprised of xranges, tildes, stars, and gtlt's at this point.
// Already replaced the hyphen ranges turn into a set of JUST comparators.
function parseComparator(comp, loose) {
    comp = replaceCarets(comp, loose);
    comp = replaceTildes(comp, loose);
    comp = replaceXRanges(comp, loose);
    comp = replaceStars(comp, loose);

    return comp;
}

class SemVer {

    /**
     * A semantic version.
     * @param {string} version The version.
     * @param {boolean} loose If this is a loose representation of a version.
     * @returns {SemVer} a new instance.
     */
    constructor(version, loose) {
        if (version instanceof SemVer) {
            if (version.loose === loose) {
                return version;
            }
            version = version.version;
        } else if (typeof version !== "string") {
            throw new TypeError(`Invalid Version: ${version}`);
        }
        if (version.length > MAX_LENGTH) {
            throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
        }
        if (!(this instanceof SemVer)) {
            return new SemVer(version, loose);
        }
        this.loose = loose;
        const matches = version.trim().match(loose ? re[LOOSE] : re[FULL]);
        if (!matches) {
            throw new TypeError(`Invalid Version: ${version}`);
        }
        this.raw = version;
        // These are actually numbers
        this.major = Number(matches[1]);
        this.minor = Number(matches[2]);
        this.patch = Number(matches[3]);
        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
            throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
            throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
            throw new TypeError("Invalid patch version");
        }
        // Numberify any prerelease numeric ids
        if (matches[4]) {
            this.prerelease = matches[4].split(".").map((id) => {
                if ((/^[0-9]+$/).test(id)) {
                    const num = Number(id);
                    if (num >= 0 && num < MAX_SAFE_INTEGER) {
                        return num;
                    }
                }

                return id;
            });
        } else {
            this.prerelease = [];
        }
        this.build = matches[5] ? matches[5].split(".") : [];
        this.format();
    }

    format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
            this.version += `-${this.prerelease.join(".")}`;
        }

        return this.version;
    }

    toString() {
        return this.version;
    }

    /**
     * Comares the current instance against another instance.
     * @param {SemVer} other The SemVer to comare to.
     * @returns {0|1|-1} A comparable value for sorting.
     */
    compare(other) {
        return this.compareMain(other) || this.comparePre(other);
    }

    compareMain(other) {
        if (!(other instanceof SemVer)) {
            other = new SemVer(other, this.loose);
        }

        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
    }

    comparePre(other) {
        if (!(other instanceof SemVer)) {
            other = new SemVer(other, this.loose);
        }
        // NOT having a prerelease is > having one
        if (this.prerelease.length && !other.prerelease.length) {
            return -1;
        } else if (!this.prerelease.length && other.prerelease.length) {
            return 1;
        } else if (!this.prerelease.length && !other.prerelease.length) {
            return 0;
        }
        let idx = 0;
        do {
            const thisPrelease = this.prerelease[idx];
            const otherPrelease = other.prerelease[idx];
            const thisPreleaseIsUndefined = typeof thisPrelease === "undefined";
            const otherPreleaseIsUndefined = typeof otherPrelease === "undefined";
            if (thisPreleaseIsUndefined && otherPreleaseIsUndefined) {
                return 0;
            } else if (otherPreleaseIsUndefined) {
                return 1;
            } else if (thisPreleaseIsUndefined) {
                return -1;
            } else if (thisPrelease === otherPrelease) {
                continue;
            } else {
                return compareIdentifiers(thisPrelease, otherPrelease);
            }
        } while ((idx += 1) > 0);

        // Should not hit this point, but assume equal ranking.
        return 0;
    }
}

const compare = (leftVersion, rightVersion, loose) => new SemVer(leftVersion, loose).compare(new SemVer(rightVersion, loose));
const gt = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) > 0;
const lt = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) < 0;
const eq = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) === 0;
const neq = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) !== 0;
const gte = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) >= 0;
const lte = (leftVersion, rightVersion, loose) => compare(leftVersion, rightVersion, loose) <= 0;

function cmp(left, op, right, loose) {
    let ret;
    switch (op) {
        case "===":
            if (typeof left === "object") {
                left = left.version;
            }
            if (typeof right === "object") {
                right = right.version;
            }
            ret = left === right;
            break;
        case "!==":
            if (typeof left === "object") {
                left = left.version;
            }
            if (typeof right === "object") {
                right = right.version;
            }
            ret = left !== right;
            break;
        case "":
        case "=":
        case "==":
            ret = eq(left, right, loose);
            break;
        case "!=":
            ret = neq(left, right, loose);
            break;
        case ">":
            ret = gt(left, right, loose);
            break;
        case ">=":
            ret = gte(left, right, loose);
            break;
        case "<":
            ret = lt(left, right, loose);
            break;
        case "<=":
            ret = lte(left, right, loose);
            break;
        default:
            throw new TypeError(`Invalid operator: ${op}`);
    }

    return ret;
}

function testSet(set, version) {
    for (let idx = 0; idx < set.length; idx++) {
        if (!set[idx].test(version)) {
            return false;
        }
    }

    if (version.prerelease.length) {
        // Find the set of versions that are allowed to have prereleases
        // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
        // That should allow `1.2.3-pr.2` to pass.
        // However, `1.2.4-alpha.notready` should NOT be allowed, even though it's within the range set by the comparators.
        for (let idx = 0; idx < set.length; idx++) {
            if (set[idx].semver !== ANY) {
                if (set[idx].semver.prerelease.length > 0) {
                    const allowed = set[idx].semver;
                    if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
                        return true;
                    }
                }
            }
        }

        // Version has a -pre, but it's not one of the ones we like.
        return false;
    }

    return true;
}
class Comparator {
    constructor(comp, loose) {
        if (comp instanceof Comparator) {
            if (comp.loose === loose) {
                return comp;
            }
            comp = comp.value;
        }
        if (!(this instanceof Comparator)) {
            return new Comparator(comp, loose);
        }
        this.loose = loose;
        this.parse(comp);
        if (this.semver === ANY) {
            this.value = "";
        } else {
            this.value = this.operator + this.semver.version;
        }
    }

    parse(comp) {
        const regex = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
        const matches = comp.match(regex);
        if (!matches) {
            throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = matches[1];
        if (this.operator === "=") {
            this.operator = "";
        }
        // If it literally is just '>' or '' then allow anything.
        if (matches[2]) {
            this.semver = new SemVer(matches[2], this.loose);
        } else {
            this.semver = ANY;
        }
    }

    toString() {
        return this.value;
    }

    test(version) {
        if (this.semver === ANY) {
            return true;
        }
        if (typeof version === "string") {
            version = new SemVer(version, this.loose);
        }

        return cmp(version, this.operator, this.semver, this.loose);
    }
}

/**
 * A range object.
 * @param {Range|Comparator|string} range the value to parse to a Range.
 * @param {any} loose whether the range is explicit or a loose value.
 * @returns {Range} the Range instace.
 */
class Range {
    constructor(range, loose) {
        if (range instanceof Range) {
            if (range.loose === loose) {
                return range;
            }

            return new Range(range.raw, loose);
        }
        if (range instanceof Comparator) {
            return new Range(range.value, loose);
        }
        if (!(this instanceof Range)) {
            return new Range(range, loose);
        }
        this.loose = loose;
        // First, split based on boolean or ||
        /**
         * @type {string}
         */
        this.raw = range;
        // Throw out any that are not relevant for whatever reason
        const hasLength = (item) => item.length;
        this.set = this.raw.split(/\s*\|\|\s*/).map(function (range1) {
            return this.parseRange(range1.trim());
        }, this)
            .filter(hasLength);
        if (!this.set.length) {
            throw new TypeError(`Invalid SemVer Range: ${range}`);
        }
        this.format();
    }

    format() {
        this.range = this.set.map((comps) => comps.join(" ").trim())
            .join("||")
            .trim();

        return this.range;
    }

    toString() {
        return this.range;
    }

    parseRange(range) {
        const loose = this.loose;
        range = range.trim();
        // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
        const hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
        range = range.replace(hr, hyphenReplace);
        // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
        range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
        // `~ 1.2.3` => `~1.2.3`
        range = range.replace(re[TILDETRIM], tildeTrimReplace);
        // `^ 1.2.3` => `^1.2.3`
        range = range.replace(re[CARETTRIM], caretTrimReplace);
        // Normalize spaces
        range = range.split(/\s+/).join(" ");
        // At this point, the range is completely trimmed and ready to be split into comparators.
        const compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
        let set = range.split(" ").map((comp) => parseComparator(comp, loose))
            .join(" ")
            .split(/\s+/);
        if (loose) {
            // In loose mode, throw out any that are not valid comparators
            set = set.filter((comp) => Boolean(comp.match(compRe)));
        }
        set = set.map((comp) => new Comparator(comp, loose));

        return set;
    }

    // If ANY of the sets match ALL of its comparators, then pass
    test(version) {
        if (!version) {
            return false;
        }
        if (typeof version === "string") {
            version = new SemVer(version, this.loose);
        }
        for (let idx = 0; idx < this.set.length; idx++) {
            if (testSet(this.set[idx], version)) {
                return true;
            }
        }

        return false;
    }
}

/**
 * Checks if the provided version can satisfy the provided range.
 * @param {string} version The specific version.
 * @param {string} range The range expression.
 * @param {any} loose If the range is a loose expression.
 * @returns {boolean} Whether the versions successfully satisfies the range.
 */
function satisfies(version, range, loose) {
    try {
        const rangeObj = new Range(range, loose);

        return rangeObj.test(version);
    } catch (er) {
        return false;
    }
}

module.exports.satisfies = satisfies;