keep-a-changelog 2.3.0 → 2.5.0

package/esm/deps/deno.land/std@0.205.0/semver/comparator_min.d.ts

@@ -0,0 +1,8 @@
+import type { Operator, SemVer } from "./types.js";
+/**
+ * The minimum semantic version that could match this comparator
+ * @param semver The semantic version of the comparator
+ * @param operator The operator of the comparator
+ * @returns The minimum valid semantic version
+ */
+export declare function comparatorMin(semver: SemVer, operator: Operator): SemVer;

package/esm/deps/deno.land/std@0.205.0/semver/comparator_min.js

@@ -0,0 +1,32 @@
+import { ANY, MAX, MIN } from "./constants.js";
+import { gt } from "./gt.js";
+import { increment } from "./increment.js";
+/**
+ * The minimum semantic version that could match this comparator
+ * @param semver The semantic version of the comparator
+ * @param operator The operator of the comparator
+ * @returns The minimum valid semantic version
+ */
+export function comparatorMin(semver, operator) {
+    if (semver === ANY) {
+        return MIN;
+    }
+    switch (operator) {
+        case ">":
+            return semver.prerelease.length > 0
+                ? increment(semver, "pre")
+                : increment(semver, "patch");
+        case "!=":
+        case "!==":
+        case "<=":
+        case "<":
+            // The min(<0.0.0) is MAX
+            return gt(semver, MIN) ? MIN : MAX;
+        case ">=":
+        case "":
+        case "=":
+        case "==":
+        case "===":
+            return semver;
+    }
+}

package/esm/deps/deno.land/std@0.205.0/semver/compare.d.ts

@@ -0,0 +1,10 @@
+import type { SemVer } from "./types.js";
+/**
+ * Compare two semantic version objects.
+ *
+ * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to `Array.sort()`,
+ */
+export declare function compare(s0: SemVer, s1: SemVer): 1 | 0 | -1;

package/esm/deps/deno.land/std@0.205.0/semver/compare.js

@@ -0,0 +1,18 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
+/**
+ * Compare two semantic version objects.
+ *
+ * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to `Array.sort()`,
+ */
+export function compare(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return (compareNumber(s0.major, s1.major) ||
+        compareNumber(s0.minor, s1.minor) ||
+        compareNumber(s0.patch, s1.patch) ||
+        checkIdentifier(s0.prerelease, s1.prerelease) ||
+        compareIdentifier(s0.prerelease, s1.prerelease));
+}

package/esm/deps/deno.land/std@0.205.0/semver/compare_build.d.ts

@@ -0,0 +1,13 @@
+import type { SemVer } from "./types.js";
+/**
+ * Compare two semantic version objects including build metadata.
+ *
+ * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to `Array.sort()`,
+ * @param s0
+ * @param s1
+ * @returns
+ */
+export declare function compareBuild(s0: SemVer, s1: SemVer): 1 | 0 | -1;

package/esm/deps/deno.land/std@0.205.0/semver/compare_build.js

@@ -0,0 +1,23 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
+/**
+ * Compare two semantic version objects including build metadata.
+ *
+ * Returns `0` if `v1 === v2`, or `1` if `v1` is greater, or `-1` if `v2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to `Array.sort()`,
+ * @param s0
+ * @param s1
+ * @returns
+ */
+export function compareBuild(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return (compareNumber(s0.major, s1.major) ||
+        compareNumber(s0.minor, s1.minor) ||
+        compareNumber(s0.patch, s1.patch) ||
+        checkIdentifier(s0.prerelease, s1.prerelease) ||
+        compareIdentifier(s0.prerelease, s1.prerelease) ||
+        checkIdentifier(s1.build, s0.build) ||
+        compareIdentifier(s0.build, s1.build));
+}

package/esm/deps/deno.land/std@0.205.0/semver/constants.d.ts

@@ -0,0 +1,42 @@
+import type { SemVer, SemVerComparator } from "./types.js";
+/**
+ * MAX is a sentinel value used by some range calculations.
+ * It is equivalent to `∞.∞.∞`.
+ */
+export declare const MAX: SemVer;
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+export declare const MIN: SemVer;
+/**
+ * A sentinel value used to denote an invalid SemVer object
+ * which may be the result of impossible ranges or comparator operations.
+ * @example
+ * ```ts
+ * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
+ * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
+ * import { INVALID } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
+ * eq(parse("1.2.3"), INVALID);
+ * ```
+ */
+export declare const INVALID: SemVer;
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ * @example
+ * ```ts
+ * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
+ * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
+ * import { ANY } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
+ * eq(parse("1.2.3"), ANY); // false
+ * ```
+ */
+export declare const ANY: SemVer;
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export declare const ALL: SemVerComparator;
+/**
+ * A comparator which will not span any semantic versions
+ */
+export declare const NONE: SemVerComparator;

package/esm/deps/deno.land/std@0.205.0/semver/constants.js

@@ -0,0 +1,75 @@
+/**
+ * MAX is a sentinel value used by some range calculations.
+ * It is equivalent to `∞.∞.∞`.
+ */
+export const MAX = {
+    major: Number.POSITIVE_INFINITY,
+    minor: Number.POSITIVE_INFINITY,
+    patch: Number.POSITIVE_INFINITY,
+    prerelease: [],
+    build: [],
+};
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+export const MIN = {
+    major: 0,
+    minor: 0,
+    patch: 0,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A sentinel value used to denote an invalid SemVer object
+ * which may be the result of impossible ranges or comparator operations.
+ * @example
+ * ```ts
+ * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
+ * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
+ * import { INVALID } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
+ * eq(parse("1.2.3"), INVALID);
+ * ```
+ */
+export const INVALID = {
+    major: Number.NEGATIVE_INFINITY,
+    minor: Number.POSITIVE_INFINITY,
+    patch: Number.POSITIVE_INFINITY,
+    prerelease: [],
+    build: [],
+};
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ * @example
+ * ```ts
+ * import { eq } from "https://deno.land/std@$STD_VERSION/semver/eq.ts";
+ * import { parse } from "https://deno.land/std@$STD_VERSION/semver/parse.ts";
+ * import { ANY } from "https://deno.land/std@$STD_VERSION/semver/constants.ts"
+ * eq(parse("1.2.3"), ANY); // false
+ * ```
+ */
+export const ANY = {
+    major: Number.NaN,
+    minor: Number.NaN,
+    patch: Number.NaN,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export const ALL = {
+    operator: "",
+    semver: ANY,
+    min: MIN,
+    max: MAX,
+};
+/**
+ * A comparator which will not span any semantic versions
+ */
+export const NONE = {
+    operator: "<",
+    semver: MIN,
+    min: MAX,
+    max: MIN,
+};

package/esm/deps/deno.land/std@0.205.0/semver/difference.d.ts

@@ -0,0 +1,4 @@
+import type { ReleaseType, SemVer } from "./types.js";
+/** Returns difference between two versions by the release type, or
+ * `undefined` if the versions are the same. */
+export declare function difference(s0: SemVer, s1: SemVer): ReleaseType | undefined;

package/esm/deps/deno.land/std@0.205.0/semver/difference.js

@@ -0,0 +1,26 @@
+import { eq } from "./eq.js";
+/** Returns difference between two versions by the release type, or
+ * `undefined` if the versions are the same. */
+export function difference(s0, s1) {
+    if (eq(s0, s1)) {
+        return undefined;
+    }
+    else {
+        let prefix = "";
+        let defaultResult = undefined;
+        if (s0 && s1) {
+            if (s0.prerelease.length || s1.prerelease.length) {
+                prefix = "pre";
+                defaultResult = "prerelease";
+            }
+            for (const key in s0) {
+                if (key === "major" || key === "minor" || key === "patch") {
+                    if (s0[key] !== s1[key]) {
+                        return (prefix + key);
+                    }
+                }
+            }
+        }
+        return defaultResult; // may be undefined
+    }
+}

package/esm/deps/deno.land/std@0.205.0/semver/eq.d.ts

@@ -0,0 +1,4 @@
+import type { SemVer } from "./types.js";
+/** Returns `true` if they're logically equivalent, even if they're not the exact
+ * same version object. */
+export declare function eq(s0: SemVer, s1: SemVer): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/eq.js

@@ -0,0 +1,7 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { compare } from "./compare.js";
+/** Returns `true` if they're logically equivalent, even if they're not the exact
+ * same version object. */
+export function eq(s0, s1) {
+    return compare(s0, s1) === 0;
+}

package/esm/deps/deno.land/std@0.205.0/semver/format.d.ts

@@ -0,0 +1,12 @@
+import type { FormatStyle, SemVer } from "./types.js";
+/**
+ * Format a SemVer object into a string.
+ *
+ * If any number is NaN then NaN will be printed.
+ *
+ * If any number is positive or negative infinity then '∞' or '⧞' will be printed instead.
+ *
+ * @param semver The semantic version to format
+ * @returns The string representation of a semantic version.
+ */
+export declare function format(semver: SemVer, style?: FormatStyle): string;

package/esm/deps/deno.land/std@0.205.0/semver/format.js

@@ -0,0 +1,54 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { ANY } from "./constants.js";
+function formatNumber(value) {
+    if (value === Number.POSITIVE_INFINITY) {
+        return "∞";
+    }
+    else if (value === Number.NEGATIVE_INFINITY) {
+        return "⧞";
+    }
+    else {
+        return value.toFixed(0);
+    }
+}
+/**
+ * Format a SemVer object into a string.
+ *
+ * If any number is NaN then NaN will be printed.
+ *
+ * If any number is positive or negative infinity then '∞' or '⧞' will be printed instead.
+ *
+ * @param semver The semantic version to format
+ * @returns The string representation of a semantic version.
+ */
+export function format(semver, style = "full") {
+    if (semver === ANY) {
+        return "*";
+    }
+    const major = formatNumber(semver.major);
+    const minor = formatNumber(semver.minor);
+    const patch = formatNumber(semver.patch);
+    const pre = semver.prerelease.join(".");
+    const build = semver.build.join(".");
+    const primary = `${major}.${minor}.${patch}`;
+    const release = [primary, pre].filter((v) => v).join("-");
+    const full = [release, build].filter((v) => v).join("+");
+    switch (style) {
+        case "full":
+            return full;
+        case "release":
+            return release;
+        case "primary":
+            return primary;
+        case "build":
+            return build;
+        case "pre":
+            return pre;
+        case "patch":
+            return patch;
+        case "minor":
+            return minor;
+        case "major":
+            return major;
+    }
+}

package/esm/deps/deno.land/std@0.205.0/semver/gt.d.ts

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Greater than comparison */
+export declare function gt(s0: SemVer, s1: SemVer): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/gt.js

@@ -0,0 +1,5 @@
+import { compare } from "./compare.js";
+/** Greater than comparison */
+export function gt(s0, s1) {
+    return compare(s0, s1) > 0;
+}

package/esm/deps/deno.land/std@0.205.0/semver/gte.d.ts

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Greater than or equal to comparison */
+export declare function gte(s0: SemVer, s1: SemVer): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/gte.js

@@ -0,0 +1,5 @@
+import { compare } from "./compare.js";
+/** Greater than or equal to comparison */
+export function gte(s0, s1) {
+    return compare(s0, s1) >= 0;
+}

package/esm/deps/deno.land/std@0.205.0/semver/gtr.d.ts

@@ -0,0 +1,3 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/** Checks to see if the version is greater than all possible versions of the range. */
+export declare function gtr(version: SemVer, range: SemVerRange): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/gtr.js

@@ -0,0 +1,5 @@
+import { outside } from "./outside.js";
+/** Checks to see if the version is greater than all possible versions of the range. */
+export function gtr(version, range) {
+    return outside(version, range, ">");
+}

package/esm/deps/deno.land/std@0.205.0/semver/increment.d.ts

@@ -0,0 +1,28 @@
+import type { ReleaseType, SemVer } from "./types.js";
+/**
+ * Returns the new version 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.
+ * @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
+ */
+export declare function increment(version: SemVer, release: ReleaseType, prerelease?: string, build?: string): SemVer;

package/esm/deps/deno.land/std@0.205.0/semver/increment.js

@@ -0,0 +1,207 @@
+function pre(prerelease, identifier) {
+    let values = [...prerelease];
+    // In reality this will either be 0, 1 or 2 entries.
+    let i = values.length;
+    while (--i >= 0) {
+        if (typeof values[i] === "number") {
+            // deno-fmt-ignore
+            values[i]++;
+            i = -2;
+        }
+    }
+    if (i === -1) {
+        // didn't increment anything
+        values.push(0);
+    }
+    if (identifier) {
+        // 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) {
+            if (isNaN(values[1])) {
+                values = [identifier, 0];
+            }
+        }
+        else {
+            values = [identifier, 0];
+        }
+    }
+    return values;
+}
+function parseBuild(build, metadata) {
+    return metadata === undefined ? build : metadata.split(".").filter((m) => m);
+}
+/**
+ * Returns the new version 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.
+ * @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
+ */
+export function increment(version, release, prerelease, build) {
+    let result;
+    switch (release) {
+        case "premajor":
+            result = {
+                major: version.major + 1,
+                minor: 0,
+                patch: 0,
+                prerelease: pre(version.prerelease, prerelease),
+                build: parseBuild(version.build, build),
+            };
+            break;
+        case "preminor":
+            result = {
+                major: version.major,
+                minor: version.minor + 1,
+                patch: 0,
+                prerelease: pre(version.prerelease, prerelease),
+                build: parseBuild(version.build, build),
+            };
+            break;
+        case "prepatch":
+            result = {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch + 1,
+                prerelease: pre(version.prerelease, prerelease),
+                build: parseBuild(version.build, build),
+            };
+            break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+            if (version.prerelease.length === 0) {
+                result = {
+                    major: version.major,
+                    minor: version.minor,
+                    patch: version.patch + 1,
+                    prerelease: pre(version.prerelease, prerelease),
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+            else {
+                result = {
+                    major: version.major,
+                    minor: version.minor,
+                    patch: version.patch,
+                    prerelease: pre(version.prerelease, prerelease),
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+        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
+            if (version.minor !== 0 ||
+                version.patch !== 0 ||
+                version.prerelease.length === 0) {
+                result = {
+                    major: version.major + 1,
+                    minor: 0,
+                    patch: 0,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+            else {
+                result = {
+                    major: version.major,
+                    minor: 0,
+                    patch: 0,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+        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
+            if (version.patch !== 0 ||
+                version.prerelease.length === 0) {
+                result = {
+                    major: version.major,
+                    minor: version.minor + 1,
+                    patch: 0,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+            else {
+                result = {
+                    major: version.major,
+                    minor: version.minor,
+                    patch: 0,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+        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
+            if (version.prerelease.length === 0) {
+                result = {
+                    major: version.major,
+                    minor: version.minor,
+                    patch: version.patch + 1,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+            else {
+                result = {
+                    major: version.major,
+                    minor: version.minor,
+                    patch: version.patch,
+                    prerelease: [],
+                    build: parseBuild(version.build, build),
+                };
+                break;
+            }
+        // 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
+        case "pre":
+            result = {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch,
+                prerelease: pre(version.prerelease, prerelease),
+                build: parseBuild(version.build, build),
+            };
+            break;
+        default:
+            throw new Error(`invalid increment argument: ${release}`);
+    }
+    return result;
+}

package/esm/deps/deno.land/std@0.205.0/semver/is_semver.d.ts

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