keep-a-changelog 2.2.1 → 2.4.1

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

@@ -0,0 +1,292 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { ALL } from "./constants.js";
+import { CARET, HYPHENRANGE, re, STAR, TILDE, XRANGE } from "./_shared.js";
+import { parseComparator } from "./parse_comparator.js";
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp) {
+    return comp
+        .trim()
+        .split(/\s+/)
+        .map((comp) => replaceTilde(comp))
+        .join(" ");
+}
+function replaceTilde(comp) {
+    const r = re[TILDE];
+    return comp.replace(r, (_, M, m, p, pr) => {
+        let ret;
+        if (isX(M)) {
+            ret = "";
+        }
+        else if (isX(m)) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (isX(p)) {
+            // ~1.2 == >=1.2.0 <1.3.0
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        }
+        else if (pr) {
+            ret = ">=" +
+                M +
+                "." +
+                m +
+                "." +
+                p +
+                "-" +
+                pr +
+                " <" +
+                M +
+                "." +
+                (+m + 1) +
+                ".0";
+        }
+        else {
+            // ~1.2.3 == >=1.2.3 <1.3.0
+            ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+        }
+        return ret;
+    });
+}
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp) {
+    return comp
+        .trim()
+        .split(/\s+/)
+        .map((comp) => replaceCaret(comp))
+        .join(" ");
+}
+function replaceCaret(comp) {
+    const r = re[CARET];
+    return comp.replace(r, (_, M, m, p, pr) => {
+        let ret;
+        if (isX(M)) {
+            ret = "";
+        }
+        else if (isX(m)) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (isX(p)) {
+            if (M === "0") {
+                ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+            }
+            else {
+                ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
+            }
+        }
+        else if (pr) {
+            if (M === "0") {
+                if (m === "0") {
+                    ret = ">=" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        p +
+                        "-" +
+                        pr +
+                        " <" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        (+p + 1);
+                }
+                else {
+                    ret = ">=" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        p +
+                        "-" +
+                        pr +
+                        " <" +
+                        M +
+                        "." +
+                        (+m + 1) +
+                        ".0";
+                }
+            }
+            else {
+                ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) +
+                    ".0.0";
+            }
+        }
+        else {
+            if (M === "0") {
+                if (m === "0") {
+                    ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." +
+                        (+p + 1);
+                }
+                else {
+                    ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+                }
+            }
+            else {
+                ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
+            }
+        }
+        return ret;
+    });
+}
+function replaceXRanges(comp) {
+    return comp
+        .split(/\s+/)
+        .map((comp) => replaceXRange(comp))
+        .join(" ");
+}
+function replaceXRange(comp) {
+    comp = comp.trim();
+    const r = re[XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, _pr) => {
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+            gtlt = "";
+        }
+        if (xM) {
+            if (gtlt === ">" || gtlt === "<") {
+                // nothing is allowed
+                ret = "<0.0.0";
+            }
+            else {
+                // nothing is forbidden
+                ret = "*";
+            }
+        }
+        else if (gtlt && anyX) {
+            // we know patch is an x, because we have any x at all.
+            // replace X with 0
+            if (xm) {
+                m = 0;
+            }
+            p = 0;
+            if (gtlt === ">") {
+                // >1 => >=2.0.0
+                // >1.2 => >=1.3.0
+                // >1.2.3 => >= 1.2.4
+                gtlt = ">=";
+                if (xm) {
+                    M = +M + 1;
+                    m = 0;
+                    p = 0;
+                }
+                else {
+                    m = +m + 1;
+                    p = 0;
+                }
+            }
+            else if (gtlt === "<=") {
+                // <=0.7.x is actually <0.8.0, since any 0.7.x should
+                // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+                gtlt = "<";
+                if (xm) {
+                    M = +M + 1;
+                }
+                else {
+                    m = +m + 1;
+                }
+            }
+            ret = gtlt + M + "." + m + "." + p;
+        }
+        else if (xm) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (xp) {
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        }
+        return ret;
+    });
+}
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp) {
+    return comp.trim().replace(re[STAR], "");
+}
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 -> >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 -> >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 -> >=1.2.0 <3.5.0
+function hyphenReplace(_$0, from, fM, fm, fp, _fpr, _fb, to, tM, tm, tp, tpr, _tb) {
+    if (isX(fM)) {
+        from = "";
+    }
+    else if (isX(fm)) {
+        from = ">=" + fM + ".0.0";
+    }
+    else if (isX(fp)) {
+        from = ">=" + fM + "." + fm + ".0";
+    }
+    else {
+        from = ">=" + from;
+    }
+    if (isX(tM)) {
+        to = "";
+    }
+    else if (isX(tm)) {
+        to = "<" + (+tM + 1) + ".0.0";
+    }
+    else if (isX(tp)) {
+        to = "<" + tM + "." + (+tm + 1) + ".0";
+    }
+    else if (tpr) {
+        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
+    }
+    else {
+        to = "<=" + to;
+    }
+    return (from + " " + to).trim();
+}
+function isX(id) {
+    return !id || id.toLowerCase() === "x" || id === "*";
+}
+/**
+ * Parses a range string into a SemVerRange object or throws a TypeError.
+ * @param range The range string
+ * @returns A valid semantic version range
+ */
+export function parseRange(range) {
+    // handle spaces around and between comparator and version
+    range = range.trim().replaceAll(/(?<=<|>|=) /g, "");
+    if (range === "") {
+        return { ranges: [[ALL]] };
+    }
+    // Split into groups of comparators, these are considered OR'd together.
+    const ranges = range
+        .trim()
+        .split(/\s*\|\|\s*/)
+        .map((range) => {
+        // convert `1.2.3 - 1.2.4` into `>=1.2.3 <=1.2.4`
+        const hr = re[HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace);
+        range = replaceCarets(range);
+        range = replaceTildes(range);
+        range = replaceXRanges(range);
+        range = replaceStars(range);
+        // At this point, the range is completely trimmed and
+        // ready to be split into comparators.
+        // These are considered AND's
+        if (range === "") {
+            return [ALL];
+        }
+        else {
+            return range
+                .split(" ")
+                .filter((r) => r)
+                .map((r) => parseComparator(r));
+        }
+    });
+    return { ranges };
+}

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

@@ -0,0 +1,8 @@
+import type { SemVerRange } from "./types.js";
+/**
+ * Formats the range into a string
+ * @example >=0.0.0 || <1.0.0
+ * @param range The range to format
+ * @returns A string representation of the range
+ */
+export declare function rangeFormat(range: SemVerRange): string;

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

@@ -0,0 +1,11 @@
+import { comparatorFormat } from "./comparator_format.js";
+/**
+ * Formats the range into a string
+ * @example >=0.0.0 || <1.0.0
+ * @param range The range to format
+ * @returns A string representation of the range
+ */
+export function rangeFormat(range) {
+    return range.ranges.map((c) => c.map((c) => comparatorFormat(c)).join(" "))
+        .join("||");
+}

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

@@ -0,0 +1,8 @@
+import type { SemVerRange } from "./types.js";
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+export declare function rangeIntersects(r0: SemVerRange, r1: SemVerRange): boolean;

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

@@ -0,0 +1,35 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { comparatorIntersects } from "./comparator_intersects.js";
+function rangesSatisfiable(ranges) {
+    return ranges.every((r) => {
+        // For each OR at least one AND must be satisfiable
+        return r.ranges.some((comparators) => comparatorsSatisfiable(comparators));
+    });
+}
+function comparatorsSatisfiable(comparators) {
+    // Comparators are satisfiable if they all intersect with each other
+    for (let i = 0; i < comparators.length - 1; i++) {
+        const c0 = comparators[i];
+        for (const c1 of comparators.slice(i + 1)) {
+            if (!comparatorIntersects(c0, c1)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+export function rangeIntersects(r0, r1) {
+    return rangesSatisfiable([r0, r1]) && r0.ranges.some((r00) => {
+        return r1.ranges.some((r11) => {
+            return r00.every((c0) => {
+                return r11.every((c1) => comparatorIntersects(c0, c1));
+            });
+        });
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMax(range: SemVerRange): SemVer | undefined;

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

@@ -0,0 +1,15 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { INVALID } from "./constants.js";
+import { sort } from "./sort.js";
+import { testRange } from "./test_range.js";
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+export function rangeMax(range) {
+    // For and's, you take the smallest max
+    // For or's, you take the biggest max
+    //[ [1 and 2] or [2 and 3] ] = [ 1 or 2 ] = 2
+    return sort(range.ranges.map((r) => sort(r.filter((c) => testRange(c.max, range)).map((c) => c.max)).shift())).filter((v) => v).pop() ?? INVALID;
+}

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

@@ -0,0 +1,7 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMin(range: SemVerRange): SemVer;

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

@@ -0,0 +1,14 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { INVALID } from "./constants.js";
+import { sort } from "./sort.js";
+import { testRange } from "./test_range.js";
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+export function rangeMin(range) {
+    // For or's, you take the smallest min
+    //[ [1 and 2] or [2 and 3] ] = [ 2 or 3 ] = 2
+    return sort(range.ranges.map((r) => sort(r.filter((c) => testRange(c.min, range)).map((c) => c.min)).pop()).filter((v) => v)).shift() ?? INVALID;
+}

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

@@ -0,0 +1,8 @@
+import type { SemVer } from "./types.js";
+/**
+ * A reverse comparison of two versions. Same as compare but
+ * `1` and `-1` are inverted.
+ *
+ * Sorts in descending order if passed to `Array.sort()`,
+ */
+export declare function rcompare(s0: SemVer, s1: SemVer): 1 | 0 | -1;

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

@@ -0,0 +1,10 @@
+import { compare } from "./compare.js";
+/**
+ * A reverse comparison of two versions. Same as compare but
+ * `1` and `-1` are inverted.
+ *
+ * Sorts in descending order if passed to `Array.sort()`,
+ */
+export function rcompare(s0, s1) {
+    return compare(s1, s0);
+}

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

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Sorts a list of semantic versions in descending order. */
+export declare function rsort(list: SemVer[]): SemVer[];

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

@@ -0,0 +1,5 @@
+import { compare } from "./compare.js";
+/** Sorts a list of semantic versions in descending order. */
+export function rsort(list) {
+    return list.sort((a, b) => compare(b, a));
+}

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

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Sorts a list of semantic versions in ascending order. */
+export declare function sort(list: SemVer[]): SemVer[];

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

@@ -0,0 +1,5 @@
+import { compare } from "./compare.js";
+/** Sorts a list of semantic versions in ascending order. */
+export function sort(list) {
+    return list.sort((a, b) => compare(a, b));
+}

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

@@ -0,0 +1,8 @@
+import type { SemVer, SemVerComparator } from "./types.js";
+/**
+ * Test to see if a semantic version falls within the range of the comparator.
+ * @param version The version to compare
+ * @param comparator The comparator
+ * @returns True if the version is within the comparators set otherwise false
+ */
+export declare function testComparator(version: SemVer, comparator: SemVerComparator): boolean;

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

@@ -0,0 +1,10 @@
+import { cmp } from "./cmp.js";
+/**
+ * Test to see if a semantic version falls within the range of the comparator.
+ * @param version The version to compare
+ * @param comparator The comparator
+ * @returns True if the version is within the comparators set otherwise false
+ */
+export function testComparator(version, comparator) {
+    return cmp(version, comparator.operator, comparator.semver);
+}

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

@@ -0,0 +1,8 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export declare function testRange(version: SemVer, range: SemVerRange): boolean;

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

@@ -0,0 +1,16 @@
+import { gte } from "./gte.js";
+import { lte } from "./lte.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export function testRange(version, range) {
+    for (const r of range.ranges) {
+        if (r.every((c) => gte(version, c.min) && lte(version, c.max))) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * The possible release types are used as an operator for the
+ * increment function and as a result of the difference function.
+ */
+export type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+/**
+ * SemVer comparison operators.
+ */
+export type Operator = "" | "=" | "==" | "===" | "!==" | "!=" | ">" | ">=" | "<" | "<=";
+/**
+ * The style to use when formatting a SemVer object into a string
+ */
+export type FormatStyle = "full" | "release" | "primary" | "build" | "pre" | "patch" | "minor" | "major";
+/**
+ * The shape of a valid semantic version comparator
+ * @example >=0.0.0
+ */
+export interface SemVerComparator {
+    operator: Operator;
+    semver: SemVer;
+    min: SemVer;
+    max: SemVer;
+}
+/**
+ * A SemVer object parsed into its constituent parts.
+ */
+export interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: (string | number)[];
+    build: string[];
+}
+type SemVerRangeAnd = SemVerComparator[];
+type SemVerRangeOr = SemVerRangeAnd[];
+/**
+ * A type representing a semantic version range. The ranges consist of
+ * a nested array, which represents a set of OR comparisons while the
+ * inner array represents AND comparisons.
+ */
+export interface SemVerRange {
+    ranges: SemVerRangeOr;
+}
+export {};

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

@@ -0,0 +1,2 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export {};

package/{types → esm}/src/Changelog.d.ts

@@ -1,5 +1,5 @@
 import Release from "./Release.js";
-import { Semver } from "./deps.js";
+import type { SemVer } from "./deps.js";
 export default class Changelog {
     flag?: string;
     title: string;
@@ -9,11 +9,13 @@ export default class Changelog {
     url?: string;
     releases: Release[];
     tagNameBuilder?: (release: Release) => string;
+    compareLinkBuilder?: (previous: Release, release: Release) => string;
     format: "compact" | "markdownlint";
     constructor(title: string, description?: string);
     addRelease(release: Release): this;
-    findRelease(version?: Semver | string): Release | undefined;
+    findRelease(version?: SemVer | string): Release | undefined;
     sortReleases(): void;
+    compareLink(previous: Release, release: Release): string;
     tagName(release: Release): string;
     toString(): string;
 }

package/esm/src/Changelog.js

@@ -1,4 +1,4 @@
-import { eq } from "./deps.js";
+import { eq, parse } from "./deps.js";
 export default class Changelog {
     constructor(title, description = "") {
         Object.defineProperty(this, "flag", {
@@ -49,6 +49,12 @@ export default class Changelog {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "compareLinkBuilder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "format", {
             enumerable: true,
             configurable: true,
@@ -68,11 +74,26 @@ export default class Changelog {
         if (!version) {
             return this.releases.find((release) => !release.version);
         }
-        return this.releases.find((release) => release.version && eq(release.version, version));
+        if (typeof version === "string") {
+            version = parse(version);
+        }
+        return this.releases.find((release) => release.parsedVersion && eq(release.parsedVersion, version));
     }
     sortReleases() {
         this.releases.sort((a, b) => a.compare(b));
     }
+    compareLink(previous, release) {
+        if (this.compareLinkBuilder) {
+            return this.compareLinkBuilder(previous, release);
+        }
+        if (!previous) {
+            return `${this.url}/releases/tag/${this.tagName(release)}`;
+        }
+        if (!release.date || !release.version) {
+            return `${this.url}/compare/${this.tagName(previous)}...${this.head}`;
+        }
+        return `${this.url}/compare/${this.tagName(previous)}...${this.tagName(release)}`;
+    }
     tagName(release) {
         if (this.tagNameBuilder) {
             return this.tagNameBuilder(release);
@@ -94,8 +115,8 @@ export default class Changelog {
         const description = this.description.trim() ||
             `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/).`;
         if (description) {
             t.push(description);
         }

package/{types → esm}/src/Release.d.ts

@@ -1,17 +1,18 @@
-import { Semver } from "./deps.js";
 import Change from "./Change.js";
 import Changelog from "./Changelog.js";
+import type { SemVer } from "./deps.js";
 export default class Release {
     changelog?: Changelog;
-    version?: Semver;
+    parsedVersion?: SemVer;
     date?: Date;
     yanked: boolean;
     description: string;
     changes: Map<string, Change[]>;
-    constructor(version?: string | Semver, date?: string | Date, description?: string);
+    constructor(version?: string | SemVer, date?: string | Date, description?: string);
+    get version(): string | undefined;
     compare(release: Release): number;
     isEmpty(): boolean;
-    setVersion(version?: string | Semver): void;
+    setVersion(version?: string | SemVer): void;
     setDate(date?: Date | string): void;
     setYanked(yanked?: boolean): this;
     addChange(type: string, change: Change | string): this;