keep-a-changelog 2.5.3 → 2.6.1

package/script/deps/jsr.io/@std/semver/1.0.4/not_equals.d.ts

@@ -0,0 +1,24 @@
+import type { SemVer } from "./types.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 declare function notEquals(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=not_equals.d.ts.map

package/script/deps/jsr.io/@std/semver/1.0.4/not_equals.d.ts.map

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

package/script/deps/jsr.io/@std/semver/1.0.4/not_equals.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEquals = notEquals;
+const compare_js_1 = require("./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
+ */
+function notEquals(version1, version2) {
+    return (0, compare_js_1.compare)(version1, version2) !== 0;
+}

package/script/deps/jsr.io/@std/semver/1.0.4/parse.d.ts

@@ -0,0 +1,25 @@
+import type { SemVer } from "./types.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 declare function parse(value: string): SemVer;
+//# sourceMappingURL=parse.d.ts.map

package/script/deps/jsr.io/@std/semver/1.0.4/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/parse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAqC3C"}

package/script/deps/jsr.io/@std/semver/1.0.4/parse.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const _shared_js_1 = require("./_shared.js");
+const _shared_js_2 = require("./_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
+ */
+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 > _shared_js_2.MAX_LENGTH) {
+        throw new TypeError(`Cannot parse version as version length is too long: length is ${value.length}, max length is ${_shared_js_2.MAX_LENGTH}`);
+    }
+    value = value.trim();
+    const groups = value.match(_shared_js_2.FULL_REGEXP)?.groups;
+    if (!groups)
+        throw new TypeError(`Cannot parse version: ${value}`);
+    const major = (0, _shared_js_1.parseNumber)(groups.major, `Cannot parse version ${value}: invalid major version`);
+    const minor = (0, _shared_js_1.parseNumber)(groups.minor, `Cannot parse version ${value}: invalid minor version`);
+    const patch = (0, _shared_js_1.parseNumber)(groups.patch, `Cannot parse version ${value}: invalid patch version`);
+    const prerelease = groups.prerelease
+        ? (0, _shared_js_1.parsePrerelease)(groups.prerelease)
+        : [];
+    const build = groups.buildmetadata ? (0, _shared_js_1.parseBuild)(groups.buildmetadata) : [];
+    return { major, minor, patch, prerelease, build };
+}

package/script/deps/jsr.io/@std/semver/1.0.4/parse_range.d.ts

@@ -0,0 +1,27 @@
+import type { Range } from "./types.js";
+/**
+ * Parses a range string into a {@linkcode Range} object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange } from "@std/semver/parse-range";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.0.0 <2.0.0 || >=3.0.0");
+ * assertEquals(range, [
+ *   [
+ *     { operator: ">=", major: 1, minor: 0, patch: 0, prerelease: [], build: [] },
+ *     { operator: "<", major: 2, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ],
+ *   [
+ *     { operator: ">=", major: 3, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ]
+ * ]);
+ * ```
+ *
+ * @throws {TypeError} If the input range is invalid.
+ * @param value The range set string
+ * @returns A valid SemVer range
+ */
+export declare function parseRange(value: string): Range;
+//# sourceMappingURL=parse_range.d.ts.map

package/script/deps/jsr.io/@std/semver/1.0.4/parse_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/parse_range.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAwB,KAAK,EAAE,MAAM,YAAY,CAAC;AAoX9D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAY/C"}

package/script/deps/jsr.io/@std/semver/1.0.4/parse_range.js

@@ -0,0 +1,361 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRange = parseRange;
+const _shared_js_1 = require("./_shared.js");
+const _constants_js_1 = require("./_constants.js");
+function parseComparator(comparator) {
+    const match = comparator.match(_shared_js_1.COMPARATOR_REGEXP);
+    const groups = match?.groups;
+    if (!groups)
+        return null;
+    const { operator, prerelease, buildmetadata } = groups;
+    const semver = groups.major
+        ? {
+            major: (0, _shared_js_1.parseNumber)(groups.major, `Cannot parse comparator ${comparator}: invalid major version`),
+            minor: (0, _shared_js_1.parseNumber)(groups.minor, `Cannot parse comparator ${comparator}: invalid minor version`),
+            patch: (0, _shared_js_1.parseNumber)(groups.patch, `Cannot parse comparator ${comparator}: invalid patch version`),
+            prerelease: prerelease ? (0, _shared_js_1.parsePrerelease)(prerelease) : [],
+            build: buildmetadata ? (0, _shared_js_1.parseBuild)(buildmetadata) : [],
+        }
+        : _constants_js_1.ANY;
+    return { operator: operator || undefined, ...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
+            ? (0, _shared_js_1.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: (0, _shared_js_1.parsePrerelease)(rightGroups.prerelease),
+            build: [],
+        };
+    }
+    return {
+        operator: "<=",
+        major: +rightGroups.major,
+        minor: +rightGroups.minor,
+        patch: +rightGroups.patch,
+        prerelease: [],
+        build: [],
+    };
+}
+function parseHyphenRange(range) {
+    const leftMatch = range.match(new RegExp(`^${_shared_js_1.XRANGE}`));
+    const leftGroup = leftMatch?.groups;
+    if (!leftGroup)
+        return null;
+    const leftLength = leftMatch[0].length;
+    const hyphenMatch = range.slice(leftLength).match(/^\s+-\s+/);
+    if (!hyphenMatch)
+        return null;
+    const hyphenLength = hyphenMatch[0].length;
+    const rightMatch = range.slice(leftLength + hyphenLength).match(new RegExp(`^${_shared_js_1.XRANGE}\\s*$`));
+    const rightGroups = rightMatch?.groups;
+    if (!rightGroups)
+        return null;
+    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 [_constants_js_1.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 = (0, _shared_js_1.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 [_constants_js_1.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 = (0, _shared_js_1.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: 0, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: "<", major, minor, patch: 0 }];
+    const prerelease = (0, _shared_js_1.parsePrerelease)(groups.prerelease ?? "");
+    const build = (0, _shared_js_1.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 = (0, _shared_js_1.parsePrerelease)(groups.prerelease ?? "");
+    const build = (0, _shared_js_1.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 = (0, _shared_js_1.parsePrerelease)(groups.prerelease ?? "");
+    const build = (0, _shared_js_1.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 [_constants_js_1.ALL];
+    if (minorIsWildcard) {
+        if (patchIsWildcard)
+            return [{ operator: ">=", major, minor: 0, patch: 0 }];
+        return [{ operator: ">=", major, minor: 0, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: ">=", major, minor, patch: 0 }];
+    const prerelease = (0, _shared_js_1.parsePrerelease)(groups.prerelease ?? "");
+    const build = (0, _shared_js_1.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 [_constants_js_1.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 = (0, _shared_js_1.parsePrerelease)(groups.prerelease ?? "");
+    const build = (0, _shared_js_1.parseBuild)(groups.build ?? "");
+    return [{ operator: undefined, major, minor, patch, prerelease, build }];
+}
+function parseOperatorRange(string) {
+    const groups = string.match(_shared_js_1.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(`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 {@linkcode Range} object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange } from "@std/semver/parse-range";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.0.0 <2.0.0 || >=3.0.0");
+ * assertEquals(range, [
+ *   [
+ *     { operator: ">=", major: 1, minor: 0, patch: 0, prerelease: [], build: [] },
+ *     { operator: "<", major: 2, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ],
+ *   [
+ *     { operator: ">=", major: 3, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ]
+ * ]);
+ * ```
+ *
+ * @throws {TypeError} If the input range is invalid.
+ * @param value The range set string
+ * @returns A valid SemVer range
+ */
+function parseRange(value) {
+    const result = value
+        // remove spaces between operators and versions
+        .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/script/deps/jsr.io/@std/semver/1.0.4/range_intersects.d.ts

@@ -0,0 +1,25 @@
+import type { Range } from "./types.js";
+/**
+ * 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 } from "@std/assert";
+ *
+ * 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(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
+ * ```
+ *
+ * @param range1 range 0
+ * @param range2 range 1
+ * @returns returns true if the given ranges intersect, false otherwise
+ */
+export declare function rangeIntersects(range1: Range, range2: Range): boolean;
+//# sourceMappingURL=range_intersects.d.ts.map

package/script/deps/jsr.io/@std/semver/1.0.4/range_intersects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range_intersects.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/range_intersects.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AA8DpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAWrE"}

package/script/deps/jsr.io/@std/semver/1.0.4/range_intersects.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeIntersects = rangeIntersects;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const _shared_js_1 = require("./_shared.js");
+const compare_js_1 = require("./compare.js");
+const satisfies_js_1 = require("./satisfies.js");
+function comparatorIntersects(comparator1, comparator2) {
+    const op0 = comparator1.operator;
+    const op1 = comparator2.operator;
+    if (op0 === undefined) {
+        // if comparator1 is empty comparator, then returns true
+        if ((0, _shared_js_1.isWildcardComparator)(comparator1))
+            return true;
+        return (0, satisfies_js_1.satisfies)(comparator1, [[comparator2]]);
+    }
+    if (op1 === undefined) {
+        if ((0, _shared_js_1.isWildcardComparator)(comparator2))
+            return true;
+        return (0, satisfies_js_1.satisfies)(comparator2, [[comparator1]]);
+    }
+    const cmp = (0, compare_js_1.compare)(comparator1, comparator2);
+    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 comparator1 = comparators[i];
+        for (const comparator2 of comparators.slice(i + 1)) {
+            if (!comparatorIntersects(comparator1, comparator2)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * 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 } from "@std/assert";
+ *
+ * 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(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
+ * ```
+ *
+ * @param range1 range 0
+ * @param range2 range 1
+ * @returns returns true if the given ranges intersect, false otherwise
+ */
+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/script/deps/jsr.io/@std/semver/1.0.4/satisfies.d.ts

@@ -0,0 +1,24 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Test to see if the SemVer satisfies the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, satisfies } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version = parse("1.2.3");
+ * const range0 = parseRange(">=1.0.0 <2.0.0");
+ * const range1 = parseRange(">=1.0.0 <1.3.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ *
+ * assert(satisfies(version, range0));
+ * assert(satisfies(version, range1));
+ * assert(!satisfies(version, range2));
+ * ```
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export declare function satisfies(version: SemVer, range: Range): boolean;
+//# sourceMappingURL=satisfies.d.ts.map

package/script/deps/jsr.io/@std/semver/1.0.4/satisfies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"satisfies.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/satisfies.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAEhE"}