keep-a-changelog 2.3.0 → 2.5.0

package/script/deps/deno.land/{std@0.173.0 → std@0.205.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;

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

@@ -0,0 +1,330 @@
+"use strict";
+// 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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMVER_SPEC_VERSION = void 0;
+/**
+ * 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
+ */
+__exportStar(require("./cmp.js"), exports);
+__exportStar(require("./comparator_format.js"), exports);
+__exportStar(require("./comparator_intersects.js"), exports);
+__exportStar(require("./comparator_max.js"), exports);
+__exportStar(require("./comparator_min.js"), exports);
+__exportStar(require("./compare_build.js"), exports);
+__exportStar(require("./compare.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./difference.js"), exports);
+__exportStar(require("./eq.js"), exports);
+__exportStar(require("./format.js"), exports);
+__exportStar(require("./gt.js"), exports);
+__exportStar(require("./gte.js"), exports);
+__exportStar(require("./gtr.js"), exports);
+__exportStar(require("./test_comparator.js"), exports);
+__exportStar(require("./test_range.js"), exports);
+__exportStar(require("./increment.js"), exports);
+__exportStar(require("./is_semver_comparator.js"), exports);
+__exportStar(require("./is_semver_range.js"), exports);
+__exportStar(require("./is_semver.js"), exports);
+__exportStar(require("./lt.js"), exports);
+__exportStar(require("./lte.js"), exports);
+__exportStar(require("./ltr.js"), exports);
+__exportStar(require("./max_satisfying.js"), exports);
+__exportStar(require("./min_satisfying.js"), exports);
+__exportStar(require("./neq.js"), exports);
+__exportStar(require("./outside.js"), exports);
+__exportStar(require("./parse_comparator.js"), exports);
+__exportStar(require("./parse_range.js"), exports);
+__exportStar(require("./parse.js"), exports);
+__exportStar(require("./range_format.js"), exports);
+__exportStar(require("./range_intersects.js"), exports);
+__exportStar(require("./range_max.js"), exports);
+__exportStar(require("./range_min.js"), exports);
+__exportStar(require("./rcompare.js"), exports);
+__exportStar(require("./rsort.js"), exports);
+__exportStar(require("./sort.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./lte.js"), exports);
+__exportStar(require("./lte.js"), exports);
+exports.SEMVER_SPEC_VERSION = "2.0.0";

package/script/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/script/deps/deno.land/std@0.205.0/semver/neq.js

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

package/script/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;