keep-a-changelog 2.3.0 → 2.4.1

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

@@ -0,0 +1,248 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XRANGE = exports.TILDE = exports.STAR = exports.src = exports.re = exports.NUMERICIDENTIFIER = exports.HYPHENRANGE = exports.FULL = exports.COMPARATOR = exports.CARET = exports.isValidOperator = exports.isValidString = exports.MAX_LENGTH = exports.isValidNumber = exports.compareIdentifier = exports.checkIdentifier = exports.compareNumber = void 0;
+function compareNumber(a, b) {
+    if (isNaN(a) || isNaN(b)) {
+        throw new Error("Comparison against non-numbers");
+    }
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+exports.compareNumber = compareNumber;
+function checkIdentifier(v1, v2) {
+    // NOT having a prerelease is > having one
+    // But NOT having a build is < having one
+    if (v1.length && !v2.length) {
+        return -1;
+    }
+    else if (!v1.length && v2.length) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+exports.checkIdentifier = checkIdentifier;
+function compareIdentifier(v1, v2) {
+    let i = 0;
+    do {
+        const a = v1[i];
+        const b = v2[i];
+        if (a === undefined && b === undefined) {
+            // same length is equal
+            return 0;
+        }
+        else if (b === undefined) {
+            // longer > shorter
+            return 1;
+        }
+        else if (a === undefined) {
+            // shorter < longer
+            return -1;
+        }
+        else if (typeof a === "string" && typeof b === "number") {
+            // string > number
+            return 1;
+        }
+        else if (typeof a === "number" && typeof b === "string") {
+            // number < string
+            return -1;
+        }
+        else if (a < b) {
+            return -1;
+        }
+        else if (a > b) {
+            return 1;
+        }
+        else {
+            // If they're equal, continue comparing segments.
+            continue;
+        }
+    } while (++i);
+    // It can't ever reach here, but typescript doesn't realize that so
+    // add this line so the return type is inferred correctly.
+    return 0;
+}
+exports.compareIdentifier = compareIdentifier;
+// The actual regexps
+const re = [];
+exports.re = re;
+const src = [];
+exports.src = src;
+let R = 0;
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+const NUMERICIDENTIFIER = R++;
+exports.NUMERICIDENTIFIER = NUMERICIDENTIFIER;
+src[NUMERICIDENTIFIER] = "0|[1-9]\\d*";
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+const NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+// ## Main Version
+// Three dot-separated numeric identifiers.
+const MAINVERSION = R++;
+const nid = src[NUMERICIDENTIFIER];
+src[MAINVERSION] = `(${nid})\\.(${nid})\\.(${nid})`;
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+const PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = "(?:" + src[NUMERICIDENTIFIER] + "|" +
+    src[NONNUMERICIDENTIFIER] + ")";
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+const PRERELEASE = R++;
+src[PRERELEASE] = "(?:-(" +
+    src[PRERELEASEIDENTIFIER] +
+    "(?:\\." +
+    src[PRERELEASEIDENTIFIER] +
+    ")*))";
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+const BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+const BUILD = R++;
+src[BUILD] = "(?:\\+(" + src[BUILDIDENTIFIER] + "(?:\\." +
+    src[BUILDIDENTIFIER] + ")*))";
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+const FULL = R++;
+exports.FULL = FULL;
+const FULLPLAIN = "v?" + src[MAINVERSION] + src[PRERELEASE] + "?" + src[BUILD] +
+    "?";
+src[FULL] = "^" + FULLPLAIN + "$";
+const GTLT = R++;
+src[GTLT] = "((?:<|>)?=?)";
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifier, meaning "any version"
+// Only the first item is strictly required.
+const XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + "|x|X|\\*";
+const XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = "[v=\\s]*(" +
+    src[XRANGEIDENTIFIER] +
+    ")" +
+    "(?:\\.(" +
+    src[XRANGEIDENTIFIER] +
+    ")" +
+    "(?:\\.(" +
+    src[XRANGEIDENTIFIER] +
+    ")" +
+    "(?:" +
+    src[PRERELEASE] +
+    ")?" +
+    src[BUILD] +
+    "?" +
+    ")?)?";
+const XRANGE = R++;
+exports.XRANGE = XRANGE;
+src[XRANGE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAIN] + "$";
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+const LONETILDE = R++;
+src[LONETILDE] = "(?:~>?)";
+const TILDE = R++;
+exports.TILDE = TILDE;
+src[TILDE] = "^" + src[LONETILDE] + src[XRANGEPLAIN] + "$";
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+const LONECARET = R++;
+src[LONECARET] = "(?:\\^)";
+const CARET = R++;
+exports.CARET = CARET;
+src[CARET] = "^" + src[LONECARET] + src[XRANGEPLAIN] + "$";
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+const COMPARATOR = R++;
+exports.COMPARATOR = COMPARATOR;
+src[COMPARATOR] = "^" + src[GTLT] + "\\s*(" + FULLPLAIN + ")$|^$";
+// Something like `1.2.3 - 1.2.4`
+const HYPHENRANGE = R++;
+exports.HYPHENRANGE = HYPHENRANGE;
+src[HYPHENRANGE] = "^\\s*(" +
+    src[XRANGEPLAIN] +
+    ")" +
+    "\\s+-\\s+" +
+    "(" +
+    src[XRANGEPLAIN] +
+    ")" +
+    "\\s*$";
+// Star ranges basically just allow anything at all.
+const STAR = R++;
+exports.STAR = STAR;
+src[STAR] = "(<|>)?=?\\s*\\*";
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (let i = 0; i < R; i++) {
+    if (!re[i]) {
+        re[i] = new RegExp(src[i]);
+    }
+}
+/**
+ * Returns true if the value is a valid SemVer number.
+ *
+ * Must be a number. Must not be NaN. Can be positive or negative infinity.
+ * Can be between 0 and MAX_SAFE_INTEGER.
+ * @param value The value to check
+ * @returns True if its a valid semver number
+ */
+function isValidNumber(value) {
+    return (typeof value === "number" &&
+        !Number.isNaN(value) && (!Number.isFinite(value) ||
+        (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
+}
+exports.isValidNumber = isValidNumber;
+exports.MAX_LENGTH = 256;
+/**
+ * Returns true if the value is a valid semver pre-release or build identifier.
+ *
+ * Must be a string. Must be between 1 and 256 characters long. Must match
+ * the regular expression /[0-9A-Za-z-]+/.
+ * @param value The value to check
+ * @returns True if the value is a valid semver string.
+ */
+function isValidString(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= exports.MAX_LENGTH &&
+        !!value.match(/[0-9A-Za-z-]+/));
+}
+exports.isValidString = isValidString;
+/**
+ * Checks to see if the value is a valid Operator string.
+ *
+ * Adds a type assertion if true.
+ * @param value The value to check
+ * @returns True if the value is a valid Operator string otherwise false.
+ */
+function isValidOperator(value) {
+    if (typeof value !== "string")
+        return false;
+    switch (value) {
+        case "":
+        case "=":
+        case "==":
+        case "===":
+        case "!==":
+        case "!=":
+        case ">":
+        case ">=":
+        case "<":
+        case "<=":
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isValidOperator = isValidOperator;

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

@@ -0,0 +1,9 @@
+import type { Operator, SemVer } from "./types.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
+ */
+export declare function cmp(s0: SemVer, operator: Operator, s1: SemVer): boolean;

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