keep-a-changelog 2.6.0 → 2.6.2

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.increment = increment;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const _shared_js_1 = require("./_shared.js");
+function bumpPrereleaseNumber(prerelease = []) {
+    const values = [...prerelease];
+    let index = values.length;
+    while (index >= 0) {
+        const value = values[index];
+        if (typeof value === "number") {
+            values[index] = value + 1;
+            break;
+        }
+        index -= 1;
+    }
+    // if no number was bumped
+    if (index === -1)
+        values.push(0);
+    return values;
+}
+function bumpPrerelease(prerelease = [], identifier) {
+    let values = bumpPrereleaseNumber(prerelease);
+    if (!identifier)
+        return values;
+    // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+    // 1.2.0-beta.foobar or 1.2.0-beta bumps to 1.2.0-beta.0
+    if (values[0] !== identifier || isNaN(values[1])) {
+        values = [identifier, 0];
+    }
+    return values;
+}
+/**
+ * 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.
+ *
+ * If called from a non-prerelease version, the `prerelease` will work the same as
+ * `prepatch`. The patch version is incremented and then is made into a prerelease. If
+ * the input version is already a prerelease it will simply increment the prerelease
+ * metadata.
+ *
+ * If a prerelease identifier is specified without a number then a number will be added.
+ * For example `pre` will result in `pre.0`. If the existing version already has a
+ * prerelease with a number and its the same prerelease identifier then the number
+ * will be incremented. If the identifier differs from the new identifier then the new
+ * identifier is applied and the number is reset to `0`.
+ *
+ * If the input version has build metadata it will be preserved on the resulting version
+ * unless a new build parameter is specified. Specifying `""` will unset existing build
+ * metadata.
+ *
+ * @example Usage
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(increment(version, "major"), parse("2.0.0"));
+ * assertEquals(increment(version, "minor"), parse("1.3.0"));
+ * assertEquals(increment(version, "patch"), parse("1.2.4"));
+ * assertEquals(increment(version, "prerelease"), parse("1.2.4-0"));
+ *
+ * const prerelease = parse("1.2.3-beta.0");
+ * assertEquals(increment(prerelease, "prerelease"), parse("1.2.3-beta.1"));
+ * ```
+ *
+ * @param version The version to increment
+ * @param release The type of increment to perform
+ * @param options Additional options
+ * @returns The new version
+ */
+function increment(version, release, options = {}) {
+    const build = options.build !== undefined
+        ? (0, _shared_js_1.parseBuild)(options.build)
+        : version.build ?? [];
+    switch (release) {
+        case "premajor":
+            return {
+                major: version.major + 1,
+                minor: 0,
+                patch: 0,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case "preminor":
+            return {
+                major: version.major,
+                minor: version.minor + 1,
+                patch: 0,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case "prepatch":
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch + 1,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case "prerelease": {
+            // If the input is a non-prerelease version, this acts the same as prepatch.
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const patch = isPrerelease ? version.patch + 1 : version.patch;
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        }
+        case "major": {
+            // If this is a pre-major version, bump up to the same major version. Otherwise increment major.
+            // 1.0.0-5 bumps to 1.0.0
+            // 1.1.0 bumps to 2.0.0
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const major = isPrerelease || version.minor !== 0 || version.patch !== 0
+                ? version.major + 1
+                : version.major;
+            return {
+                major,
+                minor: 0,
+                patch: 0,
+                prerelease: [],
+                build,
+            };
+        }
+        case "minor": {
+            // If this is a pre-minor version, bump up to the same minor version. Otherwise increment minor.
+            // 1.2.0-5 bumps to 1.2.0
+            // 1.2.1 bumps to 1.3.0
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const minor = isPrerelease || version.patch !== 0
+                ? version.minor + 1
+                : version.minor;
+            return {
+                major: version.major,
+                minor,
+                patch: 0,
+                prerelease: [],
+                build,
+            };
+        }
+        case "patch": {
+            // If this is not a pre-release version, it will increment the patch.
+            // If it is a pre-release it will bump up to the same patch version.
+            // 1.2.0-5 patches to 1.2.0
+            // 1.2.0 patches to 1.2.1
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const patch = isPrerelease ? version.patch + 1 : version.patch;
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch,
+                prerelease: [],
+                build,
+            };
+        }
+        case "pre": {
+            // 1.0.0 "pre" would become 1.0.0-0
+            // 1.0.0-0 would become 1.0.0-1
+            // 1.0.0-beta.0 would be come 1.0.0-beta.1
+            // switching the pre identifier resets the number to 0
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        }
+        default:
+            throw new TypeError(`Cannot increment version: invalid argument ${release}`);
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { Range } from "./types.js";
+/**
+ * Does a deep check on the object to determine if its a valid range.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ *
+ * @example Usage
+ * ```ts
+ * import { isRange } from "@std/semver/is-range";
+ * import { assert } from "@std/assert";
+ *
+ * const range = [[{ major: 1, minor: 2, patch: 3 }]];
+ * assert(isRange(range));
+ * assert(!isRange({}));
+ * ```
+ * @param value The value to check if its a valid Range
+ * @returns True if its a valid Range otherwise false.
+ */
+export declare function isRange(value: unknown): value is Range;
+//# sourceMappingURL=is_range.d.ts.map

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRange = isRange;
+const _constants_js_1 = require("./_constants.js");
+const _constants_js_2 = require("./_constants.js");
+const is_semver_js_1 = require("./is_semver.js");
+function isComparator(value) {
+    if (value === null || value === undefined || Array.isArray(value) ||
+        typeof value !== "object")
+        return false;
+    if (value === _constants_js_2.ALL)
+        return true;
+    const { operator } = value;
+    return ((operator === undefined ||
+        _constants_js_1.OPERATORS.includes(operator)) &&
+        (0, is_semver_js_1.isSemVer)(value));
+}
+/**
+ * Does a deep check on the object to determine if its a valid range.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ *
+ * @example Usage
+ * ```ts
+ * import { isRange } from "@std/semver/is-range";
+ * import { assert } from "@std/assert";
+ *
+ * const range = [[{ major: 1, minor: 2, patch: 3 }]];
+ * assert(isRange(range));
+ * assert(!isRange({}));
+ * ```
+ * @param value The value to check if its a valid Range
+ * @returns True if its a valid Range otherwise false.
+ */
+function isRange(value) {
+    return Array.isArray(value) &&
+        value.every((r) => Array.isArray(r) && r.every((c) => isComparator(c)));
+}

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

@@ -0,0 +1,34 @@
+import type { SemVer } from "./types.js";
+/**
+ * Checks to see if value is a valid SemVer object. It does a check
+ * into each field including prerelease and build.
+ *
+ * Some invalid SemVer sentinels can still return true such as ANY and INVALID.
+ * An object which has the same value as a sentinel but isn't reference equal
+ * will still fail.
+ *
+ * Objects which are valid SemVer objects but have _extra_ fields are still
+ * considered SemVer objects and this will return true.
+ *
+ * A type assertion is added to the value.
+ *
+ * @example Usage
+ * ```ts
+ * import { isSemVer } from "@std/semver/is-semver";
+ * import { assert } from "@std/assert";
+ *
+ * const value = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ *
+ * assert(isSemVer(value));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
+ * ```
+ *
+ * @param value The value to check to see if its a valid SemVer object
+ * @returns True if value is a valid SemVer otherwise false
+ */
+export declare function isSemVer(value: unknown): value is SemVer;
+//# sourceMappingURL=is_semver.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemVer = isSemVer;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const _constants_js_1 = require("./_constants.js");
+const _shared_js_1 = require("./_shared.js");
+/**
+ * Checks to see if value is a valid SemVer object. It does a check
+ * into each field including prerelease and build.
+ *
+ * Some invalid SemVer sentinels can still return true such as ANY and INVALID.
+ * An object which has the same value as a sentinel but isn't reference equal
+ * will still fail.
+ *
+ * Objects which are valid SemVer objects but have _extra_ fields are still
+ * considered SemVer objects and this will return true.
+ *
+ * A type assertion is added to the value.
+ *
+ * @example Usage
+ * ```ts
+ * import { isSemVer } from "@std/semver/is-semver";
+ * import { assert } from "@std/assert";
+ *
+ * const value = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ *
+ * assert(isSemVer(value));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
+ * ```
+ *
+ * @param value The value to check to see if its a valid SemVer object
+ * @returns True if value is a valid SemVer otherwise false
+ */
+function isSemVer(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value !== "object")
+        return false;
+    if (value === _constants_js_1.ANY)
+        return true;
+    const { major, minor, patch, build = [], prerelease = [], } = value;
+    return ((0, _shared_js_1.isValidNumber)(major) &&
+        (0, _shared_js_1.isValidNumber)(minor) &&
+        (0, _shared_js_1.isValidNumber)(patch) &&
+        Array.isArray(prerelease) &&
+        prerelease.every((v) => (0, _shared_js_1.isValidString)(v) || (0, _shared_js_1.isValidNumber)(v)) &&
+        Array.isArray(build) &&
+        build.every(_shared_js_1.isValidString));
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Check if the SemVer is less than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, lessThanRange } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.0.0");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ *
+ * assert(!lessThanRange(version1, range));
+ * assert(lessThanRange(version2, range));
+ * ```
+ *
+ * @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 declare function lessThanRange(version: SemVer, range: Range): boolean;
+//# sourceMappingURL=less_than_range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"less_than_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/less_than_range.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAIpE"}

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

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lessThanRange = lessThanRange;
+const _test_comparator_set_js_1 = require("./_test_comparator_set.js");
+const _shared_js_1 = require("./_shared.js");
+const compare_js_1 = require("./compare.js");
+/**
+ * Check if the SemVer is less than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, lessThanRange } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.0.0");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ *
+ * assert(!lessThanRange(version1, range));
+ * assert(lessThanRange(version2, range));
+ * ```
+ *
+ * @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.
+ */
+function lessThanRange(version, range) {
+    return range.every((comparatorSet) => lessThanComparatorSet(version, comparatorSet));
+}
+function lessThanComparatorSet(version, comparatorSet) {
+    // If the comparator set contains wildcard, then the semver is not greater than the range.
+    if (comparatorSet.some(_shared_js_1.isWildcardComparator))
+        return false;
+    // If the SemVer satisfies the comparator set, then it's not less than the range.
+    if ((0, _test_comparator_set_js_1.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(version, comparator)))
+        return false;
+    return true;
+}
+function greaterThanComparator(version, comparator) {
+    const cmp = (0, compare_js_1.compare)(version, comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined:
+            return cmp > 0;
+        case "!=":
+            return false;
+        case ">":
+            return false;
+        case "<":
+            return cmp >= 0;
+        case ">=":
+            return false;
+        case "<=":
+            return cmp > 0;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * 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";
+ *
+ * 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");
+ *
+ * assertEquals(maxSatisfying(versions, range), parse("1.3.0"));
+ * ```
+ *
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The highest version in versions that satisfies the range.
+ */
+export declare function maxSatisfying(versions: SemVer[], range: Range): SemVer | undefined;
+//# sourceMappingURL=max_satisfying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/max_satisfying.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,KAAK,GACX,MAAM,GAAG,SAAS,CAOpB"}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSatisfying = maxSatisfying;
+const satisfies_js_1 = require("./satisfies.js");
+const greater_than_js_1 = require("./greater_than.js");
+/**
+ * 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";
+ *
+ * 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");
+ *
+ * assertEquals(maxSatisfying(versions, range), parse("1.3.0"));
+ * ```
+ *
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The highest version in versions that satisfies the range.
+ */
+function maxSatisfying(versions, range) {
+    let max;
+    for (const version of versions) {
+        if (!(0, satisfies_js_1.satisfies)(version, range))
+            continue;
+        max = max && (0, greater_than_js_1.greaterThan)(max, version) ? max : version;
+    }
+    return max;
+}

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

@@ -0,0 +1,22 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * 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";
+ *
+ * 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");
+ *
+ * assertEquals(minSatisfying(versions, range), parse("1.2.3"));
+ * ```
+ *
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The lowest version in versions that satisfies the range.
+ */
+export declare function minSatisfying(versions: SemVer[], range: Range): SemVer | undefined;
+//# sourceMappingURL=min_satisfying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/min_satisfying.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,KAAK,GACX,MAAM,GAAG,SAAS,CAOpB"}