keep-a-changelog 2.3.0 → 2.5.0

package/esm/deps/deno.land/std@0.205.0/semver/mod.js

@@ -0,0 +1,313 @@
+// Copyright Isaac Z. Schlueter and Contributors. All rights reserved. ISC license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * The semantic version parser.
+ *
+ * Adapted directly from [semver](https://github.com/npm/node-semver).
+ *
+ * ## Versions
+ *
+ * A "version" is described by the `v2.0.0` specification found at
+ * <https://semver.org>.
+ *
+ * A leading `"="` or `"v"` character is stripped off and ignored.
+ *
+ * ## Format
+ *
+ * Semantic versions can be formatted as strings, by default they
+ * are formatted as `full`. Below is a diagram showing the various
+ * formatting options.
+ *
+ * ```
+ *           ┌───── full
+ *       ┌───┴───┐
+ *       ├───────── release
+ *   ┌───┴───┐   │
+ *   ├───────────── primary
+ * ┌─┴─┐     │   │
+ * 1.2.3-pre.1+b.1
+ * │ │ │ └─┬─┘ └┬┘
+ * │ │ │   │    └── build
+ * │ │ │   └─────── pre
+ * │ │ └─────────── patch
+ * │ └───────────── minor
+ * └─────────────── major
+ * ```
+ *
+ * ## Ranges
+ *
+ * A `version range` is a set of `comparators` which specify versions that satisfy
+ * the range.
+ *
+ * A `comparator` is composed of an `operator` and a `version`. The set of
+ * primitive `operators` is:
+ *
+ * - `<` Less than
+ * - `<=` Less than or equal to
+ * - `>` Greater than
+ * - `>=` Greater than or equal to
+ * - `=` Equal. If no operator is specified, then equality is assumed, so this
+ *   operator is optional, but MAY be included.
+ *
+ * For example, the comparator `>=1.2.7` would match the versions `1.2.7`, `1.2.8`,
+ * `2.5.3`, and `1.3.9`, but not the versions `1.2.6` or `1.1.0`.
+ *
+ * Comparators can be joined by whitespace to form a `comparator set`, which is
+ * satisfied by the **intersection** of all of the comparators it includes.
+ *
+ * A range is composed of one or more comparator sets, joined by `||`. A version
+ * matches a range if and only if every comparator in at least one of the
+ * `||`-separated comparator sets is satisfied by the version.
+ *
+ * For example, the range `>=1.2.7 <1.3.0` would match the versions `1.2.7`,
+ * `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`, or `1.1.0`.
+ *
+ * The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`, `1.2.9`,
+ * and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+ *
+ * ### Prerelease Tags
+ *
+ * If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then it will
+ * only be allowed to satisfy comparator sets if at least one comparator with the
+ * same `[major, minor, patch]` tuple also has a prerelease tag.
+ *
+ * For example, the range `>1.2.3-alpha.3` would be allowed to match the version
+ * `1.2.3-alpha.7`, but it would _not_ be satisfied by `3.4.5-alpha.9`, even though
+ * `3.4.5-alpha.9` is technically "greater than" `1.2.3-alpha.3` according to the
+ * SemVer sort rules. The version range only accepts prerelease tags on the `1.2.3`
+ * version. The version `3.4.5` _would_ satisfy the range, because it does not have
+ * a prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+ *
+ * The purpose for this behavior is twofold. First, prerelease versions frequently
+ * are updated very quickly, and contain many breaking changes that are (by the
+ * author"s design) not yet fit for public consumption. Therefore, by default, they
+ * are excluded from range matching semantics.
+ *
+ * Second, a user who has opted into using a prerelease version has clearly
+ * indicated the intent to use _that specific_ set of alpha/beta/rc versions. By
+ * including a prerelease tag in the range, the user is indicating that they are
+ * aware of the risk. However, it is still not appropriate to assume that they have
+ * opted into taking a similar risk on the _next_ set of prerelease versions.
+ *
+ * Note that this behavior can be suppressed (treating all prerelease versions as
+ * if they were normal versions, for the purpose of range matching) by setting the
+ * `includePrerelease` flag on the options object to any [functions](#functions)
+ * that do range matching.
+ *
+ * #### Prerelease Identifiers
+ *
+ * The method `.increment` takes an additional `identifier` string argument that
+ * will append the value of the string as a prerelease identifier:
+ *
+ * ```javascript
+ * semver.increment(parse("1.2.3"), "prerelease", "beta");
+ * // "1.2.4-beta.0"
+ * ```
+ *
+ * ### Build Metadata
+ *
+ * Build metadata is `.` delimited alpha-numeric string.
+ * When parsing a version it is retained on the `build: string[]` field
+ * of the semver instance. When incrementing there is an additional parameter that
+ * can set the build metadata on the semver instance.
+ *
+ * ### Advanced Range Syntax
+ *
+ * Advanced range syntax desugars to primitive comparators in deterministic ways.
+ *
+ * Advanced ranges may be combined in the same way as primitive comparators using
+ * white space or `||`.
+ *
+ * #### Hyphen Ranges `X.Y.Z - A.B.C`
+ *
+ * Specifies an inclusive set.
+ *
+ * - `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+ *
+ * If a partial version is provided as the first version in the inclusive range,
+ * then the missing pieces are replaced with zeroes.
+ *
+ * - `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+ *
+ * If a partial version is provided as the second version in the inclusive range,
+ * then all versions that start with the supplied parts of the tuple are accepted,
+ * but nothing that would be greater than the provided tuple parts.
+ *
+ * - `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+ * - `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+ *
+ * #### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+ *
+ * Any of `X`, `x`, or `*` may be used to "stand in" for one of the numeric values
+ * in the `[major, minor, patch]` tuple.
+ *
+ * - `*` := `>=0.0.0` (Any version satisfies)
+ * - `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+ * - `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+ *
+ * A partial version range is treated as an X-Range, so the special character is in
+ * fact optional.
+ *
+ * - `""` (empty string) := `*` := `>=0.0.0`
+ * - `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+ * - `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+ *
+ * #### Tilde Ranges `~1.2.3` `~1.2` `~1`
+ *
+ * Allows patch-level changes if a minor version is specified on the comparator.
+ * Allows minor-level changes if not.
+ *
+ * - `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+ * - `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+ * - `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+ * - `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+ * - `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+ * - `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+ * - `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in the
+ *   `1.2.3` version will be allowed, if they are greater than or equal to
+ *   `beta.2`. So, `1.2.3-beta.4` would be allowed, but `1.2.4-beta.2` would not,
+ *   because it is a prerelease of a different `[major, minor, patch]` tuple.
+ *
+ * #### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+ *
+ * Allows changes that do not modify the left-most non-zero element in the
+ * `[major, minor, patch]` tuple. In other words, this allows patch and minor
+ * updates for versions `1.0.0` and above, patch updates for versions
+ * `0.X >=0.1.0`, and _no_ updates for versions `0.0.X`.
+ *
+ * Many authors treat a `0.x` version as if the `x` were the major
+ * "breaking-change" indicator.
+ *
+ * Caret ranges are ideal when an author may make breaking changes between `0.2.4`
+ * and `0.3.0` releases, which is a common practice. However, it presumes that
+ * there will _not_ be breaking changes between `0.2.4` and `0.2.5`. It allows for
+ * changes that are presumed to be additive (but non-breaking), according to
+ * commonly observed practices.
+ *
+ * - `^1.2.3` := `>=1.2.3 <2.0.0`
+ * - `^0.2.3` := `>=0.2.3 <0.3.0`
+ * - `^0.0.3` := `>=0.0.3 <0.0.4`
+ * - `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in the
+ *   `1.2.3` version will be allowed, if they are greater than or equal to
+ *   `beta.2`. So, `1.2.3-beta.4` would be allowed, but `1.2.4-beta.2` would not,
+ *   because it is a prerelease of a different `[major, minor, patch]` tuple.
+ * - `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the `0.0.3`
+ *   version _only_ will be allowed, if they are greater than or equal to `beta`.
+ *   So, `0.0.3-pr.2` would be allowed.
+ *
+ * When parsing caret ranges, a missing `patch` value desugars to the number `0`,
+ * but will allow flexibility within that value, even if the major and minor
+ * versions are both `0`.
+ *
+ * - `^1.2.x` := `>=1.2.0 <2.0.0`
+ * - `^0.0.x` := `>=0.0.0 <0.1.0`
+ * - `^0.0` := `>=0.0.0 <0.1.0`
+ *
+ * A missing `minor` and `patch` values will desugar to zero, but also allow
+ * flexibility within those values, even if the major version is zero.
+ *
+ * - `^1.x` := `>=1.0.0 <2.0.0`
+ * - `^0.x` := `>=0.0.0 <1.0.0`
+ *
+ * ### Range Grammar
+ *
+ * Putting all this together, here is a Backus-Naur grammar for ranges, for the
+ * benefit of parser authors:
+ *
+ * ```bnf
+ * range-set  ::= range ( logical-or range ) *
+ * logical-or ::= ( " " ) * "||" ( " " ) *
+ * range      ::= hyphen | simple ( " " simple ) * | ""
+ * hyphen     ::= partial " - " partial
+ * simple     ::= primitive | partial | tilde | caret
+ * primitive  ::= ( "<" | ">" | ">=" | "<=" | "=" ) partial
+ * partial    ::= xr ( "." xr ( "." xr qualifier ? )? )?
+ * xr         ::= "x" | "X" | "*" | nr
+ * nr         ::= "0" | ["1"-"9"] ( ["0"-"9"] ) *
+ * tilde      ::= "~" partial
+ * caret      ::= "^" partial
+ * qualifier  ::= ( "-" pre )? ( "+" build )?
+ * pre        ::= parts
+ * build      ::= parts
+ * parts      ::= part ( "." part ) *
+ * part       ::= nr | [-0-9A-Za-z]+
+ * ```
+ *
+ * Note that, since ranges may be non-contiguous, a version might not be greater
+ * than a range, less than a range, _or_ satisfy a range! For example, the range
+ * `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9` until `2.0.0`, so the
+ * version `1.2.10` would not be greater than the range (because `2.0.1` satisfies,
+ * which is higher), nor less than the range (since `1.2.8` satisfies, which is
+ * lower), and it also does not satisfy the range.
+ *
+ * If you want to know if a version satisfies or does not satisfy a range, use the
+ * {@linkcode satisfies} function.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   parse,
+ *   parseComparator,
+ *   parseRange,
+ *   gt,
+ *   lt,
+ *   format
+ * } from "https://deno.land/std@$STD_VERSION/semver/mod.ts";
+ *
+ * const semver = parse("1.2.3");
+ * const range = parseRange("1.x || >=2.5.0 || 5.0.0 - 7.2.3");
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("9.8.7");
+ * gt(s0, s1); // false
+ * lt(s0, s1); // true
+ *
+ * format(semver) // "1.2.3"
+ * ```
+ *
+ * @module
+ */
+export * from "./cmp.js";
+export * from "./comparator_format.js";
+export * from "./comparator_intersects.js";
+export * from "./comparator_max.js";
+export * from "./comparator_min.js";
+export * from "./compare_build.js";
+export * from "./compare.js";
+export * from "./constants.js";
+export * from "./difference.js";
+export * from "./eq.js";
+export * from "./format.js";
+export * from "./gt.js";
+export * from "./gte.js";
+export * from "./gtr.js";
+export * from "./test_comparator.js";
+export * from "./test_range.js";
+export * from "./increment.js";
+export * from "./is_semver_comparator.js";
+export * from "./is_semver_range.js";
+export * from "./is_semver.js";
+export * from "./lt.js";
+export * from "./lte.js";
+export * from "./ltr.js";
+export * from "./max_satisfying.js";
+export * from "./min_satisfying.js";
+export * from "./neq.js";
+export * from "./outside.js";
+export * from "./parse_comparator.js";
+export * from "./parse_range.js";
+export * from "./parse.js";
+export * from "./range_format.js";
+export * from "./range_intersects.js";
+export * from "./range_max.js";
+export * from "./range_min.js";
+export * from "./rcompare.js";
+export * from "./rsort.js";
+export * from "./sort.js";
+export * from "./types.js";
+export * from "./lte.js";
+export * from "./lte.js";
+export const SEMVER_SPEC_VERSION = "2.0.0";

package/esm/deps/deno.land/std@0.205.0/semver/neq.d.ts

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

package/esm/deps/deno.land/std@0.205.0/semver/neq.js

@@ -0,0 +1,5 @@
+import { compare } from "./compare.js";
+/** Not equal comparison */
+export function neq(s0, s1) {
+    return compare(s0, s1) !== 0;
+}

package/esm/deps/deno.land/std@0.205.0/semver/outside.d.ts

@@ -0,0 +1,11 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Returns true if the version is outside the bounds of the range in either the
+ * high or low direction. The hilo argument must be either the string '>' or
+ * '<'. (This is the function called by {@linkcode gtr} and {@linkcode ltr}.)
+ * @param version The version to compare to the range
+ * @param range The range of possible versions
+ * @param hilo The operator for the comparison or both if undefined.
+ * @returns True if the version is outside of the range based on the operator
+ */
+export declare function outside(version: SemVer, range: SemVerRange, hilo?: ">" | "<"): boolean;

package/esm/deps/deno.land/std@0.205.0/semver/outside.js

@@ -0,0 +1,67 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { gt } from "./gt.js";
+import { gte } from "./gte.js";
+import { lte } from "./lte.js";
+import { lt } from "./lt.js";
+import { ALL, ANY } from "./constants.js";
+import { testRange } from "./test_range.js";
+/**
+ * Returns true if the version is outside the bounds of the range in either the
+ * high or low direction. The hilo argument must be either the string '>' or
+ * '<'. (This is the function called by {@linkcode gtr} and {@linkcode ltr}.)
+ * @param version The version to compare to the range
+ * @param range The range of possible versions
+ * @param hilo The operator for the comparison or both if undefined.
+ * @returns True if the version is outside of the range based on the operator
+ */
+export function outside(version, range, hilo) {
+    if (!hilo) {
+        return outside(version, range, ">") ||
+            outside(version, range, "<");
+    }
+    const [gtfn, ltefn, ltfn, comp, ecomp] = (() => {
+        switch (hilo) {
+            case ">":
+                return [gt, lte, lt, ">", ">="];
+            case "<":
+                return [lt, gte, gt, "<", "<="];
+        }
+    })();
+    if (testRange(version, range)) {
+        return false;
+    }
+    for (const comparators of range.ranges) {
+        let high = undefined;
+        let low = undefined;
+        for (let comparator of comparators) {
+            if (comparator.semver === ANY) {
+                comparator = ALL;
+            }
+            high = high || comparator;
+            low = low || comparator;
+            if (gtfn(comparator.semver, high.semver)) {
+                high = comparator;
+            }
+            else if (ltfn(comparator.semver, low.semver)) {
+                low = comparator;
+            }
+        }
+        if (!high || !low)
+            return true;
+        // If the edge version comparator has a operator then our version
+        // isn't outside it
+        if (high.operator === comp || high.operator === ecomp) {
+            return false;
+        }
+        // If the lowest version comparator has an operator and our version
+        // is less than it then it isn't higher than the range
+        if ((!low.operator || low.operator === comp) &&
+            ltefn(version, low.semver)) {
+            return false;
+        }
+        else if (low.operator === ecomp && ltfn(version, low.semver)) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/deps/deno.land/std@0.205.0/semver/parse.d.ts

@@ -0,0 +1,8 @@
+import { SemVer } from "./types.js";
+/**
+ * Attempt to parse a string as a semantic version, returning either a `SemVer`
+ * object or throws a TypeError.
+ * @param version The version string to parse
+ * @returns A valid SemVer
+ */
+export declare function parse(version: string | SemVer): SemVer;

package/esm/deps/deno.land/std@0.205.0/semver/parse.js

@@ -0,0 +1,66 @@
+import { isValidNumber } from "./_shared.js";
+import { isSemVer } from "./is_semver.js";
+import { FULL, MAX_LENGTH, NUMERICIDENTIFIER, re, src } from "./_shared.js";
+/**
+ * Attempt to parse a string as a semantic version, returning either a `SemVer`
+ * object or throws a TypeError.
+ * @param version The version string to parse
+ * @returns A valid SemVer
+ */
+export function parse(version) {
+    if (typeof version === "object") {
+        if (isSemVer(version)) {
+            return version;
+        }
+        else {
+            throw new TypeError(`not a valid SemVer object`);
+        }
+    }
+    if (typeof version !== "string") {
+        throw new TypeError(`version must be a string`);
+    }
+    if (version.length > MAX_LENGTH) {
+        throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+    }
+    version = version.trim();
+    const r = re[FULL];
+    const m = version.match(r);
+    if (!m) {
+        throw new TypeError(`Invalid Version: ${version}`);
+    }
+    // these are actually numbers
+    const major = parseInt(m[1]);
+    const minor = parseInt(m[2]);
+    const patch = parseInt(m[3]);
+    if (major > Number.MAX_SAFE_INTEGER || major < 0) {
+        throw new TypeError("Invalid major version");
+    }
+    if (minor > Number.MAX_SAFE_INTEGER || minor < 0) {
+        throw new TypeError("Invalid minor version");
+    }
+    if (patch > Number.MAX_SAFE_INTEGER || patch < 0) {
+        throw new TypeError("Invalid patch version");
+    }
+    // number-ify any prerelease numeric ids
+    const numericIdentifier = new RegExp(`^(${src[NUMERICIDENTIFIER]})$`);
+    const prerelease = (m[4] ?? "")
+        .split(".")
+        .filter((id) => id)
+        .map((id) => {
+        const num = parseInt(id);
+        if (id.match(numericIdentifier) && isValidNumber(num)) {
+            return num;
+        }
+        else {
+            return id;
+        }
+    });
+    const build = m[5]?.split(".")?.filter((m) => m) ?? [];
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+        build,
+    };
+}

package/esm/deps/deno.land/std@0.205.0/semver/parse_comparator.d.ts

@@ -0,0 +1,7 @@
+import type { SemVerComparator } from "./types.js";
+/**
+ * Parses a comparator string into a valid SemVerComparator.
+ * @param comparator
+ * @returns A valid SemVerComparator
+ */
+export declare function parseComparator(comparator: string): SemVerComparator;

package/esm/deps/deno.land/std@0.205.0/semver/parse_comparator.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { parse } from "./parse.js";
+import { COMPARATOR, re } from "./_shared.js";
+import { comparatorMax } from "./comparator_max.js";
+import { comparatorMin } from "./comparator_min.js";
+import { ANY, NONE } from "./constants.js";
+/**
+ * Parses a comparator string into a valid SemVerComparator.
+ * @param comparator
+ * @returns A valid SemVerComparator
+ */
+export function parseComparator(comparator) {
+    const r = re[COMPARATOR];
+    const m = comparator.match(r);
+    if (!m) {
+        return NONE;
+    }
+    const operator = (m[1] ?? "");
+    const semver = m[2] ? parse(m[2]) : ANY;
+    const min = comparatorMin(semver, operator);
+    const max = comparatorMax(semver, operator);
+    return {
+        operator,
+        semver,
+        min,
+        max,
+    };
+}

package/esm/deps/deno.land/std@0.205.0/semver/parse_range.d.ts

@@ -0,0 +1,7 @@
+import type { SemVerRange } from "./types.js";
+/**
+ * Parses a range string into a SemVerRange object or throws a TypeError.
+ * @param range The range string
+ * @returns A valid semantic version range
+ */
+export declare function parseRange(range: string): SemVerRange;