keep-a-changelog 2.6.0 → 2.6.2

package/esm/deps/jsr.io/@std/path/1.0.8/windows/to_namespaced_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_namespaced_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/to_namespaced_path.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgCrD"}

package/esm/deps/jsr.io/@std/path/1.0.8/windows/to_namespaced_path.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
+import { isWindowsDeviceRoot } from "./_util.js";
+import { resolve } from "./resolve.js";
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = resolve(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/_constants.d.ts

@@ -0,0 +1,16 @@
+import type { Comparator, SemVer } from "./types.js";
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+export declare const MIN: SemVer;
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ */
+export declare const ANY: SemVer;
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export declare const ALL: Comparator;
+export declare const OPERATORS: readonly [undefined, "=", "!=", ">", ">=", "<", "<="];
+//# sourceMappingURL=_constants.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/_constants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,MAMjB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,MAMjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,UAGjB,CAAC;AAEF,eAAO,MAAM,SAAS,uDAQZ,CAAC"}

package/esm/deps/jsr.io/@std/semver/1.0.4/_shared.d.ts

@@ -0,0 +1,44 @@
+import type { Comparator } from "./types.js";
+export declare function compareNumber(a: number, b: number): 1 | 0 | -1;
+export declare function checkIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
+export declare function compareIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
+export declare const FULL_REGEXP: RegExp;
+/**
+ * A version that can contain wildcards.
+ * @example "x", "1.x", "1.x.x", "1.2.x", "*", "1.*", "1.*.*", "1.2.*"
+ */
+export declare const XRANGE = "[v=\\s]*(?<major>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<minor>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<patch>0|[1-9]\\d*|x|X|\\*)(?:-(?<prerelease>(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*))?(?:\\+(?<buildmetadata>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?";
+/**
+ * An operator (`~`, `~>`, `^`, `=`, `<`, `<=`, `>`, or `>=`), followed by an x-range.
+ * @example "~1.x.x", "^1.2.*", ">=1.2.3"
+ */
+export declare const OPERATOR_XRANGE_REGEXP: RegExp;
+/**
+ * An empty string or a comparator (`=`, `<`, `<=`, `>`, or `>=`), followed by a version.
+ * @example ">1.2.3"
+ */
+export declare const COMPARATOR_REGEXP: RegExp;
+/**
+ * Returns true if the value is a valid SemVer number.
+ *
+ * Must be a number. Must not be NaN. Can be positive or negative infinity.
+ * Can be between 0 and MAX_SAFE_INTEGER.
+ * @param value The value to check
+ * @returns True if its a valid semver number
+ */
+export declare function isValidNumber(value: unknown): value is number;
+export declare const MAX_LENGTH = 256;
+/**
+ * Returns true if the value is a valid semver pre-release or build identifier.
+ *
+ * Must be a string. Must be between 1 and 256 characters long. Must match
+ * the regular expression /[0-9A-Za-z-]+/.
+ * @param value The value to check
+ * @returns True if the value is a valid semver string.
+ */
+export declare function isValidString(value: unknown): value is string;
+export declare function parsePrerelease(prerelease: string): (string | number)[];
+export declare function parseBuild(buildmetadata: string): string[];
+export declare function parseNumber(input: string, errorMessage: string): number;
+export declare function isWildcardComparator(c: Comparator): boolean;
+//# sourceMappingURL=_shared.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/_shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shared.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/_shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAKZ;AAED,wBAAgB,eAAe,CAC7B,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,EACvC,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,GACtC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAMZ;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,EACvC,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,GACtC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAoBZ;AAgDD,eAAO,MAAM,WAAW,QAAkC,CAAC;AAgB3D;;;GAGG;AACH,eAAO,MAAM,MAAM,iSAC0H,CAAC;AAE9I;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAElC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAE7B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAGD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,uBAWjD;AAED,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,YAE/C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAI9D;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAM3D"}

package/esm/deps/jsr.io/@std/semver/1.0.4/_test_comparator_set.d.ts

@@ -0,0 +1,3 @@
+import type { Comparator, SemVer } from "./types.js";
+export declare function testComparatorSet(version: SemVer, set: Comparator[]): boolean;
+//# sourceMappingURL=_test_comparator_set.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/_test_comparator_set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_test_comparator_set.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/_test_comparator_set.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAgCrD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,UAAU,EAAE,GAChB,OAAO,CA6BT"}

package/esm/deps/jsr.io/@std/semver/1.0.4/can_parse.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "@std/semver/can-parse";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(canParse("1.2.3"));
+ * assertFalse(canParse("invalid"));
+ * ```
+ *
+ * @param value The version string to check
+ * @returns `true` if the string can be parsed as SemVer, `false` otherwise
+ */
+export declare function canParse(value: string): boolean;
+//# sourceMappingURL=can_parse.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/can_parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"can_parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/can_parse.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAO/C"}

package/esm/deps/jsr.io/@std/semver/1.0.4/can_parse.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parse } from "./parse.js";
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "@std/semver/can-parse";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(canParse("1.2.3"));
+ * assertFalse(canParse("invalid"));
+ * ```
+ *
+ * @param value The version string to check
+ * @returns `true` if the string can be parsed as SemVer, `false` otherwise
+ */
+export function canParse(value) {
+    try {
+        parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/compare.d.ts

@@ -0,0 +1,28 @@
+import type { SemVer } from "./types.js";
+/**
+ * Compare two SemVers.
+ *
+ * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to {@linkcode Array.sort}.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assertEquals(compare(version1, version2), -1);
+ * assertEquals(compare(version2, version1), 1);
+ * assertEquals(compare(version1, version1), 0);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
+ */
+export declare function compare(version1: SemVer, version2: SemVer): 1 | 0 | -1;
+//# sourceMappingURL=compare.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/compare.d.ts.map

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

package/esm/deps/jsr.io/@std/semver/1.0.4/compare.js

@@ -0,0 +1,35 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
+/**
+ * Compare two SemVers.
+ *
+ * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to {@linkcode Array.sort}.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assertEquals(compare(version1, version2), -1);
+ * assertEquals(compare(version2, version1), 1);
+ * assertEquals(compare(version1, version1), 0);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
+ */
+export function compare(version1, version2) {
+    if (version1 === version2)
+        return 0;
+    return (compareNumber(version1.major, version2.major) ||
+        compareNumber(version1.minor, version2.minor) ||
+        compareNumber(version1.patch, version2.patch) ||
+        checkIdentifier(version1.prerelease, version2.prerelease) ||
+        compareIdentifier(version1.prerelease, version2.prerelease));
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/difference.d.ts

@@ -0,0 +1,27 @@
+import type { ReleaseType, SemVer } from "./types.js";
+/**
+ * Returns difference between two SemVers by the release type,
+ * or `undefined` if the SemVers are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const version3 = parse("1.3.0");
+ * const version4 = parse("2.0.0");
+ *
+ * assertEquals(difference(version1, version2), "patch");
+ * assertEquals(difference(version1, version3), "minor");
+ * assertEquals(difference(version1, version4), "major");
+ * assertEquals(difference(version1, version1), undefined);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export declare function difference(version1: SemVer, version2: SemVer): ReleaseType | undefined;
+//# sourceMappingURL=difference.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/difference.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,WAAW,GAAG,SAAS,CAiBzB"}

package/esm/deps/jsr.io/@std/semver/1.0.4/difference.js

@@ -0,0 +1,41 @@
+import { compareIdentifier } from "./_shared.js";
+/**
+ * Returns difference between two SemVers by the release type,
+ * or `undefined` if the SemVers are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const version3 = parse("1.3.0");
+ * const version4 = parse("2.0.0");
+ *
+ * assertEquals(difference(version1, version2), "patch");
+ * assertEquals(difference(version1, version3), "minor");
+ * assertEquals(difference(version1, version4), "major");
+ * assertEquals(difference(version1, version1), undefined);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export function difference(version1, version2) {
+    const hasPrerelease = version1.prerelease?.length ||
+        version2.prerelease?.length;
+    if (version1.major !== version2.major) {
+        return hasPrerelease ? "premajor" : "major";
+    }
+    if (version1.minor !== version2.minor) {
+        return hasPrerelease ? "preminor" : "minor";
+    }
+    if (version1.patch !== version2.patch) {
+        return hasPrerelease ? "prepatch" : "patch";
+    }
+    if (compareIdentifier(version1.prerelease, version2.prerelease) !== 0) {
+        return "prerelease";
+    }
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/equals.d.ts

@@ -0,0 +1,24 @@
+import type { SemVer } from "./types.js";
+/**
+ * Returns `true` if both SemVers are equivalent.
+ *
+ * This is equal to `compare(version1, version2) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.3");
+ *
+ * assert(equals(version1, version2));
+ * assert(!equals(version1, parse("1.2.4")));
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `true` if `version1` is equal to `version2`, `false` otherwise
+ */
+export declare function equals(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=equals.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/equals.d.ts.map

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

package/esm/deps/jsr.io/@std/semver/1.0.4/equals.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Returns `true` if both SemVers are equivalent.
+ *
+ * This is equal to `compare(version1, version2) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.3");
+ *
+ * assert(equals(version1, version2));
+ * assert(!equals(version1, parse("1.2.4")));
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `true` if `version1` is equal to `version2`, `false` otherwise
+ */
+export function equals(version1, version2) {
+    return compare(version1, version2) === 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/format.d.ts

@@ -0,0 +1,22 @@
+import type { SemVer } from "./types.js";
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ */
+export declare function format(version: SemVer): string;
+//# sourceMappingURL=format.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/format.d.ts.map

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

package/esm/deps/jsr.io/@std/semver/1.0.4/format.js

@@ -0,0 +1,32 @@
+function formatNumber(value) {
+    return value.toFixed(0);
+}
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ */
+export function format(version) {
+    const major = formatNumber(version.major);
+    const minor = formatNumber(version.minor);
+    const patch = formatNumber(version.patch);
+    const pre = version.prerelease?.join(".") ?? "";
+    const build = version.build?.join(".") ?? "";
+    const primary = `${major}.${minor}.${patch}`;
+    const release = [primary, pre].filter((v) => v).join("-");
+    return [release, build].filter((v) => v).join("+");
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/format_range.d.ts

@@ -0,0 +1,18 @@
+import type { Range } from "./types.js";
+/**
+ * Formats the SemVerrange into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { formatRange, parseRange } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertEquals(formatRange(range), ">=1.2.3 <1.2.4");
+ * ```
+ *
+ * @param range The range to format
+ * @returns A string representation of the SemVer range
+ */
+export declare function formatRange(range: Range): string;
+//# sourceMappingURL=format_range.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/format_range.d.ts.map

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

package/esm/deps/jsr.io/@std/semver/1.0.4/format_range.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { format } from "./format.js";
+import { isWildcardComparator } from "./_shared.js";
+function formatComparator(comparator) {
+    const { operator } = comparator;
+    return `${operator === undefined ? "" : operator}${isWildcardComparator(comparator) ? "*" : format(comparator)}`;
+}
+/**
+ * Formats the SemVerrange into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { formatRange, parseRange } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertEquals(formatRange(range), ">=1.2.3 <1.2.4");
+ * ```
+ *
+ * @param range The range to format
+ * @returns A string representation of the SemVer range
+ */
+export function formatRange(range) {
+    return range.map((c) => c.map((c) => formatComparator(c)).join(" "))
+        .join("||");
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_or_equal.d.ts

@@ -0,0 +1,25 @@
+import type { SemVer } from "./types.js";
+/**
+ * Greater than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) >= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterOrEqual(version2, version1));
+ * assert(!greaterOrEqual(version1, version2));
+ * assert(greaterOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than or equal to `version2`, `false` otherwise
+ */
+export declare function greaterOrEqual(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=greater_or_equal.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_or_equal.d.ts.map

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

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_or_equal.js

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

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_than.d.ts

@@ -0,0 +1,25 @@
+import type { SemVer } from "./types.js";
+/**
+ * Greater than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterThan(version2, version1));
+ * assert(!greaterThan(version1, version2));
+ * assert(!greaterThan(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than `version2`, `false` otherwise
+ */
+export declare function greaterThan(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=greater_than.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater_than.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.4/greater_than.ts"],"names":[],"mappings":"AAGA,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/esm/deps/jsr.io/@std/semver/1.0.4/greater_than.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Greater than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterThan(version2, version1));
+ * assert(!greaterThan(version1, version2));
+ * assert(!greaterThan(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than `version2`, `false` otherwise
+ */
+export function greaterThan(version1, version2) {
+    return compare(version1, version2) > 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_than_range.d.ts

@@ -0,0 +1,23 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ *
+ * assert(!greaterThanRange(version1, range));
+ * assert(greaterThanRange(version2, range));
+ * ```
+ *
+ * @param version The version to check.
+ * @param range The range to check against.
+ * @returns `true` if the semver is greater than the range, `false` otherwise.
+ */
+export declare function greaterThanRange(version: SemVer, range: Range): boolean;
+//# sourceMappingURL=greater_than_range.d.ts.map

package/esm/deps/jsr.io/@std/semver/1.0.4/greater_than_range.d.ts.map

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