keep-a-changelog 2.2.1 → 2.4.1

package/esm/deps/deno.land/{std@0.173.0 → std@0.189.0}/path/win32.js

@@ -4,7 +4,7 @@
 // This module is browser compatible.
 import * as dntShim from "../../../../_dnt.shims.js";
 import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "./_constants.js";
-import { _format, assertPath, encodeWhitespace, isPathSeparator, isWindowsDeviceRoot, normalizeString, } from "./_util.js";
+import { _format, assertPath, encodeWhitespace, isPathSeparator, isPosixPathSeparator, isWindowsDeviceRoot, lastPathSegment, normalizeString, stripSuffix, stripTrailingSeparators, } from "./_util.js";
 import { assert } from "../_util/asserts.js";
 export const sep = "\\";
 export const delimiter = ";";
@@ -508,7 +508,7 @@ export function toNamespacedPath(path) {
 }
 /**
  * Return the directory path of a `path`.
- * @param path to determine the directory path for
+ * @param path - path to extract the directory from.
  */
 export function dirname(path) {
     assertPath(path);
@@ -598,25 +598,26 @@ export function dirname(path) {
         else
             end = rootEnd;
     }
-    return path.slice(0, end);
+    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
 }
 /**
- * Return the last portion of a `path`. Trailing directory separators are ignored.
- * @param path to process
- * @param ext of path directory
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract name from.
+ * @param [suffix] - suffix to remove from extracted name.
  */
-export function basename(path, ext = "") {
-    if (ext !== undefined && typeof ext !== "string") {
-        throw new TypeError('"ext" argument must be a string');
-    }
+export function basename(path, suffix = "") {
     assertPath(path);
-    let start = 0;
-    let end = -1;
-    let matchedSlash = true;
-    let i;
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
     // Check for a drive letter prefix so as not to mistake the following
     // path separator as an extra separator at the end of the path that can be
     // disregarded
+    let start = 0;
     if (path.length >= 2) {
         const drive = path.charCodeAt(0);
         if (isWindowsDeviceRoot(drive)) {
@@ -624,73 +625,9 @@ export function basename(path, ext = "") {
                 start = 2;
         }
     }
-    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
-        if (ext.length === path.length && ext === path)
-            return "";
-        let extIdx = ext.length - 1;
-        let firstNonSlashEnd = -1;
-        for (i = path.length - 1; i >= start; --i) {
-            const code = path.charCodeAt(i);
-            if (isPathSeparator(code)) {
-                // If we reached a path separator that was not part of a set of path
-                // separators at the end of the string, stop now
-                if (!matchedSlash) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else {
-                if (firstNonSlashEnd === -1) {
-                    // We saw the first non-path separator, mark this as the end of our
-                    // path component in case we don't match a whole suffix
-                    matchedSlash = false;
-                    firstNonSlashEnd = i + 1;
-                    end = firstNonSlashEnd;
-                }
-                if (extIdx >= 0) {
-                    // Try to match the explicit suffix
-                    if (code === ext.charCodeAt(extIdx)) {
-                        if (--extIdx === -1) {
-                            // We matched whole suffix, so mark this as the end of our path
-                            // component
-                            end = i;
-                        }
-                    }
-                    else {
-                        // Suffix character does not match, so bail out early
-                        // from checking rest of characters
-                        extIdx = -1;
-                    }
-                }
-            }
-        }
-        if (end === -1)
-            return "";
-        if (start === end)
-            end = firstNonSlashEnd;
-        return path.slice(start, end);
-    }
-    else {
-        for (i = path.length - 1; i >= start; --i) {
-            if (isPathSeparator(path.charCodeAt(i))) {
-                // If we reached a path separator that was not part of a set of path
-                // separators at the end of the string, stop now
-                if (!matchedSlash) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else if (end === -1) {
-                // We saw the first non-path separator, mark this as the end of our
-                // path component
-                matchedSlash = false;
-                end = i + 1;
-            }
-        }
-        if (end === -1)
-            return "";
-        return path.slice(start, end);
-    }
+    const lastSegment = lastPathSegment(path, isPathSeparator, start);
+    const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
+    return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
 }
 /**
  * Return the extension of the `path` with leading period.
@@ -829,13 +766,14 @@ export function parse(path) {
                             // `path` contains just a drive root, exit early to avoid
                             // unnecessary work
                             ret.root = ret.dir = path;
+                            ret.base = "\\";
                             return ret;
                         }
                         rootEnd = 3;
                     }
                 }
                 else {
-                    // `path` contains just a drive root, exit early to avoid
+                    // `path` contains just a relative drive root, exit early to avoid
                     // unnecessary work
                     ret.root = ret.dir = path;
                     return ret;
@@ -847,6 +785,7 @@ export function parse(path) {
         // `path` contains just a path separator, exit early to avoid
         // unnecessary work
         ret.root = ret.dir = path;
+        ret.base = "\\";
         return ret;
     }
     if (rootEnd > 0)
@@ -905,6 +844,8 @@ export function parse(path) {
         ret.base = path.slice(startPart, end);
         ret.ext = path.slice(startDot, end);
     }
+    // Fallback to '\' in case there is no basename
+    ret.base = ret.base || "\\";
     // If the directory is the root, use the entire root as the `dir` including
     // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
     // trailing slash (`C:\abc\def` -> `C:\abc`).

package/esm/deps/deno.land/std@0.203.0/semver/_shared.d.ts

@@ -0,0 +1,42 @@
+import { Operator } from "./types.js";
+export declare function compareNumber(a: number, b: number): 1 | 0 | -1;
+export declare function checkIdentifier(v1: ReadonlyArray<string | number>, v2: ReadonlyArray<string | number>): 1 | 0 | -1;
+export declare function compareIdentifier(v1: ReadonlyArray<string | number>, v2: ReadonlyArray<string | number>): 1 | 0 | -1;
+declare const re: RegExp[];
+declare const src: string[];
+declare const NUMERICIDENTIFIER: number;
+declare const FULL: number;
+declare const XRANGE: number;
+declare const TILDE: number;
+declare const CARET: number;
+declare const COMPARATOR: number;
+declare const HYPHENRANGE: number;
+declare const STAR: number;
+/**
+ * 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
+ */
+export declare function isValidNumber(value: unknown): value is number;
+export declare const 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.
+ */
+export declare function isValidString(value: unknown): value is string;
+/**
+ * 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.
+ */
+export declare function isValidOperator(value: unknown): value is Operator;
+export { CARET, COMPARATOR, FULL, HYPHENRANGE, NUMERICIDENTIFIER, re, src, STAR, TILDE, XRANGE, };

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

@@ -0,0 +1,230 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export function compareNumber(a, b) {
+    if (isNaN(a) || isNaN(b)) {
+        throw new Error("Comparison against non-numbers");
+    }
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+export 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;
+    }
+}
+export 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;
+}
+// The actual regexps
+const re = [];
+const 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++;
+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++;
+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++;
+src[XRANGE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAIN] + "$";
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+const LONETILDE = R++;
+src[LONETILDE] = "(?:~>?)";
+const TILDE = R++;
+src[TILDE] = "^" + src[LONETILDE] + src[XRANGEPLAIN] + "$";
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+const LONECARET = R++;
+src[LONECARET] = "(?:\\^)";
+const CARET = R++;
+src[CARET] = "^" + src[LONECARET] + src[XRANGEPLAIN] + "$";
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+const COMPARATOR = R++;
+src[COMPARATOR] = "^" + src[GTLT] + "\\s*(" + FULLPLAIN + ")$|^$";
+// Something like `1.2.3 - 1.2.4`
+const HYPHENRANGE = R++;
+src[HYPHENRANGE] = "^\\s*(" +
+    src[XRANGEPLAIN] +
+    ")" +
+    "\\s+-\\s+" +
+    "(" +
+    src[XRANGEPLAIN] +
+    ")" +
+    "\\s*$";
+// Star ranges basically just allow anything at all.
+const STAR = R++;
+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
+ */
+export function isValidNumber(value) {
+    return (typeof value === "number" &&
+        !Number.isNaN(value) && (!Number.isFinite(value) ||
+        (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
+}
+export const 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.
+ */
+export function isValidString(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= MAX_LENGTH &&
+        !!value.match(/[0-9A-Za-z-]+/));
+}
+/**
+ * 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.
+ */
+export 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;
+    }
+}
+export { CARET, COMPARATOR, FULL, HYPHENRANGE, NUMERICIDENTIFIER, re, src, STAR, TILDE, XRANGE, };

package/esm/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/esm/deps/deno.land/std@0.203.0/semver/cmp.js

@@ -0,0 +1,35 @@
+import { eq } from "./eq.js";
+import { neq } from "./neq.js";
+import { gte } from "./gte.js";
+import { gt } from "./gt.js";
+import { lt } from "./lt.js";
+import { lte } from "./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
+ */
+export function cmp(s0, operator, s1) {
+    switch (operator) {
+        case "":
+        case "=":
+        case "==":
+        case "===":
+            return eq(s0, s1);
+        case "!=":
+        case "!==":
+            return neq(s0, s1);
+        case ">":
+            return gt(s0, s1);
+        case ">=":
+            return gte(s0, s1);
+        case "<":
+            return lt(s0, s1);
+        case "<=":
+            return lte(s0, s1);
+        default:
+            throw new TypeError(`Invalid operator: ${operator}`);
+    }
+}

package/esm/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/esm/deps/deno.land/std@0.203.0/semver/comparator_format.js

@@ -0,0 +1,11 @@
+import { format } from "./format.js";
+/**
+ * Formats the comparator into a string
+ * @example >=0.0.0
+ * @param comparator
+ * @returns A string representation of the comparator
+ */
+export function comparatorFormat(comparator) {
+    const { semver, operator } = comparator;
+    return `${operator}${format(semver)}`;
+}

package/esm/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/esm/deps/deno.land/std@0.203.0/semver/comparator_intersects.js

@@ -0,0 +1,45 @@
+import { gte } from "./gte.js";
+import { lte } from "./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
+ */
+export 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 (gte(l0, r0) && lte(l0, r1)) || (gte(r0, l0) && lte(r0, l1));
+}

package/esm/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/esm/deps/deno.land/std@0.203.0/semver/comparator_max.js

@@ -0,0 +1,45 @@
+import { ANY, INVALID, MAX } from "./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
+ */
+export function comparatorMax(semver, operator) {
+    if (semver === ANY) {
+        return MAX;
+    }
+    switch (operator) {
+        case "!=":
+        case "!==":
+        case ">":
+        case ">=":
+            return 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 INVALID;
+            }
+            else {
+                return {
+                    major,
+                    minor: minor >= 0 ? minor : Number.POSITIVE_INFINITY,
+                    patch: patch >= 0 ? patch : Number.POSITIVE_INFINITY,
+                    prerelease: [],
+                    build: [],
+                };
+            }
+        }
+    }
+}

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