keep-a-changelog 2.3.0 → 2.4.1

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lte = void 0;
+const compare_js_1 = require("./compare.js");
+/** Less than or equal to comparison */
+function lte(s0, s1) {
+    return (0, compare_js_1.compare)(s0, s1) <= 0;
+}
+exports.lte = lte;

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

@@ -0,0 +1,3 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/** Greater than range comparison */
+export declare function ltr(version: SemVer, range: SemVerRange): boolean;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ltr = void 0;
+const outside_js_1 = require("./outside.js");
+/** Greater than range comparison */
+function ltr(version, range) {
+    return (0, outside_js_1.outside)(version, range, "<");
+}
+exports.ltr = ltr;

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

@@ -0,0 +1,9 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Returns the highest version in the list that satisfies the range, or `undefined`
+ * if none of them do.
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The highest version in versions that satisfies the range.
+ */
+export declare function maxSatisfying(versions: SemVer[], range: SemVerRange): SemVer | undefined;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSatisfying = void 0;
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * Returns the highest version in the list that satisfies the range, or `undefined`
+ * if none of them do.
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The highest version in versions that satisfies the range.
+ */
+function maxSatisfying(versions, range) {
+    const satisfying = versions.filter((v) => (0, test_range_js_1.testRange)(v, range));
+    const sorted = (0, sort_js_1.sort)(satisfying);
+    return sorted.pop();
+}
+exports.maxSatisfying = maxSatisfying;

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

@@ -0,0 +1,9 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * none of them do.
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The lowest version in versions that satisfies the range.
+ */
+export declare function minSatisfying(versions: SemVer[], range: SemVerRange): SemVer | undefined;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minSatisfying = void 0;
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * none of them do.
+ * @param versions The versions to check.
+ * @param range The range of possible versions to compare to.
+ * @returns The lowest version in versions that satisfies the range.
+ */
+function minSatisfying(versions, range) {
+    const satisfying = versions.filter((v) => (0, test_range_js_1.testRange)(v, range));
+    const sorted = (0, sort_js_1.sort)(satisfying);
+    return sorted.shift();
+}
+exports.minSatisfying = minSatisfying;

package/script/deps/deno.land/{std@0.173.0 → std@0.203.0}/semver/mod.d.ts

@@ -10,6 +10,28 @@
  *
  * 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
@@ -76,10 +98,17 @@
  * will append the value of the string as a prerelease identifier:
  *
  * ```javascript
- * semver.increment("1.2.3", "prerelease", "beta");
+ * 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.
@@ -216,183 +245,66 @@
  *
  * @example
  * ```ts
- * import * as semver from "https://deno.land/std@$STD_VERSION/semver/mod.ts";
- *
- * semver.valid("1.2.3"); // "1.2.3"
- * semver.valid("a.b.c"); // null
- * semver.satisfies("1.2.3", "1.x || >=2.5.0 || 5.0.0 - 7.2.3"); // true
- * semver.gt("1.2.3", "9.8.7"); // false
- * semver.lt("1.2.3", "9.8.7"); // true
- * semver.minVersion(">=1.0.0"); // "1.0.0"
+ * 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 type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
-export type Operator = "===" | "!==" | "" | "=" | "==" | "!=" | ">" | ">=" | "<" | "<=";
-export interface Options {
-    /**
-     * Set to suppress the default behavior of excluding prerelease tagged
-     * versions from ranges unless they are explicitly opted into.
-     */
-    includePrerelease?: boolean;
-}
+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 declare const SEMVER_SPEC_VERSION = "2.0.0";
-/**
- * Attempt to parse a string as a semantic version, returning either a `SemVer`
- * object or `null`.
- */
-export declare function parse(version: string | SemVer | null, options?: Options): SemVer | null;
-/** Returns the parsed version, or null if it's not valid. */
-export declare function valid(version: string | SemVer | null, options?: Options): string | null;
-export declare class SemVer {
-    raw: string;
-    options: Options;
-    major: number;
-    minor: number;
-    patch: number;
-    version: string;
-    build: ReadonlyArray<string>;
-    prerelease: Array<string | number>;
-    constructor(version: string | SemVer, options?: Options);
-    format(): string;
-    compare(other: string | SemVer): 1 | 0 | -1;
-    compareMain(other: string | SemVer): 1 | 0 | -1;
-    comparePre(other: string | SemVer): 1 | 0 | -1;
-    compareBuild(other: string | SemVer): 1 | 0 | -1;
-    increment(release: ReleaseType, identifier?: string): SemVer;
-    toString(): string;
-}
-/**
- * Returns the version incremented by the release type
- * (major, minor, patch, or prerelease), or null if it's not valid.
- *
- * `premajor` in one call will bump the version up to the next major version and
- * down to a prerelease of that major version. `preminor`, and `prepatch` work
- * the same way.
- *
- * If called from a non-prerelease version, the `prerelease` will work the same
- * as `prepatch`. It increments the patch version, then makes a prerelease. If
- * the input version is already a prerelease it simply increments it.
- */
-export declare function increment(version: string | SemVer, release: ReleaseType, options?: Options, identifier?: string): string | null;
-/**
- * Returns difference between two versions by the release type  (`major`,
- * `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`), or
- * null if the versions are the same.
- */
-export declare function difference(version1: string | SemVer, version2: string | SemVer, options?: Options): ReleaseType | null;
-export declare function compareIdentifiers(a: string | number | null, b: string | number | null): 1 | 0 | -1;
-export declare function rcompareIdentifiers(a: string | null, b: string | null): 1 | 0 | -1;
-/** Returns the major version number. */
-export declare function major(v: string | SemVer, options?: Options): number;
-/** Returns the minor version number. */
-export declare function minor(v: string | SemVer, options?: Options): number;
-/** Returns the patch version number. */
-export declare function patch(v: string | SemVer, options?: Options): number;
-/**
- * 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(v1: string | SemVer, v2: string | SemVer, options?: Options): 1 | 0 | -1;
-/**
- * The same as {@linkcode compare} but considers `build` when two versions are
- * equal. Sorts in ascending order if passed to `Array.sort()`.
- */
-export declare function compareBuild(a: string | SemVer, b: string | SemVer, options?: Options): 1 | 0 | -1;
-/**
- * Returns `0` if `v1 == v2`, or `-1` if `v1` is greater, or `1` if `v2` is
- * greater. Sorts in descending order if passed to `Array.sort()`,
- */
-export declare function rcompare(v1: string | SemVer, v2: string | SemVer, options?: Options): 1 | 0 | -1;
-export declare function sort<T extends string | SemVer>(list: T[], options?: Options): T[];
-export declare function rsort<T extends string | SemVer>(list: T[], options?: Options): T[];
-/** Greater than comparison */
-export declare function gt(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/** Less than comparison */
-export declare function lt(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/**
- * This is true if they're logically equivalent, even if they're not the exact
- * same string.
- */
-export declare function eq(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/**
- * This is true if they're not logically equivalent, even if they're the exact
- * same string.
- */
-export declare function neq(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/** Greater than or equal comparison */
-export declare function gte(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/** Less than or equal comparison */
-export declare function lte(v1: string | SemVer, v2: string | SemVer, options?: Options): boolean;
-/**
- * Pass in a comparison string, and it'll call the corresponding comparison
- * function. `"==="` and `"!=="` do simple string comparison, but are included
- * for completeness. Throws if an invalid comparison string is provided.
- */
-export declare function cmp(v1: string | SemVer, operator: Operator, v2: string | SemVer, options?: Options): boolean;
-export declare class Comparator {
-    semver: SemVer;
-    operator: "" | "=" | "<" | ">" | "<=" | ">=";
-    value: string;
-    options: Options;
-    constructor(comp: string | Comparator, options?: Options);
-    parse(comp: string): void;
-    test(version: string | SemVer): boolean;
-    intersects(comp: Comparator, options?: Options): boolean;
-    toString(): string;
-}
-export declare class Range {
-    range: string;
-    raw: string;
-    options: Options;
-    includePrerelease: boolean;
-    set: ReadonlyArray<ReadonlyArray<Comparator>>;
-    constructor(range: string | Range | Comparator, options?: Options);
-    format(): string;
-    parseRange(range: string): ReadonlyArray<Comparator>;
-    test(version: string | SemVer): boolean;
-    intersects(range?: Range, options?: Options): boolean;
-    toString(): string;
-}
-export declare function toComparators(range: string | Range, options?: Options): string[][];
-/** Returns true if the version satisfies the range. */
-export declare function satisfies(version: string | SemVer, range: string | Range, options?: Options): boolean;
-/**
- * Returns the highest version in the list that satisfies the range, or `null`
- * if none of them do.
- */
-export declare function maxSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, options?: Options): T | null;
-/**
- * Returns the lowest version in the list that satisfies the range, or `null` if
- * none of them do.
- */
-export declare function minSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, options?: Options): T | null;
-/** Returns the lowest version that can possibly match the given range. */
-export declare function minVersion(range: string | Range, options?: Options): SemVer | null;
-/** Returns the valid range or null if it's not valid. */
-export declare function validRange(range: string | Range | null, options?: Options): string | null;
-/**
- * Returns true if version is less than all the versions possible in the range.
- */
-export declare function ltr(version: string | SemVer, range: string | Range, options?: Options): boolean;
-/**
- * Returns true if version is greater than all the versions possible in the range.
- */
-export declare function gtr(version: string | SemVer, range: string | Range, options?: Options): boolean;
-/**
- * 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}.)
- */
-export declare function outside(version: string | SemVer, range: string | Range, hilo: ">" | "<", options?: Options): boolean;
-/**
- * Returns an array of prerelease components, or null if none exist.
- *
- * @example
- * `prerelease("1.2.3-alpha.1") -> ["alpha", 1]`
- */
-export declare function prerelease(version: string | SemVer, options?: Options): ReadonlyArray<string | number> | null;
-/** Returns true if the two supplied ranges or comparators intersect. */
-export declare function intersects(range1: string | Range | Comparator, range2: string | Range | Comparator, options?: Options): boolean;
-export default SemVer;