keep-a-changelog 2.1.0 → 2.3.0

package/esm/deps/deno.land/{x/semver@v1.4.0 → std@0.173.0/semver}/mod.js

@@ -1,9 +1,9 @@
+// Copyright Isaac Z. Schlueter and Contributors. All rights reserved. ISC license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Note: this is the semver.org version of the spec that it implements
 // Not necessarily the package version of this code.
 export const SEMVER_SPEC_VERSION = "2.0.0";
 const MAX_LENGTH = 256;
-// Max safe segment length for coercion.
-const MAX_SAFE_COMPONENT_LENGTH = 16;
 // The actual regexps
 const re = [];
 const src = [];
@@ -14,8 +14,6 @@ let R = 0;
 // A single `0`, or a non-zero digit followed by zero or more digits.
 const NUMERICIDENTIFIER = R++;
 src[NUMERICIDENTIFIER] = "0|[1-9]\\d*";
-const NUMERICIDENTIFIERLOOSE = R++;
-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.
@@ -26,17 +24,11 @@ src[NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
 const MAINVERSION = R++;
 const nid = src[NUMERICIDENTIFIER];
 src[MAINVERSION] = `(${nid})\\.(${nid})\\.(${nid})`;
-const MAINVERSIONLOOSE = R++;
-const nidl = src[NUMERICIDENTIFIERLOOSE];
-src[MAINVERSIONLOOSE] = `(${nidl})\\.(${nidl})\\.(${nidl})`;
 // ## Pre-release Version Identifier
 // A numeric identifier, or a non-numeric identifier.
 const PRERELEASEIDENTIFIER = R++;
 src[PRERELEASEIDENTIFIER] = "(?:" + src[NUMERICIDENTIFIER] + "|" +
     src[NONNUMERICIDENTIFIER] + ")";
-const PRERELEASEIDENTIFIERLOOSE = R++;
-src[PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[NUMERICIDENTIFIERLOOSE] + "|" +
-    src[NONNUMERICIDENTIFIER] + ")";
 // ## Pre-release Version
 // Hyphen, followed by one or more dot-separated pre-release version
 // identifiers.
@@ -46,12 +38,6 @@ src[PRERELEASE] = "(?:-(" +
     "(?:\\." +
     src[PRERELEASEIDENTIFIER] +
     ")*))";
-const PRERELEASELOOSE = R++;
-src[PRERELEASELOOSE] = "(?:-?(" +
-    src[PRERELEASEIDENTIFIERLOOSE] +
-    "(?:\\." +
-    src[PRERELEASEIDENTIFIERLOOSE] +
-    ")*))";
 // ## Build Metadata Identifier
 // Any combination of digits, letters, or hyphens.
 const BUILDIDENTIFIER = R++;
@@ -73,24 +59,11 @@ const FULL = R++;
 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] +
-    "?";
-const LOOSE = R++;
-src[LOOSE] = "^" + LOOSEPLAIN + "$";
 const GTLT = R++;
 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.
-const XRANGEIDENTIFIERLOOSE = R++;
-src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
 const XRANGEIDENTIFIER = R++;
 src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + "|x|X|\\*";
 const XRANGEPLAIN = R++;
@@ -109,81 +82,24 @@ src[XRANGEPLAIN] = "[v=\\s]*(" +
     src[BUILD] +
     "?" +
     ")?)?";
-const XRANGEPLAINLOOSE = R++;
-src[XRANGEPLAINLOOSE] = "[v=\\s]*(" +
-    src[XRANGEIDENTIFIERLOOSE] +
-    ")" +
-    "(?:\\.(" +
-    src[XRANGEIDENTIFIERLOOSE] +
-    ")" +
-    "(?:\\.(" +
-    src[XRANGEIDENTIFIERLOOSE] +
-    ")" +
-    "(?:" +
-    src[PRERELEASELOOSE] +
-    ")?" +
-    src[BUILD] +
-    "?" +
-    ")?)?";
 const XRANGE = R++;
 src[XRANGE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAIN] + "$";
-const XRANGELOOSE = R++;
-src[XRANGELOOSE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAINLOOSE] + "$";
-// Coercion.
-// Extract anything that could conceivably be a part of a valid semver
-const COERCE = R++;
-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"
 const LONETILDE = R++;
 src[LONETILDE] = "(?:~>?)";
-const TILDETRIM = R++;
-src[TILDETRIM] = "(\\s*)" + src[LONETILDE] + "\\s+";
-re[TILDETRIM] = new RegExp(src[TILDETRIM], "g");
-const tildeTrimReplace = "$1~";
 const TILDE = R++;
 src[TILDE] = "^" + src[LONETILDE] + src[XRANGEPLAIN] + "$";
-const TILDELOOSE = R++;
-src[TILDELOOSE] = "^" + src[LONETILDE] + src[XRANGEPLAINLOOSE] + "$";
 // Caret ranges.
 // Meaning is "at least and backwards compatible with"
 const LONECARET = R++;
 src[LONECARET] = "(?:\\^)";
-const CARETTRIM = R++;
-src[CARETTRIM] = "(\\s*)" + src[LONECARET] + "\\s+";
-re[CARETTRIM] = new RegExp(src[CARETTRIM], "g");
-const caretTrimReplace = "$1^";
 const CARET = R++;
 src[CARET] = "^" + src[LONECARET] + src[XRANGEPLAIN] + "$";
-const CARETLOOSE = R++;
-src[CARETLOOSE] = "^" + src[LONECARET] + src[XRANGEPLAINLOOSE] + "$";
 // A simple gt/lt/eq thing, or just "" to indicate "any version"
-const COMPARATORLOOSE = R++;
-src[COMPARATORLOOSE] = "^" + src[GTLT] + "\\s*(" + LOOSEPLAIN + ")$|^$";
 const COMPARATOR = R++;
 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`
-const COMPARATORTRIM = R++;
-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.
 const HYPHENRANGE = R++;
 src[HYPHENRANGE] = "^\\s*(" +
     src[XRANGEPLAIN] +
@@ -193,15 +109,6 @@ src[HYPHENRANGE] = "^\\s*(" +
     src[XRANGEPLAIN] +
     ")" +
     "\\s*$";
-const HYPHENRANGELOOSE = R++;
-src[HYPHENRANGELOOSE] = "^\\s*(" +
-    src[XRANGEPLAINLOOSE] +
-    ")" +
-    "\\s+-\\s+" +
-    "(" +
-    src[XRANGEPLAINLOOSE] +
-    ")" +
-    "\\s*$";
 // Star ranges basically just allow anything at all.
 const STAR = R++;
 src[STAR] = "(<|>)?=?\\s*\\*";
@@ -212,10 +119,13 @@ for (let i = 0; i < R; i++) {
         re[i] = new RegExp(src[i]);
     }
 }
-export function parse(version, optionsOrLoose) {
-    if (!optionsOrLoose || typeof optionsOrLoose !== "object") {
-        optionsOrLoose = {
-            loose: !!optionsOrLoose,
+/**
+ * Attempt to parse a string as a semantic version, returning either a `SemVer`
+ * object or `null`.
+ */
+export function parse(version, options) {
+    if (typeof options !== "object") {
+        options = {
             includePrerelease: false,
         };
     }
@@ -228,41 +138,32 @@ export function parse(version, optionsOrLoose) {
     if (version.length > MAX_LENGTH) {
         return null;
     }
-    const r = optionsOrLoose.loose ? re[LOOSE] : re[FULL];
+    const r = re[FULL];
     if (!r.test(version)) {
         return null;
     }
     try {
-        return new SemVer(version, optionsOrLoose);
+        return new SemVer(version, options);
     }
-    catch (er) {
+    catch {
         return null;
     }
 }
-export function valid(version, optionsOrLoose) {
+/** Returns the parsed version, or null if it's not valid. */
+export function valid(version, options) {
     if (version === null)
         return null;
-    const v = parse(version, optionsOrLoose);
+    const v = parse(version, options);
     return v ? v.version : null;
 }
-export function clean(version, optionsOrLoose) {
-    const s = parse(version.trim().replace(/^[=v]+/, ""), optionsOrLoose);
-    return s ? s.version : null;
-}
 export class SemVer {
-    constructor(version, optionsOrLoose) {
+    constructor(version, options) {
         Object.defineProperty(this, "raw", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "loose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
@@ -305,19 +206,13 @@ export class SemVer {
             writable: true,
             value: void 0
         });
-        if (!optionsOrLoose || typeof optionsOrLoose !== "object") {
-            optionsOrLoose = {
-                loose: !!optionsOrLoose,
+        if (typeof options !== "object") {
+            options = {
                 includePrerelease: false,
             };
         }
         if (version instanceof SemVer) {
-            if (version.loose === optionsOrLoose.loose) {
-                return version;
-            }
-            else {
-                version = version.version;
-            }
+            version = version.version;
         }
         else if (typeof version !== "string") {
             throw new TypeError("Invalid Version: " + version);
@@ -326,11 +221,10 @@ export class SemVer {
             throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
         }
         if (!(this instanceof SemVer)) {
-            return new SemVer(version, optionsOrLoose);
+            return new SemVer(version, options);
         }
-        this.options = optionsOrLoose;
-        this.loose = !!optionsOrLoose.loose;
-        const m = version.trim().match(optionsOrLoose.loose ? re[LOOSE] : re[FULL]);
+        this.options = options;
+        const m = version.trim().match(re[FULL]);
         if (!m) {
             throw new TypeError("Invalid Version: " + version);
         }
@@ -449,36 +343,36 @@ export class SemVer {
         } while (++i);
         return 1;
     }
-    inc(release, identifier) {
+    increment(release, identifier) {
         switch (release) {
             case "premajor":
                 this.prerelease.length = 0;
                 this.patch = 0;
                 this.minor = 0;
                 this.major++;
-                this.inc("pre", identifier);
+                this.increment("pre", identifier);
                 break;
             case "preminor":
                 this.prerelease.length = 0;
                 this.patch = 0;
                 this.minor++;
-                this.inc("pre", identifier);
+                this.increment("pre", identifier);
                 break;
             case "prepatch":
                 // If this is already a prerelease, it will bump to the next version
                 // drop any prereleases that might already exist, since they are not
                 // relevant at this point.
                 this.prerelease.length = 0;
-                this.inc("patch", identifier);
-                this.inc("pre", identifier);
+                this.increment("patch", identifier);
+                this.increment("pre", identifier);
                 break;
             // If the input is a non-prerelease version, this acts the same as
             // prepatch.
             case "prerelease":
                 if (this.prerelease.length === 0) {
-                    this.inc("patch", identifier);
+                    this.increment("patch", identifier);
                 }
-                this.inc("pre", identifier);
+                this.increment("pre", identifier);
                 break;
             case "major":
                 // If this is a pre-major version, bump up to the same major version.
@@ -525,6 +419,7 @@ export class SemVer {
                     let i = this.prerelease.length;
                     while (--i >= 0) {
                         if (typeof this.prerelease[i] === "number") {
+                            // deno-fmt-ignore
                             this.prerelease[i]++;
                             i = -2;
                         }
@@ -559,22 +454,36 @@ export class SemVer {
     }
 }
 /**
- * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
+ * Returns the version incremented by the release type
+ * (major, minor, patch, or prerelease), or null if it's not valid.
+ *
+ * `premajor` in one call will bump the version up to the next major version and
+ * down to a prerelease of that major version. `preminor`, and `prepatch` work
+ * the same way.
+ *
+ * If called from a non-prerelease version, the `prerelease` will work the same
+ * as `prepatch`. It increments the patch version, then makes a prerelease. If
+ * the input version is already a prerelease it simply increments it.
  */
-export function inc(version, release, optionsOrLoose, identifier) {
-    if (typeof optionsOrLoose === "string") {
-        identifier = optionsOrLoose;
-        optionsOrLoose = undefined;
+export function increment(version, release, options, identifier) {
+    if (typeof options === "string") {
+        identifier = options;
+        options = undefined;
     }
     try {
-        return new SemVer(version, optionsOrLoose).inc(release, identifier).version;
+        return new SemVer(version, options).increment(release, identifier).version;
     }
-    catch (er) {
+    catch {
         return null;
     }
 }
-export function diff(version1, version2, optionsOrLoose) {
-    if (eq(version1, version2, optionsOrLoose)) {
+/**
+ * Returns difference between two versions by the release type  (`major`,
+ * `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`), or
+ * null if the versions are the same.
+ */
+export function difference(version1, version2, options) {
+    if (eq(version1, version2, options)) {
         return null;
     }
     else {
@@ -613,67 +522,87 @@ export function compareIdentifiers(a, b) {
 export function rcompareIdentifiers(a, b) {
     return compareIdentifiers(b, a);
 }
-/**
- * Return the major version number.
- */
-export function major(v, optionsOrLoose) {
-    return new SemVer(v, optionsOrLoose).major;
+/** Returns the major version number. */
+export function major(v, options) {
+    return new SemVer(v, options).major;
+}
+/** Returns the minor version number. */
+export function minor(v, options) {
+    return new SemVer(v, options).minor;
+}
+/** Returns the patch version number. */
+export function patch(v, options) {
+    return new SemVer(v, options).patch;
 }
 /**
- * Return the minor version number.
+ * 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 minor(v, optionsOrLoose) {
-    return new SemVer(v, optionsOrLoose).minor;
+export function compare(v1, v2, options) {
+    return new SemVer(v1, options).compare(new SemVer(v2, options));
 }
 /**
- * Return the patch version number.
+ * The same as {@linkcode compare} but considers `build` when two versions are
+ * equal. Sorts in ascending order if passed to `Array.sort()`.
  */
-export function patch(v, optionsOrLoose) {
-    return new SemVer(v, optionsOrLoose).patch;
-}
-export function compare(v1, v2, optionsOrLoose) {
-    return new SemVer(v1, optionsOrLoose).compare(new SemVer(v2, optionsOrLoose));
-}
-export function compareLoose(a, b) {
-    return compare(a, b, true);
-}
-export function compareBuild(a, b, loose) {
-    var versionA = new SemVer(a, loose);
-    var versionB = new SemVer(b, loose);
+export function compareBuild(a, b, options) {
+    const versionA = new SemVer(a, options);
+    const versionB = new SemVer(b, options);
     return versionA.compare(versionB) || versionA.compareBuild(versionB);
 }
-export function rcompare(v1, v2, optionsOrLoose) {
-    return compare(v2, v1, optionsOrLoose);
+/**
+ * Returns `0` if `v1 == v2`, or `-1` if `v1` is greater, or `1` if `v2` is
+ * greater. Sorts in descending order if passed to `Array.sort()`,
+ */
+export function rcompare(v1, v2, options) {
+    return compare(v2, v1, options);
 }
-export function sort(list, optionsOrLoose) {
+export function sort(list, options) {
     return list.sort((a, b) => {
-        return compareBuild(a, b, optionsOrLoose);
+        return compareBuild(a, b, options);
     });
 }
-export function rsort(list, optionsOrLoose) {
+export function rsort(list, options) {
     return list.sort((a, b) => {
-        return compareBuild(b, a, optionsOrLoose);
+        return compareBuild(b, a, options);
     });
 }
-export function gt(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) > 0;
+/** Greater than comparison */
+export function gt(v1, v2, options) {
+    return compare(v1, v2, options) > 0;
 }
-export function lt(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) < 0;
+/** Less than comparison */
+export function lt(v1, v2, options) {
+    return compare(v1, v2, options) < 0;
 }
-export function eq(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) === 0;
+/**
+ * This is true if they're logically equivalent, even if they're not the exact
+ * same string.
+ */
+export function eq(v1, v2, options) {
+    return compare(v1, v2, options) === 0;
 }
-export function neq(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) !== 0;
+/**
+ * This is true if they're not logically equivalent, even if they're the exact
+ * same string.
+ */
+export function neq(v1, v2, options) {
+    return compare(v1, v2, options) !== 0;
 }
-export function gte(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) >= 0;
+/** Greater than or equal comparison */
+export function gte(v1, v2, options) {
+    return compare(v1, v2, options) >= 0;
 }
-export function lte(v1, v2, optionsOrLoose) {
-    return compare(v1, v2, optionsOrLoose) <= 0;
+/** Less than or equal comparison */
+export function lte(v1, v2, options) {
+    return compare(v1, v2, options) <= 0;
 }
-export function cmp(v1, operator, v2, optionsOrLoose) {
+/**
+ * Pass in a comparison string, and it'll call the corresponding comparison
+ * function. `"==="` and `"!=="` do simple string comparison, but are included
+ * for completeness. Throws if an invalid comparison string is provided.
+ */
+export function cmp(v1, operator, v2, options) {
     switch (operator) {
         case "===":
             if (typeof v1 === "object")
@@ -690,24 +619,24 @@ export function cmp(v1, operator, v2, optionsOrLoose) {
         case "":
         case "=":
         case "==":
-            return eq(v1, v2, optionsOrLoose);
+            return eq(v1, v2, options);
         case "!=":
-            return neq(v1, v2, optionsOrLoose);
+            return neq(v1, v2, options);
         case ">":
-            return gt(v1, v2, optionsOrLoose);
+            return gt(v1, v2, options);
         case ">=":
-            return gte(v1, v2, optionsOrLoose);
+            return gte(v1, v2, options);
         case "<":
-            return lt(v1, v2, optionsOrLoose);
+            return lt(v1, v2, options);
         case "<=":
-            return lte(v1, v2, optionsOrLoose);
+            return lte(v1, v2, options);
         default:
             throw new TypeError("Invalid operator: " + operator);
     }
 }
 const ANY = {};
 export class Comparator {
-    constructor(comp, optionsOrLoose) {
+    constructor(comp, options) {
         Object.defineProperty(this, "semver", {
             enumerable: true,
             configurable: true,
@@ -726,37 +655,24 @@ export class Comparator {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "loose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        if (!optionsOrLoose || typeof optionsOrLoose !== "object") {
-            optionsOrLoose = {
-                loose: !!optionsOrLoose,
+        if (typeof options !== "object") {
+            options = {
                 includePrerelease: false,
             };
         }
         if (comp instanceof Comparator) {
-            if (comp.loose === !!optionsOrLoose.loose) {
-                return comp;
-            }
-            else {
-                comp = comp.value;
-            }
+            return comp;
         }
         if (!(this instanceof Comparator)) {
-            return new Comparator(comp, optionsOrLoose);
+            return new Comparator(comp, options);
         }
-        this.options = optionsOrLoose;
-        this.loose = !!optionsOrLoose.loose;
+        this.options = options;
         this.parse(comp);
         if (this.semver === ANY) {
             this.value = "";
@@ -766,7 +682,7 @@ export class Comparator {
         }
     }
     parse(comp) {
-        const r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+        const r = re[COMPARATOR];
         const m = comp.match(r);
         if (!m) {
             throw new TypeError("Invalid comparator: " + comp);
@@ -781,7 +697,7 @@ export class Comparator {
             this.semver = ANY;
         }
         else {
-            this.semver = new SemVer(m[2], this.options.loose);
+            this.semver = new SemVer(m[2], this.options);
         }
     }
     test(version) {
@@ -793,13 +709,12 @@ export class Comparator {
         }
         return cmp(version, this.operator, this.semver, this.options);
     }
-    intersects(comp, optionsOrLoose) {
+    intersects(comp, options) {
         if (!(comp instanceof Comparator)) {
             throw new TypeError("a Comparator is required");
         }
-        if (!optionsOrLoose || typeof optionsOrLoose !== "object") {
-            optionsOrLoose = {
-                loose: !!optionsOrLoose,
+        if (typeof options !== "object") {
+            options = {
                 includePrerelease: false,
             };
         }
@@ -808,15 +723,15 @@ export class Comparator {
             if (this.value === "") {
                 return true;
             }
-            rangeTmp = new Range(comp.value, optionsOrLoose);
-            return satisfies(this.value, rangeTmp, optionsOrLoose);
+            rangeTmp = new Range(comp.value, options);
+            return satisfies(this.value, rangeTmp, options);
         }
         else if (comp.operator === "") {
             if (comp.value === "") {
                 return true;
             }
-            rangeTmp = new Range(this.value, optionsOrLoose);
-            return satisfies(comp.semver, rangeTmp, optionsOrLoose);
+            rangeTmp = new Range(this.value, options);
+            return satisfies(comp.semver, rangeTmp, options);
         }
         const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") &&
             (comp.operator === ">=" || comp.operator === ">");
@@ -825,10 +740,10 @@ export class Comparator {
         const sameSemVer = this.semver.version === comp.semver.version;
         const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") &&
             (comp.operator === ">=" || comp.operator === "<=");
-        const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, optionsOrLoose) &&
+        const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) &&
             (this.operator === ">=" || this.operator === ">") &&
             (comp.operator === "<=" || comp.operator === "<");
-        const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, optionsOrLoose) &&
+        const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) &&
             (this.operator === "<=" || this.operator === "<") &&
             (comp.operator === ">=" || comp.operator === ">");
         return (sameDirectionIncreasing ||
@@ -842,7 +757,7 @@ export class Comparator {
     }
 }
 export class Range {
-    constructor(range, optionsOrLoose) {
+    constructor(range, options) {
         Object.defineProperty(this, "range", {
             enumerable: true,
             configurable: true,
@@ -855,12 +770,6 @@ export class Range {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "loose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
@@ -879,30 +788,27 @@ export class Range {
             writable: true,
             value: void 0
         });
-        if (!optionsOrLoose || typeof optionsOrLoose !== "object") {
-            optionsOrLoose = {
-                loose: !!optionsOrLoose,
+        if (typeof options !== "object") {
+            options = {
                 includePrerelease: false,
             };
         }
         if (range instanceof Range) {
-            if (range.loose === !!optionsOrLoose.loose &&
-                range.includePrerelease === !!optionsOrLoose.includePrerelease) {
+            if (range.includePrerelease === !!options.includePrerelease) {
                 return range;
             }
             else {
-                return new Range(range.raw, optionsOrLoose);
+                return new Range(range.raw, options);
             }
         }
         if (range instanceof Comparator) {
-            return new Range(range.value, optionsOrLoose);
+            return new Range(range.value, options);
         }
         if (!(this instanceof Range)) {
-            return new Range(range, optionsOrLoose);
+            return new Range(range, options);
         }
-        this.options = optionsOrLoose;
-        this.loose = !!optionsOrLoose.loose;
-        this.includePrerelease = !!optionsOrLoose.includePrerelease;
+        this.options = options;
+        this.includePrerelease = !!options.includePrerelease;
         // First, split based on boolean or ||
         this.raw = range;
         this.set = range
@@ -925,57 +831,43 @@ export class Range {
         return this.range;
     }
     parseRange(range) {
-        const loose = this.options.loose;
         range = range.trim();
         // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-        const hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+        const hr = 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
+        const set = range
             .split(" ")
             .map((comp) => parseComparator(comp, this.options))
             .join(" ")
             .split(/\s+/);
-        if (this.options.loose) {
-            // in loose mode, throw out any that are not valid comparators
-            set = set.filter((comp) => {
-                return !!comp.match(compRe);
-            });
-        }
         return set.map((comp) => new Comparator(comp, this.options));
     }
     test(version) {
         if (typeof version === "string") {
             version = new SemVer(version, this.options);
         }
-        for (var i = 0; i < this.set.length; i++) {
+        for (let i = 0; i < this.set.length; i++) {
             if (testSet(this.set[i], version, this.options)) {
                 return true;
             }
         }
         return false;
     }
-    intersects(range, optionsOrLoose) {
+    intersects(range, options) {
         if (!(range instanceof Range)) {
             throw new TypeError("a Range is required");
         }
         return this.set.some((thisComparators) => {
-            return (isSatisfiable(thisComparators, optionsOrLoose) &&
+            return (isSatisfiable(thisComparators, options) &&
                 range.set.some((rangeComparators) => {
-                    return (isSatisfiable(rangeComparators, optionsOrLoose) &&
+                    return (isSatisfiable(rangeComparators, options) &&
                         thisComparators.every((thisComparator) => {
                             return rangeComparators.every((rangeComparator) => {
-                                return thisComparator.intersects(rangeComparator, optionsOrLoose);
+                                return thisComparator.intersects(rangeComparator, options);
                             });
                         }));
                 }));
@@ -1030,8 +922,8 @@ function isSatisfiable(comparators, options) {
     return result;
 }
 // Mostly just for testing and legacy API reasons
-export function toComparators(range, optionsOrLoose) {
-    return new Range(range, optionsOrLoose).set.map((comp) => {
+export function toComparators(range, options) {
+    return new Range(range, options).set.map((comp) => {
         return comp
             .map((c) => c.value)
             .join(" ")
@@ -1065,8 +957,8 @@ function replaceTildes(comp, options) {
         .map((comp) => replaceTilde(comp, options))
         .join(" ");
 }
-function replaceTilde(comp, options) {
-    const r = options.loose ? re[TILDELOOSE] : re[TILDE];
+function replaceTilde(comp, _options) {
+    const r = re[TILDE];
     return comp.replace(r, (_, M, m, p, pr) => {
         let ret;
         if (isX(M)) {
@@ -1114,8 +1006,8 @@ function replaceCarets(comp, options) {
         .map((comp) => replaceCaret(comp, options))
         .join(" ");
 }
-function replaceCaret(comp, options) {
-    const r = options.loose ? re[CARETLOOSE] : re[CARET];
+function replaceCaret(comp, _options) {
+    const r = re[CARET];
     return comp.replace(r, (_, M, m, p, pr) => {
         let ret;
         if (isX(M)) {
@@ -1194,10 +1086,10 @@ function replaceXRanges(comp, options) {
         .map((comp) => replaceXRange(comp, options))
         .join(" ");
 }
-function replaceXRange(comp, options) {
+function replaceXRange(comp, _options) {
     comp = comp.trim();
-    const r = options.loose ? re[XRANGELOOSE] : re[XRANGE];
-    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    const r = re[XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, _pr) => {
         const xM = isX(M);
         const xm = xM || isX(m);
         const xp = xm || isX(p);
@@ -1261,8 +1153,7 @@ function replaceXRange(comp, options) {
 }
 // Because * is AND-ed with everything else in the comparator,
 // and '' means "any version", just remove the *s entirely.
-function replaceStars(comp, options) {
-    // Looseness is ignored here.  star is always as loose as it gets!
+function replaceStars(comp, _options) {
     return comp.trim().replace(re[STAR], "");
 }
 // This function is passed to string.replace(re[HYPHENRANGE])
@@ -1270,7 +1161,7 @@ function replaceStars(comp, options) {
 // 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, tb) {
+function hyphenReplace(_$0, from, fM, fm, fp, _fpr, _fb, to, tM, tm, tp, tpr, _tb) {
     if (isX(fM)) {
         from = "";
     }
@@ -1300,23 +1191,29 @@ function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
     }
     return (from + " " + to).trim();
 }
-export function satisfies(version, range, optionsOrLoose) {
+/** Returns true if the version satisfies the range. */
+export function satisfies(version, range, options) {
     try {
-        range = new Range(range, optionsOrLoose);
+        range = new Range(range, options);
     }
-    catch (er) {
+    catch {
         return false;
     }
     return range.test(version);
 }
-export function maxSatisfying(versions, range, optionsOrLoose) {
+/**
+ * Returns the highest version in the list that satisfies the range, or `null`
+ * if none of them do.
+ */
+export function maxSatisfying(versions, range, options) {
     //todo
-    var max = null;
-    var maxSV = null;
+    let max = null;
+    let maxSV = null;
+    let rangeObj;
     try {
-        var rangeObj = new Range(range, optionsOrLoose);
+        rangeObj = new Range(range, options);
     }
-    catch (er) {
+    catch {
         return null;
     }
     versions.forEach((v) => {
@@ -1325,20 +1222,25 @@ export function maxSatisfying(versions, range, optionsOrLoose) {
             if (!max || (maxSV && maxSV.compare(v) === -1)) {
                 // compare(max, v, true)
                 max = v;
-                maxSV = new SemVer(max, optionsOrLoose);
+                maxSV = new SemVer(max, options);
             }
         }
     });
     return max;
 }
-export function minSatisfying(versions, range, optionsOrLoose) {
+/**
+ * Returns the lowest version in the list that satisfies the range, or `null` if
+ * none of them do.
+ */
+export function minSatisfying(versions, range, options) {
     //todo
-    var min = null;
-    var minSV = null;
+    let min = null;
+    let minSV = null;
+    let rangeObj;
     try {
-        var rangeObj = new Range(range, optionsOrLoose);
+        rangeObj = new Range(range, options);
     }
-    catch (er) {
+    catch {
         return null;
     }
     versions.forEach((v) => {
@@ -1347,15 +1249,16 @@ export function minSatisfying(versions, range, optionsOrLoose) {
             if (!min || minSV.compare(v) === 1) {
                 // compare(min, v, true)
                 min = v;
-                minSV = new SemVer(min, optionsOrLoose);
+                minSV = new SemVer(min, options);
             }
         }
     });
     return min;
 }
-export function minVersion(range, optionsOrLoose) {
-    range = new Range(range, optionsOrLoose);
-    var minver = new SemVer("0.0.0");
+/** Returns the lowest version that can possibly match the given range. */
+export function minVersion(range, options) {
+    range = new Range(range, options);
+    let minver = new SemVer("0.0.0");
     if (range.test(minver)) {
         return minver;
     }
@@ -1364,11 +1267,11 @@ export function minVersion(range, optionsOrLoose) {
         return minver;
     }
     minver = null;
-    for (var i = 0; i < range.set.length; ++i) {
-        var comparators = range.set[i];
+    for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
         comparators.forEach((comparator) => {
             // Clone to avoid manipulating the comparator's semver object.
-            var compver = new SemVer(comparator.semver.version);
+            const compver = new SemVer(comparator.semver.version);
             switch (comparator.operator) {
                 case ">":
                     if (compver.prerelease.length === 0) {
@@ -1400,37 +1303,39 @@ export function minVersion(range, optionsOrLoose) {
     }
     return null;
 }
-export function validRange(range, optionsOrLoose) {
+/** Returns the valid range or null if it's not valid. */
+export function validRange(range, options) {
     try {
         if (range === null)
             return null;
         // Return '*' instead of '' so that truthiness works.
         // This will throw if it's invalid anyway
-        return new Range(range, optionsOrLoose).range || "*";
+        return new Range(range, options).range || "*";
     }
-    catch (er) {
+    catch {
         return null;
     }
 }
 /**
- * Return true if version is less than all the versions possible in the range.
+ * Returns true if version is less than all the versions possible in the range.
  */
-export function ltr(version, range, optionsOrLoose) {
-    return outside(version, range, "<", optionsOrLoose);
+export function ltr(version, range, options) {
+    return outside(version, range, "<", options);
 }
 /**
- * Return true if version is greater than all the versions possible in the range.
+ * Returns true if version is greater than all the versions possible in the range.
  */
-export function gtr(version, range, optionsOrLoose) {
-    return outside(version, range, ">", optionsOrLoose);
+export function gtr(version, range, options) {
+    return outside(version, range, ">", options);
 }
 /**
- * Return true if the version is outside the bounds of the range in either the high or low direction.
- * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
+ * Returns true if the version is outside the bounds of the range in either the
+ * high or low direction. The hilo argument must be either the string '>' or
+ * '<'. (This is the function called by {@linkcode gtr} and {@linkcode ltr}.)
  */
-export function outside(version, range, hilo, optionsOrLoose) {
-    version = new SemVer(version, optionsOrLoose);
-    range = new Range(range, optionsOrLoose);
+export function outside(version, range, hilo, options) {
+    version = new SemVer(version, options);
+    range = new Range(range, options);
     let gtfn;
     let ltefn;
     let ltfn;
@@ -1455,7 +1360,7 @@ export function outside(version, range, hilo, optionsOrLoose) {
             throw new TypeError('Must provide a hilo val of "<" or ">"');
     }
     // If it satisifes the range it is not outside
-    if (satisfies(version, range, optionsOrLoose)) {
+    if (satisfies(version, range, options)) {
         return false;
     }
     // From now on, variable terms are as if we're in "gtr" mode.
@@ -1470,10 +1375,10 @@ export function outside(version, range, hilo, optionsOrLoose) {
             }
             high = high || comparator;
             low = low || comparator;
-            if (gtfn(comparator.semver, high.semver, optionsOrLoose)) {
+            if (gtfn(comparator.semver, high.semver, options)) {
                 high = comparator;
             }
-            else if (ltfn(comparator.semver, low.semver, optionsOrLoose)) {
+            else if (ltfn(comparator.semver, low.semver, options)) {
                 low = comparator;
             }
         }
@@ -1496,32 +1401,20 @@ export function outside(version, range, hilo, optionsOrLoose) {
     }
     return true;
 }
-export function prerelease(version, optionsOrLoose) {
-    var parsed = parse(version, optionsOrLoose);
-    return parsed && parsed.prerelease.length ? parsed.prerelease : null;
-}
 /**
- * Return true if any of the ranges comparators intersect
+ * Returns an array of prerelease components, or null if none exist.
+ *
+ * @example
+ * `prerelease("1.2.3-alpha.1") -> ["alpha", 1]`
  */
-export function intersects(range1, range2, optionsOrLoose) {
-    range1 = new Range(range1, optionsOrLoose);
-    range2 = new Range(range2, optionsOrLoose);
-    return range1.intersects(range2);
+export function prerelease(version, options) {
+    const parsed = parse(version, options);
+    return parsed && parsed.prerelease.length ? parsed.prerelease : null;
 }
-/**
- * Coerces a string to semver if possible
- */
-export function coerce(version, optionsOrLoose) {
-    if (version instanceof SemVer) {
-        return version;
-    }
-    if (typeof version !== "string") {
-        return null;
-    }
-    const match = version.match(re[COERCE]);
-    if (match == null) {
-        return null;
-    }
-    return parse(match[1] + "." + (match[2] || "0") + "." + (match[3] || "0"), optionsOrLoose);
+/** Returns true if the two supplied ranges or comparators intersect. */
+export function intersects(range1, range2, options) {
+    range1 = new Range(range1, options);
+    range2 = new Range(range2, options);
+    return range1.intersects(range2);
 }
 export default SemVer;