keep-a-changelog 2.6.0 → 2.6.2

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

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

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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-// 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

@@ -1,21 +0,0 @@
-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

@@ -1,32 +0,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.
- */
-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

@@ -1,17 +0,0 @@
-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

@@ -1,27 +0,0 @@
-// 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

@@ -1,24 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,28 +0,0 @@
-// 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

@@ -1,22 +0,0 @@
-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

@@ -1,58 +0,0 @@
-// 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/esm/std/semver/increment.d.ts

@@ -1,50 +0,0 @@
-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 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 "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 options Additional options
- * @returns The new version
- */
-export declare function increment(version: SemVer, release: ReleaseType, options?: IncrementOptions): SemVer;