keep-a-changelog 2.3.0 → 2.4.1

package/script/deps/deno.land/std@0.203.0/semver/constants.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NONE = exports.ALL = exports.ANY = exports.INVALID = exports.MIN = exports.MAX = void 0;
+/**
+ * MAX is a sentinel value used by some range calculations.
+ * It is equivalent to `∞.∞.∞`.
+ */
+exports.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`.
+ */
+exports.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);
+ * ```
+ */
+exports.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
+ * ```
+ */
+exports.ANY = {
+    major: Number.NaN,
+    minor: Number.NaN,
+    patch: Number.NaN,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A comparator which will span all valid semantic versions
+ */
+exports.ALL = {
+    operator: "",
+    semver: exports.ANY,
+    min: exports.MIN,
+    max: exports.MAX,
+};
+/**
+ * A comparator which will not span any semantic versions
+ */
+exports.NONE = {
+    operator: "<",
+    semver: exports.MIN,
+    min: exports.MAX,
+    max: exports.MIN,
+};

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/difference.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.difference = void 0;
+const eq_js_1 = require("./eq.js");
+/** Returns difference between two versions by the release type, or
+ * `undefined` if the versions are the same. */
+function difference(s0, s1) {
+    if ((0, eq_js_1.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
+    }
+}
+exports.difference = difference;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/eq.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eq = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const compare_js_1 = require("./compare.js");
+/** Returns `true` if they're logically equivalent, even if they're not the exact
+ * same version object. */
+function eq(s0, s1) {
+    return (0, compare_js_1.compare)(s0, s1) === 0;
+}
+exports.eq = eq;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/format.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const constants_js_1 = require("./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.
+ */
+function format(semver, style = "full") {
+    if (semver === constants_js_1.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;
+    }
+}
+exports.format = format;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/gt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gt = void 0;
+const compare_js_1 = require("./compare.js");
+/** Greater than comparison */
+function gt(s0, s1) {
+    return (0, compare_js_1.compare)(s0, s1) > 0;
+}
+exports.gt = gt;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/gte.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gte = void 0;
+const compare_js_1 = require("./compare.js");
+/** Greater than or equal to comparison */
+function gte(s0, s1) {
+    return (0, compare_js_1.compare)(s0, s1) >= 0;
+}
+exports.gte = gte;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/gtr.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gtr = void 0;
+const outside_js_1 = require("./outside.js");
+/** Checks to see if the version is greater than all possible versions of the range. */
+function gtr(version, range) {
+    return (0, outside_js_1.outside)(version, range, ">");
+}
+exports.gtr = gtr;

package/script/deps/deno.land/std@0.203.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/script/deps/deno.land/std@0.203.0/semver/increment.js

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

package/script/deps/deno.land/std@0.203.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;

package/script/deps/deno.land/std@0.203.0/semver/is_semver.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemVer = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const constants_js_1 = require("./constants.js");
+const _shared_js_1 = require("./_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.
+ * @param value The value to check to see if its a valid SemVer object
+ * @returns True if value is a valid SemVer otherwise false
+ */
+function isSemVer(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value !== "object")
+        return false;
+    if (value === constants_js_1.INVALID)
+        return true;
+    if (value === constants_js_1.ANY)
+        return true;
+    const { major, minor, patch, build, prerelease } = value;
+    const result = typeof major === "number" && (0, _shared_js_1.isValidNumber)(major) &&
+        typeof minor === "number" && (0, _shared_js_1.isValidNumber)(minor) &&
+        typeof patch === "number" && (0, _shared_js_1.isValidNumber)(patch) &&
+        Array.isArray(prerelease) &&
+        Array.isArray(build) &&
+        prerelease.every((v) => typeof v === "string" || typeof v === "number") &&
+        prerelease.filter((v) => typeof v === "string").every((v) => (0, _shared_js_1.isValidString)(v)) &&
+        prerelease.filter((v) => typeof v === "number").every((v) => (0, _shared_js_1.isValidNumber)(v)) &&
+        build.every((v) => typeof v === "string" && (0, _shared_js_1.isValidString)(v));
+    return result;
+}
+exports.isSemVer = isSemVer;

package/script/deps/deno.land/std@0.203.0/semver/is_semver_comparator.d.ts

@@ -0,0 +1,12 @@
+import type { SemVerComparator } from "./types.js";
+/**
+ * Does a deep check on the value to see if it is a valid SemVerComparator object.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ * @param value The value to check if its a SemVerComparator
+ * @returns True if the object is a SemVerComparator otherwise false
+ */
+export declare function isSemVerComparator(value: unknown): value is SemVerComparator;

package/script/deps/deno.land/std@0.203.0/semver/is_semver_comparator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemVerComparator = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const is_semver_js_1 = require("./is_semver.js");
+const _shared_js_1 = require("./_shared.js");
+const constants_js_1 = require("./constants.js");
+/**
+ * Does a deep check on the value to see if it is a valid SemVerComparator object.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ * @param value The value to check if its a SemVerComparator
+ * @returns True if the object is a SemVerComparator otherwise false
+ */
+function isSemVerComparator(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (value === constants_js_1.NONE)
+        return true;
+    if (value === constants_js_1.ALL)
+        return true;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value !== "object")
+        return false;
+    const { operator, semver, min, max } = value;
+    return ((0, _shared_js_1.isValidOperator)(operator) &&
+        (0, is_semver_js_1.isSemVer)(semver) &&
+        (0, is_semver_js_1.isSemVer)(min) &&
+        (0, is_semver_js_1.isSemVer)(max));
+}
+exports.isSemVerComparator = isSemVerComparator;

package/script/deps/deno.land/std@0.203.0/semver/is_semver_range.d.ts

@@ -0,0 +1,12 @@
+import type { SemVerRange } 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.
+ * @param value The value to check if its a valid SemVerRange
+ * @returns True if its a valid SemVerRange otherwise false.
+ */
+export declare function isSemVerRange(value: unknown): value is SemVerRange;

package/script/deps/deno.land/std@0.203.0/semver/is_semver_range.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemVerRange = void 0;
+const is_semver_comparator_js_1 = require("./is_semver_comparator.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.
+ * @param value The value to check if its a valid SemVerRange
+ * @returns True if its a valid SemVerRange otherwise false.
+ */
+function isSemVerRange(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value !== "object")
+        return false;
+    const { ranges } = value;
+    return (Array.isArray(ranges),
+        ranges.every((r) => Array.isArray(r) && r.every((c) => (0, is_semver_comparator_js_1.isSemVerComparator)(c))));
+}
+exports.isSemVerRange = isSemVerRange;

package/script/deps/deno.land/std@0.203.0/semver/lt.d.ts

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

package/script/deps/deno.land/std@0.203.0/semver/lt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lt = void 0;
+const compare_js_1 = require("./compare.js");
+/** Less than comparison */
+function lt(s0, s1) {
+    return (0, compare_js_1.compare)(s0, s1) < 0;
+}
+exports.lt = lt;

package/script/deps/deno.land/std@0.203.0/semver/lte.d.ts

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