@fedify/fedify 1.0.0-dev.410 → 1.0.0-dev.412

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/increment.js

@@ -29,7 +29,7 @@ function bumpPrerelease(prerelease = [], identifier) {
     return values;
 }
 /**
- * Returns the new version resulting from an increment by release type.
+ * Returns the new SemVer resulting from an increment by release type.
  *
  * `premajor`, `preminor` and `prepatch` will bump the version up to the next version,
  * based on the type, and will also add prerelease metadata.
@@ -52,7 +52,7 @@ function bumpPrerelease(prerelease = [], identifier) {
  * @example Usage
  * ```ts
  * import { increment, parse } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const version = parse("1.2.3");
  * assertEquals(increment(version, "major"), parse("2.0.0"));
@@ -66,21 +66,20 @@ function bumpPrerelease(prerelease = [], identifier) {
  *
  * @param version The version to increment
  * @param release The type of increment to perform
- * @param prerelease The pre-release metadata of the new version
- * @param buildmetadata The build metadata of the new version
+ * @param options Additional options
  * @returns The new version
  */
-export function increment(version, release, prerelease, buildmetadata) {
-    const build = buildmetadata !== undefined
-        ? parseBuild(buildmetadata)
-        : version.build;
+export function increment(version, release, options = {}) {
+    const build = options.build !== undefined
+        ? parseBuild(options.build)
+        : version.build ?? [];
     switch (release) {
         case "premajor":
             return {
                 major: version.major + 1,
                 minor: 0,
                 patch: 0,
-                prerelease: bumpPrerelease(version.prerelease, prerelease),
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
                 build,
             };
         case "preminor":
@@ -88,7 +87,7 @@ export function increment(version, release, prerelease, buildmetadata) {
                 major: version.major,
                 minor: version.minor + 1,
                 patch: 0,
-                prerelease: bumpPrerelease(version.prerelease, prerelease),
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
                 build,
             };
         case "prepatch":
@@ -96,7 +95,7 @@ export function increment(version, release, prerelease, buildmetadata) {
                 major: version.major,
                 minor: version.minor,
                 patch: version.patch + 1,
-                prerelease: bumpPrerelease(version.prerelease, prerelease),
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
                 build,
             };
         case "prerelease": {
@@ -107,7 +106,7 @@ export function increment(version, release, prerelease, buildmetadata) {
                 major: version.major,
                 minor: version.minor,
                 patch,
-                prerelease: bumpPrerelease(version.prerelease, prerelease),
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
                 build,
             };
         }
@@ -167,11 +166,11 @@ export function increment(version, release, prerelease, buildmetadata) {
                 major: version.major,
                 minor: version.minor,
                 patch: version.patch,
-                prerelease: bumpPrerelease(version.prerelease, prerelease),
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
                 build,
             };
         }
         default:
-            throw new Error(`invalid increment argument: ${release}`);
+            throw new TypeError(`Cannot increment version: invalid argument ${release}`);
     }
 }

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/is_range.js

@@ -1,11 +1,11 @@
 import { OPERATORS } from "./_constants.js";
-import { ALL, NONE } from "./constants.js";
+import { ALL } from "./_constants.js";
 import { isSemVer } from "./is_semver.js";
 function isComparator(value) {
     if (value === null || value === undefined || Array.isArray(value) ||
         typeof value !== "object")
         return false;
-    if (value === NONE || value === ALL)
+    if (value === ALL)
         return true;
     const { operator } = value;
     return ((operator === undefined ||
@@ -23,11 +23,11 @@ function isComparator(value) {
  * @example Usage
  * ```ts
  * import { isRange } from "@std/semver/is-range";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const range = [[{ major: 1, minor: 2, patch: 3 }]];
  * assert(isRange(range));
- * assertFalse(isRange({}));
+ * assert(!isRange({}));
  * ```
  * @param value The value to check if its a valid Range
  * @returns True if its a valid Range otherwise false.

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/is_semver.js

@@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import { ANY, INVALID } from "./constants.js";
+import { ANY } from "./_constants.js";
 import { isValidNumber, isValidString } from "./_shared.js";
 /**
  * Checks to see if value is a valid SemVer object. It does a check
@@ -18,7 +18,7 @@ import { isValidNumber, isValidString } from "./_shared.js";
  * @example Usage
  * ```ts
  * import { isSemVer } from "@std/semver/is-semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const value = {
  *   major: 1,
@@ -27,7 +27,7 @@ import { isValidNumber, isValidString } from "./_shared.js";
  * };
  *
  * assert(isSemVer(value));
- * assertFalse(isSemVer({ major: 1, minor: 2 }));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
  * ```
  *
  * @param value The value to check to see if its a valid SemVer object
@@ -40,8 +40,6 @@ export function isSemVer(value) {
         return false;
     if (typeof value !== "object")
         return false;
-    if (value === INVALID)
-        return true;
     if (value === ANY)
         return true;
     const { major, minor, patch, build = [], prerelease = [], } = value;

package/esm/deps/jsr.io/@std/semver/1.0.3/less_or_equal.js

@@ -0,0 +1,26 @@
+import { compare } from "./compare.js";
+/**
+ * Less than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) <= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessOrEqual(version1, version2));
+ * assert(!lessOrEqual(version2, version1));
+ * assert(lessOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than or equal to `version2`, `false` otherwise
+ */
+export function lessOrEqual(version1, version2) {
+    return compare(version1, version2) <= 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/less_than.js

@@ -0,0 +1,26 @@
+import { compare } from "./compare.js";
+/**
+ * Less than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) < 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessThan(version1, version2));
+ * assert(!lessThan(version2, version1));
+ * assert(!lessThan(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than `version2`, `false` otherwise
+ */
+export function lessThan(version1, version2) {
+    return compare(version1, version2) < 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/less_than_range.js

@@ -9,36 +9,37 @@ import { compare } from "./compare.js";
  * @example Usage
  * ```ts
  * import { parse, parseRange, lessThanRange } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
- * const v0 = parse("1.2.3");
- * const v1 = parse("1.0.0");
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.0.0");
  * const range = parseRange(">=1.2.3 <1.2.4");
- * assertFalse(lessThanRange(v0, range));
- * assert(lessThanRange(v1, range));
+ *
+ * assert(!lessThanRange(version1, range));
+ * assert(lessThanRange(version2, range));
  * ```
  *
- * @param semver The version to check.
+ * @param version The version to check.
  * @param range The range to check against.
  * @returns `true` if the SemVer is less than the range, `false` otherwise.
  */
-export function lessThanRange(semver, range) {
-    return range.every((comparatorSet) => lessThanComparatorSet(semver, comparatorSet));
+export function lessThanRange(version, range) {
+    return range.every((comparatorSet) => lessThanComparatorSet(version, comparatorSet));
 }
-function lessThanComparatorSet(semver, comparatorSet) {
+function lessThanComparatorSet(version, comparatorSet) {
     // If the comparator set contains wildcard, then the semver is not greater than the range.
     if (comparatorSet.some(isWildcardComparator))
         return false;
     // If the SemVer satisfies the comparator set, then it's not less than the range.
-    if (testComparatorSet(semver, comparatorSet))
+    if (testComparatorSet(version, comparatorSet))
         return false;
     // If the SemVer is greater than any of the comparator set, then it's not less than the range.
-    if (comparatorSet.some((comparator) => greaterThanComparator(semver, comparator)))
+    if (comparatorSet.some((comparator) => greaterThanComparator(version, comparator)))
         return false;
     return true;
 }
-function greaterThanComparator(semver, comparator) {
-    const cmp = compare(semver, comparator);
+function greaterThanComparator(version, comparator) {
+    const cmp = compare(version, comparator);
     switch (comparator.operator) {
         case "=":
         case undefined:

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/max_satisfying.js

@@ -1,13 +1,13 @@
 import { satisfies } from "./satisfies.js";
 import { greaterThan } from "./greater_than.js";
 /**
- * Returns the highest version in the list that satisfies the range, or `undefined`
+ * Returns the highest SemVer in the list that satisfies the range, or `undefined`
  * if none of them do.
  *
  * @example Usage
  * ```ts
  * import { parse, parseRange, maxSatisfying } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const versions = ["1.2.3", "1.2.4", "1.3.0", "2.0.0", "2.1.0"].map(parse);
  * const range = parseRange(">=1.0.0 <2.0.0");

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/min_satisfying.js

@@ -1,13 +1,13 @@
 import { satisfies } from "./satisfies.js";
 import { lessThan } from "./less_than.js";
 /**
- * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * Returns the lowest SemVer in the list that satisfies the range, or `undefined` if
  * none of them do.
  *
  * @example Usage
  * ```ts
  * import { parse, parseRange, minSatisfying } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const versions = ["0.2.0", "1.2.3", "1.3.0", "2.0.0", "2.1.0"].map(parse);
  * const range = parseRange(">=1.0.0 <2.0.0");

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/mod.js

@@ -14,7 +14,7 @@
  *   lessThan,
  *   format
  * } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const semver = parse("1.2.3");
  * assertEquals(semver, {
@@ -50,28 +50,28 @@
  * formatting options.
  *
  * ```
- *           ┌───── full
- *       ┌───┴───┐
- *       ├───────── release
- *   ┌───┴───┐   │
- *   ├───────────── primary
- * ┌─┴─┐     │   │
- * 1.2.3-pre.1+b.1
- * │ │ │ └─┬─┘ └┬┘
- * │ │ │   │    └── build
- * │ │ │   └─────── pre
- * │ │ └─────────── patch
- * │ └───────────── minor
- * └─────────────── major
+ *           full
+ *        ┌───┴───┐
+ *     release    │
+ *    ┌───┴───┐   │
+ * primary    │   │
+ *  ┌─┴─┐     │   │
+ *  1.2.3-pre.1+b.1
+ *  │ │ │ └─┬─┘ └┬┘
+ *  │ │ │   │    └── build
+ *  │ │ │   └─────── pre
+ *  │ │ └─────────── patch
+ *  │ └───────────── minor
+ *  └─────────────── major
  * ```
  *
  * ## Ranges
  *
- * A `version range` is a set of `comparators` which specify versions that satisfy
- * the range.
+ * A version {@linkcode Range} is a set of {@linkcode Comparator}s which specify
+ * versions that satisfy the range.
  *
- * A `comparator` is composed of an `operator` and a `version`. The set of
- * primitive `operators` is:
+ * A {@linkcode Comparator} is composed of an {@linkcode Operator} and a
+ * {@link SemVer}. The set of primitive `operators` is:
  *
  * - `<` Less than
  * - `<=` Less than or equal to
@@ -122,12 +122,14 @@
  *
  * #### Prerelease Identifiers
  *
- * The method `.increment` takes an additional `identifier` string argument that
- * will append the value of the string as a prerelease identifier:
+ * The method {@linkcode increment} takes an additional `identifier` string
+ * argument that will append the value of the string as a prerelease identifier:
  *
- * ```javascript
- * semver.increment(parse("1.2.3"), "prerelease", "beta");
- * // "1.2.4-beta.0"
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(increment(parse("1.2.3"), "prerelease", { prerelease: "alpha" }), parse("1.2.4-alpha.0"));
  * ```
  *
  * ### Build Metadata
@@ -268,18 +270,12 @@
  *
  * If you want to know if a version satisfies or does not satisfy a range, use the
  * {@linkcode satisfies} function.
- *
- *
- *
-
  *
  * @module
  */
 export * from "./compare.js";
-export * from "./constants.js";
 export * from "./difference.js";
 export * from "./format.js";
-export * from "./test_range.js";
 export * from "./satisfies.js";
 export * from "./increment.js";
 export * from "./is_semver.js";
@@ -288,8 +284,6 @@ export * from "./min_satisfying.js";
 export * from "./parse_range.js";
 export * from "./parse.js";
 export * from "./range_intersects.js";
-export * from "./range_max.js";
-export * from "./range_min.js";
 export * from "./types.js";
 export * from "./try_parse_range.js";
 export * from "./is_range.js";
@@ -304,5 +298,3 @@ export * from "./greater_or_equal.js";
 export * from "./less_than.js";
 export * from "./less_than_range.js";
 export * from "./less_or_equal.js";
-/** The SemVer spec version */
-export const SEMVER_SPEC_VERSION = "2.0.0";

package/esm/deps/jsr.io/@std/semver/1.0.3/not_equals.js

@@ -0,0 +1,25 @@
+import { compare } from "./compare.js";
+/**
+ * Not equal comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) !== 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, notEquals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(notEquals(version1, version2));
+ * assert(!notEquals(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is not equal to `version2`, `false` otherwise
+ */
+export function notEquals(version1, version2) {
+    return compare(version1, version2) !== 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/parse.js

@@ -0,0 +1,44 @@
+import { parseBuild, parseNumber, parsePrerelease } from "./_shared.js";
+import { FULL_REGEXP, MAX_LENGTH } from "./_shared.js";
+/**
+ * Attempt to parse a string as a semantic version, returning a SemVer object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/semver/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(version, {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ *   prerelease: [],
+ *   build: [],
+ * });
+ * ```
+ *
+ * @throws {TypeError} If the input string is invalid.
+ * @param value The version string to parse
+ * @returns A valid SemVer
+ */
+export function parse(value) {
+    if (typeof value !== "string") {
+        throw new TypeError(`Cannot parse version as version must be a string: received ${typeof value}`);
+    }
+    if (value.length > MAX_LENGTH) {
+        throw new TypeError(`Cannot parse version as version length is too long: length is ${value.length}, max length is ${MAX_LENGTH}`);
+    }
+    value = value.trim();
+    const groups = value.match(FULL_REGEXP)?.groups;
+    if (!groups)
+        throw new TypeError(`Cannot parse version: ${value}`);
+    const major = parseNumber(groups.major, `Cannot parse version ${value}: invalid major version`);
+    const minor = parseNumber(groups.minor, `Cannot parse version ${value}: invalid minor version`);
+    const patch = parseNumber(groups.patch, `Cannot parse version ${value}: invalid patch version`);
+    const prerelease = groups.prerelease
+        ? parsePrerelease(groups.prerelease)
+        : [];
+    const build = groups.buildmetadata ? parseBuild(groups.buildmetadata) : [];
+    return { major, minor, patch, prerelease, build };
+}

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/parse_range.js

@@ -1,18 +1,18 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { COMPARATOR_REGEXP, OPERATOR_XRANGE_REGEXP, parseBuild, parseNumber, parsePrerelease, XRANGE, } from "./_shared.js";
-import { ALL, ANY, NONE } from "./constants.js";
+import { ALL, ANY } from "./_constants.js";
 function parseComparator(comparator) {
     const match = comparator.match(COMPARATOR_REGEXP);
     const groups = match?.groups;
     if (!groups)
-        return NONE;
+        return null;
     const { operator, prerelease, buildmetadata } = groups;
     const semver = groups.major
         ? {
-            major: parseNumber(groups.major, "Invalid major version"),
-            minor: parseNumber(groups.minor, "Invalid minor version"),
-            patch: parseNumber(groups.patch, "Invalid patch version"),
+            major: parseNumber(groups.major, `Cannot parse comparator ${comparator}: invalid major version`),
+            minor: parseNumber(groups.minor, `Cannot parse comparator ${comparator}: invalid minor version`),
+            patch: parseNumber(groups.patch, `Cannot parse comparator ${comparator}: invalid patch version`),
             prerelease: prerelease ? parsePrerelease(prerelease) : [],
             build: buildmetadata ? parseBuild(buildmetadata) : [],
         }
@@ -317,19 +317,19 @@ function parseOperatorRange(string) {
         case "":
             return handleEqualOperator(groups);
         default:
-            throw new Error(`'${groups.operator}' is not a valid operator.`);
+            throw new Error(`Cannot parse version range: '${groups.operator}' is not a valid operator`);
     }
 }
 function parseOperatorRanges(string) {
     return string.split(/\s+/).flatMap(parseOperatorRange);
 }
 /**
- * Parses a range string into a Range object or throws a TypeError.
+ * Parses a range string into a {@linkcode Range} object.
  *
  * @example Usage
  * ```ts
  * import { parseRange } from "@std/semver/parse-range";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const range = parseRange(">=1.0.0 <2.0.0 || >=3.0.0");
  * assertEquals(range, [
@@ -343,13 +343,18 @@ function parseOperatorRanges(string) {
  * ]);
  * ```
  *
- * @param range The range set string
- * @returns A valid semantic range
+ * @throws {TypeError} If the input range is invalid.
+ * @param value The range set string
+ * @returns A valid SemVer range
  */
-export function parseRange(range) {
-    return range
+export function parseRange(value) {
+    const result = value
         // remove spaces between operators and versions
-        .replaceAll(/(?<=<|>|=) +/g, "")
+        .replaceAll(/(?<=<|>|=|~|\^)(\s+)/g, "")
         .split(/\s*\|\|\s*/)
         .map((string) => parseHyphenRange(string) || parseOperatorRanges(string));
+    if (result.some((r) => r.includes(null))) {
+        throw new TypeError(`Cannot parse version range: range "${value}" is invalid`);
+    }
+    return result;
 }

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/range_intersects.js

@@ -3,21 +3,21 @@
 import { isWildcardComparator } from "./_shared.js";
 import { compare } from "./compare.js";
 import { satisfies } from "./satisfies.js";
-function comparatorIntersects(c0, c1) {
-    const op0 = c0.operator;
-    const op1 = c1.operator;
+function comparatorIntersects(comparator1, comparator2) {
+    const op0 = comparator1.operator;
+    const op1 = comparator2.operator;
     if (op0 === undefined) {
-        // if c0 is empty comparator, then returns true
-        if (isWildcardComparator(c0))
+        // if comparator1 is empty comparator, then returns true
+        if (isWildcardComparator(comparator1))
             return true;
-        return satisfies(c0, [[c1]]);
+        return satisfies(comparator1, [[comparator2]]);
     }
     if (op1 === undefined) {
-        if (isWildcardComparator(c1))
+        if (isWildcardComparator(comparator2))
             return true;
-        return satisfies(c1, [[c0]]);
+        return satisfies(comparator2, [[comparator1]]);
     }
-    const cmp = compare(c0, c1);
+    const cmp = compare(comparator1, comparator2);
     const sameDirectionIncreasing = (op0 === ">=" || op0 === ">") &&
         (op1 === ">=" || op1 === ">");
     const sameDirectionDecreasing = (op0 === "<=" || op0 === "<") &&
@@ -46,9 +46,9 @@ function rangesSatisfiable(ranges) {
 function comparatorsSatisfiable(comparators) {
     // Comparators are satisfiable if they all intersect with each other
     for (let i = 0; i < comparators.length - 1; i++) {
-        const c0 = comparators[i];
-        for (const c1 of comparators.slice(i + 1)) {
-            if (!comparatorIntersects(c0, c1)) {
+        const comparator1 = comparators[i];
+        for (const comparator2 of comparators.slice(i + 1)) {
+            if (!comparatorIntersects(comparator1, comparator2)) {
                 return false;
             }
         }
@@ -56,32 +56,33 @@ function comparatorsSatisfiable(comparators) {
     return true;
 }
 /**
- * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * The ranges intersect every range of AND comparators intersects with a least
+ * one range of OR ranges.
  *
  * @example Usage
  * ```ts
  * import { parseRange, rangeIntersects } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
- * const r0 = parseRange(">=1.0.0 <2.0.0");
- * const r1 = parseRange(">=1.0.0 <1.2.3");
- * const r2 = parseRange(">=1.2.3 <2.0.0");
+ * const range1 = parseRange(">=1.0.0 <2.0.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ * const range3 = parseRange(">=1.2.3 <2.0.0");
  *
- * assert(rangeIntersects(r0, r1));
- * assert(rangeIntersects(r0, r2));
- * assertFalse(rangeIntersects(r1, r2));
+ * assert(rangeIntersects(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
  * ```
  *
- * @param r0 range 0
- * @param r1 range 1
+ * @param range1 range 0
+ * @param range2 range 1
  * @returns returns true if the given ranges intersect, false otherwise
  */
-export function rangeIntersects(r0, r1) {
-    return rangesSatisfiable([r0, r1]) &&
-        r0.some((r00) => {
-            return r1.some((r11) => {
-                return r00.every((c0) => {
-                    return r11.every((c1) => comparatorIntersects(c0, c1));
+export function rangeIntersects(range1, range2) {
+    return rangesSatisfiable([range1, range2]) &&
+        range1.some((range10) => {
+            return range2.some((r11) => {
+                return range10.every((comparator1) => {
+                    return r11.every((comparator2) => comparatorIntersects(comparator1, comparator2));
                 });
             });
         });

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/satisfies.js

@@ -1,12 +1,12 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import { testComparatorSet } from "./_test_comparator_set.js";
 /**
- * Test to see if the version satisfies the range.
+ * Test to see if the SemVer satisfies the range.
  *
  * @example Usage
  * ```ts
  * import { parse, parseRange, satisfies } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const version = parse("1.2.3");
  * const range0 = parseRange(">=1.0.0 <2.0.0");
@@ -15,7 +15,7 @@ import { testComparatorSet } from "./_test_comparator_set.js";
  *
  * assert(satisfies(version, range0));
  * assert(satisfies(version, range1));
- * assertFalse(satisfies(version, range2));
+ * assert(!satisfies(version, range2));
  * ```
  * @param version The version to test
  * @param range The range to check