keep-a-changelog 2.6.0 → 2.6.2

package/esm/std/semver/increment.js

@@ -1,176 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { parseBuild } from "./_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 "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 function increment(version, release, options = {}) {
-    const build = options.build !== undefined
-        ? 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/esm/std/semver/is_range.d.ts

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

package/esm/std/semver/is_range.js

@@ -1,38 +0,0 @@
-import { OPERATORS } from "./_constants.js";
-import { ALL } from "./_constants.js";
-import { isSemVer } from "./is_semver.js";
-function isComparator(value) {
-    if (value === null || value === undefined || Array.isArray(value) ||
-        typeof value !== "object")
-        return false;
-    if (value === ALL)
-        return true;
-    const { operator } = value;
-    return ((operator === undefined ||
-        OPERATORS.includes(operator)) &&
-        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 "is_range.ts";
- * import { assert } from "../assert/mod.ts";
- *
- * 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 function isRange(value) {
-    return Array.isArray(value) &&
-        value.every((r) => Array.isArray(r) && r.every((c) => isComparator(c)));
-}

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

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

package/esm/std/semver/is_semver.js

@@ -1,53 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { ANY } from "./_constants.js";
-import { isValidNumber, isValidString } from "./_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 "is_semver.ts";
- * import { assert } from "../assert/mod.ts";
- *
- * 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 function isSemVer(value) {
-    if (value === null || value === undefined)
-        return false;
-    if (Array.isArray(value))
-        return false;
-    if (typeof value !== "object")
-        return false;
-    if (value === ANY)
-        return true;
-    const { major, minor, patch, build = [], prerelease = [], } = value;
-    return (isValidNumber(major) &&
-        isValidNumber(minor) &&
-        isValidNumber(patch) &&
-        Array.isArray(prerelease) &&
-        prerelease.every((v) => isValidString(v) || isValidNumber(v)) &&
-        Array.isArray(build) &&
-        build.every(isValidString));
-}

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

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

package/esm/std/semver/less_or_equal.js

@@ -1,26 +0,0 @@
-import { compare } from "./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 "mod.ts";
- * import { assert } from "../assert/mod.ts";
- *
- * 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 function lessOrEqual(version1, version2) {
-    return compare(version1, version2) <= 0;
-}

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

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

package/esm/std/semver/less_than.js

@@ -1,26 +0,0 @@
-import { compare } from "./compare.js";
-/**
- * Less than comparison for two SemVers.
- *
- * This is equal to `compare(version1, version2) < 0`.
- *
- * @example Usage
- * ```ts
- * import { parse, lessThan } from "mod.ts";
- * import { assert } from "../assert/mod.ts";
- *
- * 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 function lessThan(version1, version2) {
-    return compare(version1, version2) < 0;
-}

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

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

package/esm/std/semver/less_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 less than the range.
- *
- * @example Usage
- * ```ts
- * import { parse, parseRange, lessThanRange } from "mod.ts";
- * import { assert } from "../assert/mod.ts";
- *
- * 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 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(isWildcardComparator))
-        return false;
-    // If the SemVer satisfies the comparator set, then it's not less than the range.
-    if (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 = 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/esm/std/semver/max_satisfying.d.ts

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

package/esm/std/semver/max_satisfying.js

@@ -1,30 +0,0 @@
-import { satisfies } from "./satisfies.js";
-import { greaterThan } from "./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 "mod.ts";
- * import { assertEquals } from "../assert/mod.ts";
- *
- * 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 function maxSatisfying(versions, range) {
-    let max;
-    for (const version of versions) {
-        if (!satisfies(version, range))
-            continue;
-        max = max && greaterThan(max, version) ? max : version;
-    }
-    return max;
-}

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

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

package/esm/std/semver/min_satisfying.js

@@ -1,30 +0,0 @@
-import { satisfies } from "./satisfies.js";
-import { lessThan } from "./less_than.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 "mod.ts";
- * import { assertEquals } from "../assert/mod.ts";
- *
- * 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 function minSatisfying(versions, range) {
-    let min;
-    for (const version of versions) {
-        if (!satisfies(version, range))
-            continue;
-        min = min && lessThan(min, version) ? min : version;
-    }
-    return min;
-}