keep-a-changelog 2.5.2 → 2.6.0

package/script/std/semver/can_parse.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canParse = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const parse_js_1 = require("./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
+ */
+function canParse(value) {
+    try {
+        (0, parse_js_1.parse)(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.canParse = canParse;

package/script/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/script/std/semver/compare.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = void 0;
+const _shared_js_1 = require("./_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
+ */
+function compare(version1, version2) {
+    if (version1 === version2)
+        return 0;
+    return ((0, _shared_js_1.compareNumber)(version1.major, version2.major) ||
+        (0, _shared_js_1.compareNumber)(version1.minor, version2.minor) ||
+        (0, _shared_js_1.compareNumber)(version1.patch, version2.patch) ||
+        (0, _shared_js_1.checkIdentifier)(version1.prerelease, version2.prerelease) ||
+        (0, _shared_js_1.compareIdentifier)(version1.prerelease, version2.prerelease));
+}
+exports.compare = compare;

package/script/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/script/std/semver/difference.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.difference = void 0;
+const _shared_js_1 = require("./_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
+ */
+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 ((0, _shared_js_1.compareIdentifier)(version1.prerelease, version2.prerelease) !== 0) {
+        return "prerelease";
+    }
+}
+exports.difference = difference;

package/script/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/script/std/semver/equals.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const compare_js_1 = require("./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
+ */
+function equals(version1, version2) {
+    return (0, compare_js_1.compare)(version1, version2) === 0;
+}
+exports.equals = equals;

package/script/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/script/std/semver/format.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+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.
+ */
+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("+");
+}
+exports.format = format;

package/script/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/script/std/semver/format_range.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRange = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const format_js_1 = require("./format.js");
+const _shared_js_1 = require("./_shared.js");
+function formatComparator(comparator) {
+    const { operator } = comparator;
+    return `${operator === undefined ? "" : operator}${(0, _shared_js_1.isWildcardComparator)(comparator) ? "*" : (0, format_js_1.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
+ */
+function formatRange(range) {
+    return range.map((c) => c.map((c) => formatComparator(c)).join(" "))
+        .join("||");
+}
+exports.formatRange = formatRange;

package/script/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/script/std/semver/greater_or_equal.js

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

package/script/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/script/std/semver/greater_than.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.greaterThan = void 0;
+const compare_js_1 = require("./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
+ */
+function greaterThan(version1, version2) {
+    return (0, compare_js_1.compare)(version1, version2) > 0;
+}
+exports.greaterThan = greaterThan;

package/script/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/script/std/semver/greater_than_range.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.greaterThanRange = void 0;
+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 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.
+ */
+function greaterThanRange(version, range) {
+    return range.every((comparatorSet) => greaterThanComparatorSet(version, comparatorSet));
+}
+exports.greaterThanRange = greaterThanRange;
+function greaterThanComparatorSet(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 greater than the range.
+    if ((0, _test_comparator_set_js_1.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 = (0, compare_js_1.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/{esm/deps/deno.land/std@0.205.0 → script/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;