keep-a-changelog 2.0.1 → 2.2.1

package/types/deps/deno.land/std@0.173.0/semver/mod.d.ts

@@ -0,0 +1,398 @@
+/**
+ * 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.
+ *
+ * ## 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("1.2.3", "prerelease", "beta");
+ * // "1.2.4-beta.0"
+ * ```
+ *
+ * ### 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 * 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"
+ * ```
+ *
+ * @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 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/types/mod.d.ts

@@ -1,3 +1,4 @@
+import "./_dnt.polyfills.js";
 import parser from "./src/parser.js";
 import Change from "./src/Change.js";
 import Changelog from "./src/Changelog.js";

package/types/src/Changelog.d.ts

@@ -9,6 +9,7 @@ export default class Changelog {
     url?: string;
     releases: Release[];
     tagNameBuilder?: (release: Release) => string;
+    format: "compact" | "markdownlint";
     constructor(title: string, description?: string);
     addRelease(release: Release): this;
     findRelease(version?: Semver | string): Release | undefined;

package/types/src/Release.d.ts

@@ -5,6 +5,7 @@ export default class Release {
     changelog?: Changelog;
     version?: Semver;
     date?: Date;
+    yanked: boolean;
     description: string;
     changes: Map<string, Change[]>;
     constructor(version?: string | Semver, date?: string | Date, description?: string);
@@ -12,6 +13,7 @@ export default class Release {
     isEmpty(): boolean;
     setVersion(version?: string | Semver): void;
     setDate(date?: Date | string): void;
+    setYanked(yanked?: boolean): this;
     addChange(type: string, change: Change | string): this;
     added(change: Change | string): this;
     changed(change: Change | string): this;

package/types/src/deps.d.ts

@@ -1 +1 @@
-export { default as Semver, eq, } from "../deps/deno_land/x/semver_v1.4.0/mod.js";
+export { default as Semver, eq, } from "../deps/deno.land/std@0.173.0/semver/mod.js";

package/esm/deps/deno_land/std_0.120.0/_util/assert.js

@@ -1,13 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-export class DenoStdInternalError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "DenoStdInternalError";
-    }
-}
-/** Make an assertion, if not `true`, then throw. */
-export function assert(expr, msg = "") {
-    if (!expr) {
-        throw new DenoStdInternalError(msg);
-    }
-}

package/esm/deps/deno_land/std_0.120.0/path/_interface.js

@@ -1,3 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-export {};

package/esm/deps/deno_land/std_0.120.0/path/mod.js

@@ -1,14 +0,0 @@
-// Copyright the Browserify authors. MIT License.
-// Ported mostly from https://github.com/browserify/path-browserify/
-// This module is browser compatible.
-import { isWindows } from "../_util/os.js";
-import * as _win32 from "./win32.js";
-import * as _posix from "./posix.js";
-const path = isWindows ? _win32 : _posix;
-export const win32 = _win32;
-export const posix = _posix;
-export const { basename, delimiter, dirname, extname, format, fromFileUrl, isAbsolute, join, normalize, parse, relative, resolve, sep, toFileUrl, toNamespacedPath, } = path;
-export * from "./common.js";
-export { SEP, SEP_PATTERN } from "./separator.js";
-export * from "./_interface.js";
-export * from "./glob.js";

package/types/deps/deno_land/std_0.120.0/_util/assert.d.ts

@@ -1,5 +0,0 @@
-export declare class DenoStdInternalError extends Error {
-    constructor(message: string);
-}
-/** Make an assertion, if not `true`, then throw. */
-export declare function assert(expr: unknown, msg?: string): asserts expr;

package/types/deps/deno_land/std_0.120.0/_util/os.d.ts

@@ -1,3 +0,0 @@
-export declare type OSType = "windows" | "linux" | "darwin";
-export declare const osType: OSType;
-export declare const isWindows: boolean;

package/types/deps/deno_land/std_0.120.0/flags/mod.d.ts

@@ -1,50 +0,0 @@
-export interface Args {
-    /** Contains all the arguments that didn't have an option associated with
-     * them. */
-    _: Array<string | number>;
-    [key: string]: any;
-}
-export interface ArgParsingOptions {
-    /** When `true`, populate the result `_` with everything before the `--` and
-     * the result `['--']` with everything after the `--`. Here's an example:
-     *
-     * ```ts
-     *      // $ deno run example.ts -- a arg1
-     *      import { parse } from "./mod.ts";
-     *      console.dir(parse(Deno.args, { "--": false }));
-     *      // output: { _: [ "a", "arg1" ] }
-     *      console.dir(parse(Deno.args, { "--": true }));
-     *      // output: { _: [], --: [ "a", "arg1" ] }
-     * ```
-     *
-     * Defaults to `false`.
-     */
-    "--"?: boolean;
-    /** An object mapping string names to strings or arrays of string argument
-     * names to use as aliases */
-    alias?: Record<string, string | string[]>;
-    /** A boolean, string or array of strings to always treat as booleans. If
-     * `true` will treat all double hyphenated arguments without equal signs as
-     * `boolean` (e.g. affects `--foo`, not `-f` or `--foo=bar`) */
-    boolean?: boolean | string | string[];
-    /** An object mapping string argument names to default values. */
-    default?: Record<string, unknown>;
-    /** When `true`, populate the result `_` with everything after the first
-     * non-option. */
-    stopEarly?: boolean;
-    /** A string or array of strings argument names to always treat as strings. */
-    string?: string | string[];
-    /** A function which is invoked with a command line parameter not defined in
-     * the `options` configuration object. If the function returns `false`, the
-     * unknown option is not added to `parsedArgs`. */
-    unknown?: (arg: string, key?: string, value?: unknown) => unknown;
-}
-/** Take a set of command line arguments, with an optional set of options, and
- * return an object representation of those argument.
- *
- * ```ts
- *      import { parse } from "./mod.ts";
- *      const parsedArgs = parse(Deno.args);
- * ```
- */
-export declare function parse(args: string[], { "--": doubleDash, alias, boolean, default: defaults, stopEarly, string, unknown, }?: ArgParsingOptions): Args;

package/types/deps/deno_land/x/semver_v1.4.0/mod.d.ts

@@ -1,116 +0,0 @@
-export declare type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
-export declare type Operator = "===" | "!==" | "" | "=" | "==" | "!=" | ">" | ">=" | "<" | "<=";
-export interface Options {
-    loose?: boolean;
-    includePrerelease?: boolean;
-}
-export declare const SEMVER_SPEC_VERSION = "2.0.0";
-export declare function parse(version: string | SemVer | null, optionsOrLoose?: boolean | Options): SemVer | null;
-export declare function valid(version: string | SemVer | null, optionsOrLoose?: boolean | Options): string | null;
-export declare function clean(version: string, optionsOrLoose?: boolean | Options): string | null;
-export declare class SemVer {
-    raw: string;
-    loose: boolean;
-    options: Options;
-    major: number;
-    minor: number;
-    patch: number;
-    version: string;
-    build: ReadonlyArray<string>;
-    prerelease: Array<string | number>;
-    constructor(version: string | SemVer, optionsOrLoose?: boolean | 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;
-    inc(release: ReleaseType, identifier?: string): SemVer;
-    toString(): string;
-}
-/**
- * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
- */
-export declare function inc(version: string | SemVer, release: ReleaseType, optionsOrLoose?: boolean | Options, identifier?: string): string | null;
-export declare function diff(version1: string | SemVer, version2: string | SemVer, optionsOrLoose?: boolean | 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;
-/**
- * Return the major version number.
- */
-export declare function major(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
-/**
- * Return the minor version number.
- */
-export declare function minor(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
-/**
- * Return the patch version number.
- */
-export declare function patch(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
-export declare function compare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
-export declare function compareLoose(a: string | SemVer, b: string | SemVer): 1 | 0 | -1;
-export declare function compareBuild(a: string | SemVer, b: string | SemVer, loose?: boolean | Options): 1 | 0 | -1;
-export declare function rcompare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
-export declare function sort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
-export declare function rsort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
-export declare function gt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function lt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function eq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function neq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function gte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function lte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare function cmp(v1: string | SemVer, operator: Operator, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
-export declare class Comparator {
-    semver: SemVer;
-    operator: "" | "=" | "<" | ">" | "<=" | ">=";
-    value: string;
-    loose: boolean;
-    options: Options;
-    constructor(comp: string | Comparator, optionsOrLoose?: boolean | Options);
-    parse(comp: string): void;
-    test(version: string | SemVer): boolean;
-    intersects(comp: Comparator, optionsOrLoose?: boolean | Options): boolean;
-    toString(): string;
-}
-export declare class Range {
-    range: string;
-    raw: string;
-    loose: boolean;
-    options: Options;
-    includePrerelease: boolean;
-    set: ReadonlyArray<ReadonlyArray<Comparator>>;
-    constructor(range: string | Range | Comparator, optionsOrLoose?: boolean | Options);
-    format(): string;
-    parseRange(range: string): ReadonlyArray<Comparator>;
-    test(version: string | SemVer): boolean;
-    intersects(range?: Range, optionsOrLoose?: boolean | Options): boolean;
-    toString(): string;
-}
-export declare function toComparators(range: string | Range, optionsOrLoose?: boolean | Options): string[][];
-export declare function satisfies(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
-export declare function maxSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
-export declare function minSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
-export declare function minVersion(range: string | Range, optionsOrLoose?: boolean | Options): SemVer | null;
-export declare function validRange(range: string | Range | null, optionsOrLoose?: boolean | Options): string | null;
-/**
- * Return true if version is less than all the versions possible in the range.
- */
-export declare function ltr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
-/**
- * Return true if version is greater than all the versions possible in the range.
- */
-export declare function gtr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
-/**
- * Return 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 gtr and ltr.)
- */
-export declare function outside(version: string | SemVer, range: string | Range, hilo: ">" | "<", optionsOrLoose?: boolean | Options): boolean;
-export declare function prerelease(version: string | SemVer, optionsOrLoose?: boolean | Options): ReadonlyArray<string | number> | null;
-/**
- * Return true if any of the ranges comparators intersect
- */
-export declare function intersects(range1: string | Range | Comparator, range2: string | Range | Comparator, optionsOrLoose?: boolean | Options): boolean;
-/**
- * Coerces a string to semver if possible
- */
-export declare function coerce(version: string | SemVer, optionsOrLoose?: boolean | Options): SemVer | null;
-export default SemVer;