keep-a-changelog 2.3.0 → 2.4.1

package/CHANGELOG.md

@@ -3,8 +3,19 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](http://keepachangelog.com/)
-and this project adheres to [Semantic Versioning](http://semver.org/).
+The format is based on [Keep a Changelog](https://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [3.4.1] - 2023-10-10
+### Fixed
+- Breaking changes after updating `semver` package
+
+## [3.4.0] - 2023-10-10
+### Added
+- New function `compareLinkBuilder` [#33].
+
+### Fixed
+- Updated dependencies
 
 ## [2.3.0] - 2023-05-25
 ### Added
@@ -12,6 +23,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Fixed
 - Allow empty values for `--release` option
+- Updated dependencies
 
 ## [2.2.1] - 2023-01-25
 ### Fixed
@@ -52,7 +64,10 @@ New version merging Deno and Node code using Deno's `dnt` package.
 [#28]: https://github.com/oscarotero/keep-a-changelog/issues/28
 [#30]: https://github.com/oscarotero/keep-a-changelog/issues/30
 [#31]: https://github.com/oscarotero/keep-a-changelog/issues/31
+[#33]: https://github.com/oscarotero/keep-a-changelog/issues/33
 
+[3.4.1]: https://github.com/oscarotero/keep-a-changelog/compare/v3.4.0...v3.4.1
+[3.4.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.3.0...v3.4.0
 [2.3.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.2.1...v2.3.0
 [2.2.1]: https://github.com/oscarotero/keep-a-changelog/compare/v2.2.0...v2.2.1
 [2.2.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.1.0...v2.2.0

package/README.md

@@ -4,7 +4,7 @@
 Node & Deno
 
 Deno package to parse and generate changelogs following the
-[keepachangelog](http://keepachangelog.com/en/1.0.0/) format.
+[keepachangelog](https://keepachangelog.com/) format.
 
 ## Usage in Node
 
@@ -78,11 +78,23 @@ const changelog = new Changelog();
 changelog.tagNameBuilder = (release) => `version-${release.version}`;
 ```
 
+### Custom compare links
+
+By default, compare links are build compliant with GitHub format. To change this
+behavior, set a new `compareLinkBuilder`:
+
+```js
+const changelog = new Changelog();
+changelog.url = "https://bitbucket.org/oscarotero/keep-a-changelog";
+changelog.compareLinkBuilder = (previous, release) =>
+  `${this.url}/branches/compare/${release.version}%0D${previous.version}`;
+```
+
 ### Custom Change Types
 
-By default and according to the
-[keepachangelog](http://keepachangelog.com/en/1.0.0/) format, the change types
-are `Added`, `Changed`, `Deprecated`, `Removed`, `Fixed`, and `Security`.
+By default and according to the [keepachangelog](https://keepachangelog.com/)
+format, the change types are `Added`, `Changed`, `Deprecated`, `Removed`,
+`Fixed`, and `Security`.
 
 In case you'd like add another type, you need to extend the `Release` class to
 support new types. Additionally, you have to tell the `parser` that it should
@@ -161,6 +173,7 @@ changelog --release
 ```
 
 If your "Unreleased" section has no version, you can specify it as an argument:
+
 ```sh
 changelog --release 2.0.0
 ```
@@ -176,11 +189,12 @@ Available options:
 
 | Option             | Description                                                                                                                                                                                                    |
 | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--format`           | The output format for the generated markdown. It can be `markdownlint` or `compact`. The default value is `compact`.                                                                                                                                       |
+| `--format`         | The output format for the generated markdown. It can be `markdownlint` or `compact`. The default value is `compact`.                                                                                           |
 | `--file`           | The markdown file of the changelog. The default value is `CHANGELOG.md`.                                                                                                                                       |
 | `--url`            | The base url used to build the diff urls of the different releases. It is taken from the existing diff urls in the markdown. If no urls are found, try to catch it using the url of the git remote repository. |
 | `--https`          | Set to false to use `http` instead `https` in the url (`--https=false`).                                                                                                                                       |
 | `--init`           | Init a new empty changelog file.                                                                                                                                                                               |
 | `--latest-release` | Print the latest release version.                                                                                                                                                                              |
-| `--release`        | Updated the latest unreleased version with the current date.                                                                                                                                                   |
+| `--release`        | Updated the latest unreleased version with the current date. Use `--release=X.Y.Z` to set a number if the version doesn't have it.                                                                             |
+| `--create`         | Create a new Unreleased version. Use `--create=X.Y.Z` to specify a version number or just `--create` for a version without number.                                                                             |
 | `--quiet`          | Do not output error messages                                                                                                                                                                                   |

package/esm/_dnt.shims.js

@@ -4,7 +4,6 @@ const dntGlobals = {
     Deno,
 };
 export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
 function createMergeProxy(baseObj, extObj) {
     return new Proxy(baseObj, {
         get(_target, prop, _receiver) {

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;

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

@@ -0,0 +1,18 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_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()`,
+ */
+export function compare(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return (compareNumber(s0.major, s1.major) ||
+        compareNumber(s0.minor, s1.minor) ||
+        compareNumber(s0.patch, s1.patch) ||
+        checkIdentifier(s0.prerelease, s1.prerelease) ||
+        compareIdentifier(s0.prerelease, s1.prerelease));
+}

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

@@ -0,0 +1,23 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_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
+ */
+export function compareBuild(s0, s1) {
+    if (s0 === s1)
+        return 0;
+    return (compareNumber(s0.major, s1.major) ||
+        compareNumber(s0.minor, s1.minor) ||
+        compareNumber(s0.patch, s1.patch) ||
+        checkIdentifier(s0.prerelease, s1.prerelease) ||
+        compareIdentifier(s0.prerelease, s1.prerelease) ||
+        checkIdentifier(s1.build, s0.build) ||
+        compareIdentifier(s0.build, s1.build));
+}