@fedify/fedify 0.5.0-dev.88

package/esm/deps/jsr.io/@std/semver/0.220.1/parse_range.js

@@ -0,0 +1,336 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import { COMPARATOR_REGEXP, OPERATOR_XRANGE_REGEXP, parseBuild, parseNumber, parsePrerelease, XRANGE, } from "./_shared.js";
+import { ALL, ANY, NONE } from "./constants.js";
+function parseComparator(comparator) {
+    const match = comparator.match(COMPARATOR_REGEXP);
+    const groups = match?.groups;
+    if (!groups)
+        return NONE;
+    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"),
+            prerelease: prerelease ? parsePrerelease(prerelease) : [],
+            build: buildmetadata ? parseBuild(buildmetadata) : [],
+        }
+        : ANY;
+    return { operator: operator || undefined, ...semver, semver };
+}
+function isWildcard(id) {
+    return !id || id.toLowerCase() === "x" || id === "*";
+}
+function handleLeftHyphenRangeGroups(leftGroup) {
+    if (isWildcard(leftGroup.major))
+        return;
+    if (isWildcard(leftGroup.minor)) {
+        return {
+            operator: ">=",
+            major: +leftGroup.major,
+            minor: 0,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (isWildcard(leftGroup.patch)) {
+        return {
+            operator: ">=",
+            major: +leftGroup.major,
+            minor: +leftGroup.minor,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    return {
+        operator: ">=",
+        major: +leftGroup.major,
+        minor: +leftGroup.minor,
+        patch: +leftGroup.patch,
+        prerelease: leftGroup.prerelease
+            ? parsePrerelease(leftGroup.prerelease)
+            : [],
+        build: [],
+    };
+}
+function handleRightHyphenRangeGroups(rightGroups) {
+    if (isWildcard(rightGroups.major)) {
+        return;
+    }
+    if (isWildcard(rightGroups.minor)) {
+        return {
+            operator: "<",
+            major: +rightGroups.major + 1,
+            minor: 0,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (isWildcard(rightGroups.patch)) {
+        return {
+            operator: "<",
+            major: +rightGroups.major,
+            minor: +rightGroups.minor + 1,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (rightGroups.prerelease) {
+        return {
+            operator: "<=",
+            major: +rightGroups.major,
+            minor: +rightGroups.minor,
+            patch: +rightGroups.patch,
+            prerelease: parsePrerelease(rightGroups.prerelease),
+            build: [],
+        };
+    }
+    return {
+        operator: "<=",
+        major: +rightGroups.major,
+        minor: +rightGroups.minor,
+        patch: +rightGroups.patch,
+        prerelease: rightGroups.prerelease
+            ? parsePrerelease(rightGroups.prerelease)
+            : [],
+        build: [],
+    };
+}
+function parseHyphenRange(range) {
+    const leftMatch = range.match(new RegExp(`^${XRANGE}`));
+    const leftGroup = leftMatch?.groups;
+    if (!leftGroup)
+        return;
+    const leftLength = leftMatch[0].length;
+    const hyphenMatch = range.slice(leftLength).match(/^\s+-\s+/);
+    if (!hyphenMatch)
+        return;
+    const hyphenLength = hyphenMatch[0].length;
+    const rightMatch = range.slice(leftLength + hyphenLength).match(new RegExp(`^${XRANGE}\\s*$`));
+    const rightGroups = rightMatch?.groups;
+    if (!rightGroups)
+        return;
+    const from = handleLeftHyphenRangeGroups(leftGroup);
+    const to = handleRightHyphenRangeGroups(rightGroups);
+    return [from, to].filter(Boolean);
+}
+function handleCaretOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        if (major === 0) {
+            return [
+                { operator: ">=", major, minor, patch: 0 },
+                { operator: "<", major, minor: minor + 1, patch: 0 },
+            ];
+        }
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    if (major === 0) {
+        if (minor === 0) {
+            return [
+                { operator: ">=", major, minor, patch, prerelease },
+                { operator: "<", major, minor, patch: patch + 1 },
+            ];
+        }
+        return [
+            { operator: ">=", major, minor, patch, prerelease },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    return [
+        { operator: ">=", major, minor, patch, prerelease },
+        { operator: "<", major: major + 1, minor: 0, patch: 0 },
+    ];
+}
+function handleTildeOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    return [
+        { operator: ">=", major, minor, patch, prerelease },
+        { operator: "<", major, minor: minor + 1, patch: 0 },
+    ];
+}
+function handleLessThanOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
+    if (minorIsWildcard) {
+        if (patchIsWildcard)
+            return [{ operator: "<", major, minor: 0, patch: 0 }];
+        return [{ operator: "<", major, minor, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: "<", major, minor, patch: 0 }];
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: "<", major, minor, patch, prerelease, build }];
+}
+function handleLessThanOrEqualOperator(groups) {
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (minorIsWildcard) {
+        if (patchIsWildcard) {
+            return [{ operator: "<", major: major + 1, minor: 0, patch: 0 }];
+        }
+        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
+    }
+    if (patchIsWildcard) {
+        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: "<=", major, minor, patch, prerelease, build }];
+}
+function handleGreaterThanOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
+    if (minorIsWildcard) {
+        return [{ operator: ">=", major: major + 1, minor: 0, patch: 0 }];
+    }
+    if (patchIsWildcard) {
+        return [{ operator: ">=", major, minor: minor + 1, patch: 0 }];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: ">", major, minor, patch, prerelease, build }];
+}
+function handleGreaterOrEqualOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        if (patchIsWildcard)
+            return [{ operator: ">=", major, minor: 0, patch: 0 }];
+        return [{ operator: ">=", major, minor, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: ">=", major, minor, patch: 0 }];
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: ">=", major, minor, patch, prerelease, build }];
+}
+function handleEqualOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: undefined, major, minor, patch, prerelease, build }];
+}
+function parseOperatorRange(string) {
+    const groups = string.match(OPERATOR_XRANGE_REGEXP)
+        ?.groups;
+    if (!groups)
+        return parseComparator(string);
+    switch (groups.operator) {
+        case "^":
+            return handleCaretOperator(groups);
+        case "~":
+        case "~>":
+            return handleTildeOperator(groups);
+        case "<":
+            return handleLessThanOperator(groups);
+        case "<=":
+            return handleLessThanOrEqualOperator(groups);
+        case ">":
+            return handleGreaterThanOperator(groups);
+        case ">=":
+            return handleGreaterOrEqualOperator(groups);
+        case "=":
+        case "":
+            return handleEqualOperator(groups);
+        default:
+            throw new Error(`'${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.
+ * @param range The range set string
+ * @returns A valid semantic range
+ */
+export function parseRange(range) {
+    return range
+        // remove spaces between operators and versions
+        .replaceAll(/(?<=<|>|=) +/g, "")
+        .split(/\s*\|\|\s*/)
+        .map((string) => parseHyphenRange(string) || parseOperatorRanges(string));
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_intersects.d.ts

@@ -0,0 +1,9 @@
+import type { Range } from "./types.js";
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+export declare function rangeIntersects(r0: Range, r1: Range): boolean;
+//# sourceMappingURL=range_intersects.d.ts.map

package/esm/deps/jsr.io/@std/semver/0.220.1/range_intersects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range_intersects.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.220.1/range_intersects.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AA8DpD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,KAAK,EACT,EAAE,EAAE,KAAK,GACR,OAAO,CAST"}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_intersects.js

@@ -0,0 +1,72 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+import { testRange } from "./test_range.js";
+function comparatorIntersects(c0, c1) {
+    const op0 = c0.operator;
+    const op1 = c1.operator;
+    if (op0 === undefined) {
+        // if c0 is empty comparator, then returns true
+        if (isWildcardComparator(c0))
+            return true;
+        return testRange(c0, [[c1]]);
+    }
+    if (op1 === undefined) {
+        if (isWildcardComparator(c1))
+            return true;
+        return testRange(c1, [[c0]]);
+    }
+    const cmp = compare(c0, c1);
+    const sameDirectionIncreasing = (op0 === ">=" || op0 === ">") &&
+        (op1 === ">=" || op1 === ">");
+    const sameDirectionDecreasing = (op0 === "<=" || op0 === "<") &&
+        (op1 === "<=" || op1 === "<");
+    const sameSemVer = cmp === 0;
+    const differentDirectionsInclusive = (op0 === ">=" || op0 === "<=") &&
+        (op1 === ">=" || op1 === "<=");
+    const oppositeDirectionsLessThan = cmp === -1 &&
+        (op0 === ">=" || op0 === ">") &&
+        (op1 === "<=" || op1 === "<");
+    const oppositeDirectionsGreaterThan = cmp === 1 &&
+        (op0 === "<=" || op0 === "<") &&
+        (op1 === ">=" || op1 === ">");
+    return sameDirectionIncreasing ||
+        sameDirectionDecreasing ||
+        (sameSemVer && differentDirectionsInclusive) ||
+        oppositeDirectionsLessThan ||
+        oppositeDirectionsGreaterThan;
+}
+function rangesSatisfiable(ranges) {
+    return ranges.every((r) => {
+        // For each OR at least one AND must be satisfiable
+        return r.some((comparators) => comparatorsSatisfiable(comparators));
+    });
+}
+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)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+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));
+                });
+            });
+        });
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_max.d.ts

@@ -0,0 +1,8 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMax(range: Range): SemVer;
+//# sourceMappingURL=range_max.d.ts.map

package/esm/deps/jsr.io/@std/semver/0.220.1/range_max.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range_max.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.220.1/range_max.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAyC5D;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAU7C"}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_max.js

@@ -0,0 +1,58 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import { ANY, INVALID, MAX } from "./constants.js";
+import { testRange } from "./test_range.js";
+import { greaterThan } from "./greater_than.js";
+function comparatorMax(comparator) {
+    const semver = comparator.semver ?? comparator;
+    if (semver === ANY)
+        return MAX;
+    switch (comparator.operator) {
+        case "!=":
+        case ">":
+        case ">=":
+            return MAX;
+        case undefined:
+        case "=":
+        case "<=":
+            return {
+                major: semver.major,
+                minor: semver.minor,
+                patch: semver.patch,
+                prerelease: semver.prerelease,
+                build: semver.build,
+            };
+        case "<": {
+            const patch = semver.patch - 1;
+            const minor = patch >= 0 ? semver.minor : semver.minor - 1;
+            const major = minor >= 0 ? semver.major : semver.major - 1;
+            // if you try to do <0.0.0 it will Give you -∞.∞.∞
+            // which means no SemVer can compare successfully to it.
+            if (major < 0)
+                return INVALID;
+            return {
+                major,
+                minor: minor >= 0 ? minor : Number.POSITIVE_INFINITY,
+                patch: patch >= 0 ? patch : Number.POSITIVE_INFINITY,
+                prerelease: [],
+                build: [],
+            };
+        }
+    }
+}
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+export function rangeMax(range) {
+    let max;
+    for (const comparators of range) {
+        for (const comparator of comparators) {
+            const candidate = comparatorMax(comparator);
+            if (!testRange(candidate, range))
+                continue;
+            max = (max && greaterThan(max, candidate)) ? max : candidate;
+        }
+    }
+    return max ?? INVALID;
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_min.d.ts

@@ -0,0 +1,8 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMin(range: Range): SemVer;
+//# sourceMappingURL=range_min.d.ts.map

package/esm/deps/jsr.io/@std/semver/0.220.1/range_min.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range_min.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.220.1/range_min.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAgC5D;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAU7C"}

package/esm/deps/jsr.io/@std/semver/0.220.1/range_min.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import { ANY, INVALID, MAX, MIN } from "./constants.js";
+import { testRange } from "./test_range.js";
+import { lessThan } from "./less_than.js";
+import { greaterThan } from "./greater_than.js";
+import { increment } from "./increment.js";
+function comparatorMin(comparator) {
+    const semver = comparator.semver ?? comparator;
+    if (semver === ANY)
+        return MIN;
+    switch (comparator.operator) {
+        case ">":
+            return semver.prerelease && semver.prerelease.length > 0
+                ? increment(semver, "pre")
+                : increment(semver, "patch");
+        case "!=":
+        case "<=":
+        case "<":
+            // The min(<0.0.0) is MAX
+            return greaterThan(semver, MIN) ? MIN : MAX;
+        case ">=":
+        case undefined:
+        case "=":
+            return {
+                major: semver.major,
+                minor: semver.minor,
+                patch: semver.patch,
+                prerelease: semver.prerelease,
+                build: semver.build,
+            };
+    }
+}
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+export function rangeMin(range) {
+    let min;
+    for (const comparators of range) {
+        for (const comparator of comparators) {
+            const candidate = comparatorMin(comparator);
+            if (!testRange(candidate, range))
+                continue;
+            min = (min && lessThan(min, candidate)) ? min : candidate;
+        }
+    }
+    return min ?? INVALID;
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/test_range.d.ts

@@ -0,0 +1,9 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export declare function testRange(version: SemVer, range: Range): boolean;
+//# sourceMappingURL=test_range.d.ts.map

package/esm/deps/jsr.io/@std/semver/0.220.1/test_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.220.1/test_range.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAqE5D;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GACX,OAAO,CAET"}

package/esm/deps/jsr.io/@std/semver/0.220.1/test_range.js

@@ -0,0 +1,69 @@
+import { compare } from "./compare.js";
+import { isWildcardComparator } from "./_shared.js";
+function testComparator(version, comparator) {
+    if (isWildcardComparator(comparator)) {
+        return true;
+    }
+    const cmp = compare(version, comparator.semver ?? comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined: {
+            return cmp === 0;
+        }
+        case "!=": {
+            return cmp !== 0;
+        }
+        case ">": {
+            return cmp > 0;
+        }
+        case "<": {
+            return cmp < 0;
+        }
+        case ">=": {
+            return cmp >= 0;
+        }
+        case "<=": {
+            return cmp <= 0;
+        }
+    }
+}
+function testComparatorSet(version, set) {
+    for (const comparator of set) {
+        if (!testComparator(version, comparator)) {
+            return false;
+        }
+    }
+    if (version.prerelease && version.prerelease.length > 0) {
+        // Find the comparator that is 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 (const comparator of set) {
+            if (isWildcardComparator(comparator)) {
+                continue;
+            }
+            const { prerelease } = comparator.semver ?? comparator;
+            if (prerelease && prerelease.length > 0) {
+                const major = comparator.semver?.major ?? comparator.major;
+                const minor = comparator.semver?.minor ?? comparator.minor;
+                const patch = comparator.semver?.patch ?? comparator.patch;
+                if (version.major === major && version.minor === minor &&
+                    version.patch === patch) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export function testRange(version, range) {
+    return range.some((set) => testComparatorSet(version, set));
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/try_parse.d.ts

@@ -0,0 +1,8 @@
+import type { SemVer } from "./types.js";
+/**
+ * Returns the parsed version, or undefined if it's not valid.
+ * @param version The version string to parse
+ * @returns A valid SemVer or `undefined`
+ */
+export declare function tryParse(version?: string): SemVer | undefined;
+//# sourceMappingURL=try_parse.d.ts.map

package/esm/deps/jsr.io/@std/semver/0.220.1/try_parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try_parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.220.1/try_parse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS7D"}

package/esm/deps/jsr.io/@std/semver/0.220.1/try_parse.js

@@ -0,0 +1,17 @@
+import { parse } from "./parse.js";
+/**
+ * Returns the parsed version, or undefined if it's not valid.
+ * @param version The version string to parse
+ * @returns A valid SemVer or `undefined`
+ */
+export function tryParse(version) {
+    if (version === undefined) {
+        return undefined;
+    }
+    try {
+        return parse(version);
+    }
+    catch {
+        return undefined;
+    }
+}

package/esm/deps/jsr.io/@std/semver/0.220.1/try_parse_range.d.ts

@@ -0,0 +1,8 @@
+import type { Range } from "./types.js";
+/**
+ * A tries to parse a valid Range string or returns undefined
+ * @param range The range string
+ * @returns A Range object if valid otherwise `undefined`
+ */
+export declare function tryParseRange(range: string): Range | undefined;
+//# sourceMappingURL=try_parse_range.d.ts.map