keep-a-changelog 2.5.3 → 2.6.0

package/esm/std/semver/_test_comparator_set.d.ts

@@ -0,0 +1,2 @@
+import type { Comparator, SemVer } from "./types.js";
+export declare function testComparatorSet(version: SemVer, set: Comparator[]): boolean;

package/esm/std/semver/_test_comparator_set.js

@@ -0,0 +1,58 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+function testComparator(version, comparator) {
+    if (isWildcardComparator(comparator)) {
+        return true;
+    }
+    const cmp = compare(version, 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;
+        }
+    }
+}
+export 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 { major, minor, patch, prerelease } = comparator;
+            if (prerelease && prerelease.length > 0) {
+                if (version.major === major && version.minor === minor &&
+                    version.patch === patch) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return true;
+}

package/esm/std/semver/can_parse.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "can_parse.ts";
+ * import { assert, assertFalse } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "can_parse.ts";
+ * import { assert, assertFalse } from "../assert/mod.ts";
+ *
+ * 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/std/semver/compare.d.ts

@@ -0,0 +1,27 @@
+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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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/std/semver/difference.d.ts

@@ -0,0 +1,26 @@
+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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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/std/semver/equals.d.ts

@@ -0,0 +1,23 @@
+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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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/std/semver/format.d.ts

@@ -0,0 +1,21 @@
+import type { SemVer } from "./types.js";
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "format.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "format.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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/std/semver/format_range.d.ts

@@ -0,0 +1,17 @@
+import type { Range } from "./types.js";
+/**
+ * Formats the SemVerrange into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { formatRange, parseRange } from "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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/std/semver/greater_or_equal.d.ts

@@ -0,0 +1,24 @@
+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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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/std/semver/greater_than.d.ts

@@ -0,0 +1,24 @@
+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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/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 "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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/std/semver/greater_than_range.d.ts

@@ -0,0 +1,22 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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;

package/esm/std/semver/greater_than_range.js

@@ -0,0 +1,58 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { testComparatorSet } from "./_test_comparator_set.js";
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * 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 function greaterThanRange(version, range) {
+    return range.every((comparatorSet) => greaterThanComparatorSet(version, comparatorSet));
+}
+function greaterThanComparatorSet(version, comparatorSet) {
+    // If the comparator set contains wildcard, then the semver is not greater than the range.
+    if (comparatorSet.some(isWildcardComparator))
+        return false;
+    // If the semver satisfies the comparator set, then it's not greater than the range.
+    if (testComparatorSet(version, comparatorSet))
+        return false;
+    // If the semver is less than any of the comparator set, then it's not greater than the range.
+    if (comparatorSet.some((comparator) => lessThanComparator(version, comparator)))
+        return false;
+    return true;
+}
+function lessThanComparator(version, comparator) {
+    const cmp = compare(version, comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined:
+            return cmp < 0;
+        case "!=":
+            return false;
+        case ">":
+            return cmp <= 0;
+        case "<":
+            return false;
+        case ">=":
+            return cmp < 0;
+        case "<=":
+            return false;
+    }
+}

package/{script/deps/deno.land/std@0.205.0 → esm/std}/semver/increment.d.ts

@@ -1,6 +1,13 @@
 import type { ReleaseType, SemVer } from "./types.js";
+/** Options for {@linkcode increment}. */
+export interface IncrementOptions {
+    /** The pre-release metadata of the new version. */
+    prerelease?: string;
+    /** The build metadata of the new version. */
+    build?: string;
+}
 /**
- * Returns the new version resulting from an increment by release type.
+ * Returns the new SemVer resulting from an increment by release type.
  *
  * `premajor`, `preminor` and `prepatch` will bump the version up to the next version,
  * based on the type, and will also add prerelease metadata.
@@ -19,10 +26,25 @@ import type { ReleaseType, SemVer } from "./types.js";
  * 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 "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * 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 prerelease The pre-release metadata of the new version
- * @param build The build metadata of the new version
- * @returns
+ * @param options Additional options
+ * @returns The new version
  */
-export declare function increment(version: SemVer, release: ReleaseType, prerelease?: string, build?: string): SemVer;
+export declare function increment(version: SemVer, release: ReleaseType, options?: IncrementOptions): SemVer;