keep-a-changelog 2.3.0 → 2.5.0

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmp = void 0;
+const eq_js_1 = require("./eq.js");
+const neq_js_1 = require("./neq.js");
+const gte_js_1 = require("./gte.js");
+const gt_js_1 = require("./gt.js");
+const lt_js_1 = require("./lt.js");
+const lte_js_1 = require("./lte.js");
+/**
+ * Do a comparison of two semantic version objects based on the given operator
+ * @param s0 The left side of the comparison
+ * @param operator The operator to use for the comparison
+ * @param s1 The right side of the comparison
+ * @returns True or false based on the operator
+ */
+function cmp(s0, operator, s1) {
+    switch (operator) {
+        case "":
+        case "=":
+        case "==":
+        case "===":
+            return (0, eq_js_1.eq)(s0, s1);
+        case "!=":
+        case "!==":
+            return (0, neq_js_1.neq)(s0, s1);
+        case ">":
+            return (0, gt_js_1.gt)(s0, s1);
+        case ">=":
+            return (0, gte_js_1.gte)(s0, s1);
+        case "<":
+            return (0, lt_js_1.lt)(s0, s1);
+        case "<=":
+            return (0, lte_js_1.lte)(s0, s1);
+        default:
+            throw new TypeError(`Invalid operator: ${operator}`);
+    }
+}
+exports.cmp = cmp;

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

@@ -0,0 +1,8 @@
+import type { SemVerComparator } from "./types.js";
+/**
+ * Formats the comparator into a string
+ * @example >=0.0.0
+ * @param comparator
+ * @returns A string representation of the comparator
+ */
+export declare function comparatorFormat(comparator: SemVerComparator): string;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparatorFormat = void 0;
+const format_js_1 = require("./format.js");
+/**
+ * Formats the comparator into a string
+ * @example >=0.0.0
+ * @param comparator
+ * @returns A string representation of the comparator
+ */
+function comparatorFormat(comparator) {
+    const { semver, operator } = comparator;
+    return `${operator}${(0, format_js_1.format)(semver)}`;
+}
+exports.comparatorFormat = comparatorFormat;

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

@@ -0,0 +1,8 @@
+import type { SemVerComparator } from "./types.js";
+/**
+ * Returns true if the range of possible versions intersects with the other comparators set of possible versions
+ * @param c0 The left side comparator
+ * @param c1 The right side comparator
+ * @returns True if any part of the comparators intersect
+ */
+export declare function comparatorIntersects(c0: SemVerComparator, c1: SemVerComparator): boolean;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparatorIntersects = void 0;
+const gte_js_1 = require("./gte.js");
+const lte_js_1 = require("./lte.js");
+/**
+ * Returns true if the range of possible versions intersects with the other comparators set of possible versions
+ * @param c0 The left side comparator
+ * @param c1 The right side comparator
+ * @returns True if any part of the comparators intersect
+ */
+function comparatorIntersects(c0, c1) {
+    const l0 = c0.min;
+    const l1 = c0.max;
+    const r0 = c1.min;
+    const r1 = c1.max;
+    // We calculate the min and max ranges of both comparators.
+    // The minimum min is 0.0.0, the maximum max is ANY.
+    //
+    // Comparators with equality operators have the same min and max.
+    //
+    // We then check to see if the min's of either range falls within the span of the other range.
+    //
+    // A couple of intersection examples:
+    // ```
+    // l0 ---- l1
+    //     r0 ---- r1
+    // ```
+    // ```
+    //     l0 ---- l1
+    // r0 ---- r1
+    // ```
+    // ```
+    // l0 ------ l1
+    //    r0--r1
+    // ```
+    // ```
+    // l0 - l1
+    // r0 - r1
+    // ```
+    //
+    // non-intersection example
+    // ```
+    // l0 -- l1
+    //          r0 -- r1
+    // ```
+    return ((0, gte_js_1.gte)(l0, r0) && (0, lte_js_1.lte)(l0, r1)) || ((0, gte_js_1.gte)(r0, l0) && (0, lte_js_1.lte)(r0, l1));
+}
+exports.comparatorIntersects = comparatorIntersects;

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

@@ -0,0 +1,9 @@
+import type { Operator, SemVer } from "./types.js";
+/**
+ * The maximum version that could match this comparator.
+ *
+ * If an invalid comparator is given such as <0.0.0 then
+ * an out of range semver will be returned.
+ * @returns the version, the MAX version or the next smallest patch version
+ */
+export declare function comparatorMax(semver: SemVer, operator: Operator): SemVer;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparatorMax = void 0;
+const constants_js_1 = require("./constants.js");
+/**
+ * The maximum version that could match this comparator.
+ *
+ * If an invalid comparator is given such as <0.0.0 then
+ * an out of range semver will be returned.
+ * @returns the version, the MAX version or the next smallest patch version
+ */
+function comparatorMax(semver, operator) {
+    if (semver === constants_js_1.ANY) {
+        return constants_js_1.MAX;
+    }
+    switch (operator) {
+        case "!=":
+        case "!==":
+        case ">":
+        case ">=":
+            return constants_js_1.MAX;
+        case "":
+        case "=":
+        case "==":
+        case "===":
+        case "<=":
+            return semver;
+        case "<": {
+            const patch = semver.patch - 1;
+            const minor = patch >= 0 ? semver.minor : semver.minor - 1;
+            const major = minor >= 0 ? semver.major : semver.major - 1;
+            // if you try to do <0.0.0 it will Give you -∞.∞.∞
+            // which means no SemVer can compare successfully to it.
+            if (major < 0) {
+                return constants_js_1.INVALID;
+            }
+            else {
+                return {
+                    major,
+                    minor: minor >= 0 ? minor : Number.POSITIVE_INFINITY,
+                    patch: patch >= 0 ? patch : Number.POSITIVE_INFINITY,
+                    prerelease: [],
+                    build: [],
+                };
+            }
+        }
+    }
+}
+exports.comparatorMax = comparatorMax;

package/script/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/script/deps/deno.land/std@0.205.0/semver/comparator_min.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparatorMin = void 0;
+const constants_js_1 = require("./constants.js");
+const gt_js_1 = require("./gt.js");
+const increment_js_1 = require("./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
+ */
+function comparatorMin(semver, operator) {
+    if (semver === constants_js_1.ANY) {
+        return constants_js_1.MIN;
+    }
+    switch (operator) {
+        case ">":
+            return semver.prerelease.length > 0
+                ? (0, increment_js_1.increment)(semver, "pre")
+                : (0, increment_js_1.increment)(semver, "patch");
+        case "!=":
+        case "!==":
+        case "<=":
+        case "<":
+            // The min(<0.0.0) is MAX
+            return (0, gt_js_1.gt)(semver, constants_js_1.MIN) ? constants_js_1.MIN : constants_js_1.MAX;
+        case ">=":
+        case "":
+        case "=":
+        case "==":
+        case "===":
+            return semver;
+    }
+}
+exports.comparatorMin = comparatorMin;

package/script/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/script/deps/deno.land/std@0.205.0/semver/compare.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = void 0;
+const _shared_js_1 = require("./_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()`,
+ */
+function compare(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return ((0, _shared_js_1.compareNumber)(s0.major, s1.major) ||
+        (0, _shared_js_1.compareNumber)(s0.minor, s1.minor) ||
+        (0, _shared_js_1.compareNumber)(s0.patch, s1.patch) ||
+        (0, _shared_js_1.checkIdentifier)(s0.prerelease, s1.prerelease) ||
+        (0, _shared_js_1.compareIdentifier)(s0.prerelease, s1.prerelease));
+}
+exports.compare = compare;

package/script/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/script/deps/deno.land/std@0.205.0/semver/compare_build.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareBuild = void 0;
+const _shared_js_1 = require("./_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
+ */
+function compareBuild(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return ((0, _shared_js_1.compareNumber)(s0.major, s1.major) ||
+        (0, _shared_js_1.compareNumber)(s0.minor, s1.minor) ||
+        (0, _shared_js_1.compareNumber)(s0.patch, s1.patch) ||
+        (0, _shared_js_1.checkIdentifier)(s0.prerelease, s1.prerelease) ||
+        (0, _shared_js_1.compareIdentifier)(s0.prerelease, s1.prerelease) ||
+        (0, _shared_js_1.checkIdentifier)(s1.build, s0.build) ||
+        (0, _shared_js_1.compareIdentifier)(s0.build, s1.build));
+}
+exports.compareBuild = compareBuild;

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