keep-a-changelog 2.3.0 → 2.5.0

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

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

package/script/deps/deno.land/std@0.205.0/semver/lte.js

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

package/script/deps/deno.land/std@0.205.0/semver/ltr.d.ts

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

package/script/deps/deno.land/std@0.205.0/semver/ltr.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ltr = void 0;
+const outside_js_1 = require("./outside.js");
+/** Greater than range comparison */
+function ltr(version, range) {
+    return (0, outside_js_1.outside)(version, range, "<");
+}
+exports.ltr = ltr;

package/script/deps/deno.land/std@0.205.0/semver/max_satisfying.d.ts

@@ -0,0 +1,9 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Returns the highest version in the list that satisfies the range, or `undefined`
+ * if none of them do.
+ * @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: SemVerRange): SemVer | undefined;

package/script/deps/deno.land/std@0.205.0/semver/max_satisfying.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSatisfying = void 0;
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * Returns the highest version in the list that satisfies the range, or `undefined`
+ * if none of them do.
+ * @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.
+ */
+function maxSatisfying(versions, range) {
+    const satisfying = versions.filter((v) => (0, test_range_js_1.testRange)(v, range));
+    const sorted = (0, sort_js_1.sort)(satisfying);
+    return sorted.pop();
+}
+exports.maxSatisfying = maxSatisfying;

package/script/deps/deno.land/std@0.205.0/semver/min_satisfying.d.ts

@@ -0,0 +1,9 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * none of them do.
+ * @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: SemVerRange): SemVer | undefined;

package/script/deps/deno.land/std@0.205.0/semver/min_satisfying.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minSatisfying = void 0;
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * none of them do.
+ * @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.
+ */
+function minSatisfying(versions, range) {
+    const satisfying = versions.filter((v) => (0, test_range_js_1.testRange)(v, range));
+    const sorted = (0, sort_js_1.sort)(satisfying);
+    return sorted.shift();
+}
+exports.minSatisfying = minSatisfying;