keep-a-changelog 2.2.1 → 2.3.0

package/script/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/script/deps/deno.land/std@0.189.0/_util/asserts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+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;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;

package/script/deps/deno.land/std@0.189.0/_util/os.d.ts

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

package/script/deps/deno.land/std@0.189.0/flags/mod.d.ts

@@ -0,0 +1,166 @@
+/** Combines recursively all intersection types and returns a new single type. */
+type Id<TRecord> = TRecord extends Record<string, unknown> ? TRecord extends infer InferredRecord ? {
+    [Key in keyof InferredRecord]: Id<InferredRecord[Key]>;
+} : never : TRecord;
+/** Converts a union type `A | B | C` into an intersection type `A & B & C`. */
+type UnionToIntersection<TValue> = (TValue extends unknown ? (args: TValue) => unknown : never) extends (args: infer R) => unknown ? R extends Record<string, unknown> ? R : never : never;
+type BooleanType = boolean | string | undefined;
+type StringType = string | undefined;
+type ArgType = StringType | BooleanType;
+type Collectable = string | undefined;
+type Negatable = string | undefined;
+type UseTypes<TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable> = undefined extends ((false extends TBooleans ? undefined : TBooleans) & TCollectable & TStrings) ? false : true;
+/**
+ * Creates a record with all available flags with the corresponding type and
+ * default type.
+ */
+type Values<TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable, TNegatable extends Negatable, TDefault extends Record<string, unknown> | undefined, TAliases extends Aliases | undefined> = UseTypes<TBooleans, TStrings, TCollectable> extends true ? Record<string, unknown> & AddAliases<SpreadDefaults<CollectValues<TStrings, string, TCollectable, TNegatable> & RecursiveRequired<CollectValues<TBooleans, boolean, TCollectable>> & CollectUnknownValues<TBooleans, TStrings, TCollectable, TNegatable>, DedotRecord<TDefault>>, TAliases> : Record<string, any>;
+type Aliases<TArgNames = string, TAliasNames extends string = string> = Partial<Record<Extract<TArgNames, string>, TAliasNames | ReadonlyArray<TAliasNames>>>;
+type AddAliases<TArgs, TAliases extends Aliases | undefined> = {
+    [TArgName in keyof TArgs as AliasNames<TArgName, TAliases>]: TArgs[TArgName];
+};
+type AliasNames<TArgName, TAliases extends Aliases | undefined> = TArgName extends keyof TAliases ? string extends TAliases[TArgName] ? TArgName : TAliases[TArgName] extends string ? TArgName | TAliases[TArgName] : TAliases[TArgName] extends Array<string> ? TArgName | TAliases[TArgName][number] : TArgName : TArgName;
+/**
+ * Spreads all default values of Record `TDefaults` into Record `TArgs`
+ * and makes default values required.
+ *
+ * **Example:**
+ * `SpreadValues<{ foo?: boolean, bar?: number }, { foo: number }>`
+ *
+ * **Result:** `{ foo: boolean | number, bar?: number }`
+ */
+type SpreadDefaults<TArgs, TDefaults> = TDefaults extends undefined ? TArgs : TArgs extends Record<string, unknown> ? Omit<TArgs, keyof TDefaults> & {
+    [Default in keyof TDefaults]: Default extends keyof TArgs ? (TArgs[Default] & TDefaults[Default] | TDefaults[Default]) extends Record<string, unknown> ? NonNullable<SpreadDefaults<TArgs[Default], TDefaults[Default]>> : TDefaults[Default] | NonNullable<TArgs[Default]> : unknown;
+} : never;
+/**
+ * Defines the Record for the `default` option to add
+ * auto-suggestion support for IDE's.
+ */
+type Defaults<TBooleans extends BooleanType, TStrings extends StringType> = Id<UnionToIntersection<Record<string, unknown> & MapTypes<TStrings, unknown> & MapTypes<TBooleans, unknown> & MapDefaults<TBooleans> & MapDefaults<TStrings>>>;
+type MapDefaults<TArgNames extends ArgType> = Partial<Record<TArgNames extends string ? TArgNames : string, unknown>>;
+type RecursiveRequired<TRecord> = TRecord extends Record<string, unknown> ? {
+    [Key in keyof TRecord]-?: RecursiveRequired<TRecord[Key]>;
+} : TRecord;
+/** Same as `MapTypes` but also supports collectable options. */
+type CollectValues<TArgNames extends ArgType, TType, TCollectable extends Collectable, TNegatable extends Negatable = undefined> = UnionToIntersection<Extract<TArgNames, TCollectable> extends string ? (Exclude<TArgNames, TCollectable> extends never ? Record<never, never> : MapTypes<Exclude<TArgNames, TCollectable>, TType, TNegatable>) & (Extract<TArgNames, TCollectable> extends never ? Record<never, never> : RecursiveRequired<MapTypes<Extract<TArgNames, TCollectable>, Array<TType>, TNegatable>>) : MapTypes<TArgNames, TType, TNegatable>>;
+/** Same as `Record` but also supports dotted and negatable options. */
+type MapTypes<TArgNames extends ArgType, TType, TNegatable extends Negatable = undefined> = undefined extends TArgNames ? Record<never, never> : TArgNames extends `${infer Name}.${infer Rest}` ? {
+    [Key in Name]?: MapTypes<Rest, TType, TNegatable extends `${Name}.${infer Negate}` ? Negate : undefined>;
+} : TArgNames extends string ? Partial<Record<TArgNames, TNegatable extends TArgNames ? TType | false : TType>> : Record<never, never>;
+type CollectUnknownValues<TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable, TNegatable extends Negatable> = UnionToIntersection<TCollectable extends TBooleans & TStrings ? Record<never, never> : DedotRecord<Record<Exclude<Extract<Exclude<TCollectable, TNegatable>, string>, Extract<TStrings | TBooleans, string>>, Array<unknown>> & Record<Exclude<Extract<Extract<TCollectable, TNegatable>, string>, Extract<TStrings | TBooleans, string>>, Array<unknown> | false>>>;
+/** Converts `{ "foo.bar.baz": unknown }` into `{ foo: { bar: { baz: unknown } } }`. */
+type DedotRecord<TRecord> = Record<string, unknown> extends TRecord ? TRecord : TRecord extends Record<string, unknown> ? UnionToIntersection<ValueOf<{
+    [Key in keyof TRecord]: Key extends string ? Dedot<Key, TRecord[Key]> : never;
+}>> : TRecord;
+type Dedot<TKey extends string, TValue> = TKey extends `${infer Name}.${infer Rest}` ? {
+    [Key in Name]: Dedot<Rest, TValue>;
+} : {
+    [Key in TKey]: TValue;
+};
+type ValueOf<TValue> = TValue[keyof TValue];
+/** The value returned from `parse`. */
+export type Args<TArgs extends Record<string, unknown> = Record<string, any>, TDoubleDash extends boolean | undefined = undefined> = Id<TArgs & {
+    /** Contains all the arguments that didn't have an option associated with
+     * them. */
+    _: Array<string | number>;
+} & (boolean extends TDoubleDash ? DoubleDash : true extends TDoubleDash ? Required<DoubleDash> : Record<never, never>)>;
+type DoubleDash = {
+    /** Contains all the arguments that appear after the double dash: "--". */
+    "--"?: Array<string>;
+};
+/** The options for the `parse` call. */
+export interface ParseOptions<TBooleans extends BooleanType = BooleanType, TStrings extends StringType = StringType, TCollectable extends Collectable = Collectable, TNegatable extends Negatable = Negatable, TDefault extends Record<string, unknown> | undefined = Record<string, unknown> | undefined, TAliases extends Aliases | undefined = Aliases | undefined, TDoubleDash extends boolean | undefined = boolean | undefined> {
+    /**
+     * When `true`, populate the result `_` with everything before the `--` and
+     * the result `['--']` with everything after the `--`.
+     *
+     * @default {false}
+     *
+     *  @example
+     * ```ts
+     * // $ deno run example.ts -- a arg1
+     * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+     * console.dir(parse(Deno.args, { "--": false }));
+     * // output: { _: [ "a", "arg1" ] }
+     * console.dir(parse(Deno.args, { "--": true }));
+     * // output: { _: [], --: [ "a", "arg1" ] }
+     * ```
+     */
+    "--"?: TDoubleDash;
+    /**
+     * An object mapping string names to strings or arrays of string argument
+     * names to use as aliases.
+     */
+    alias?: TAliases;
+    /**
+     * 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`).
+     *  All `boolean` arguments will be set to `false` by default.
+     */
+    boolean?: TBooleans | ReadonlyArray<Extract<TBooleans, string>>;
+    /** An object mapping string argument names to default values. */
+    default?: TDefault & Defaults<TBooleans, TStrings>;
+    /**
+     * 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?: TStrings | ReadonlyArray<Extract<TStrings, string>>;
+    /**
+     * A string or array of strings argument names to always treat as arrays.
+     * Collectable options can be used multiple times. All values will be
+     * collected into one array. If a non-collectable option is used multiple
+     * times, the last value is used.
+     * All Collectable arguments will be set to `[]` by default.
+     */
+    collect?: TCollectable | ReadonlyArray<Extract<TCollectable, string>>;
+    /**
+     * A string or array of strings argument names which can be negated
+     * by prefixing them with `--no-`, like `--no-config`.
+     */
+    negatable?: TNegatable | ReadonlyArray<Extract<TNegatable, 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, optionally with a set of options, and
+ * return an object representing the flags found in the passed arguments.
+ *
+ * By default, any arguments starting with `-` or `--` are considered boolean
+ * flags. If the argument name is followed by an equal sign (`=`) it is
+ * considered a key-value pair. Any arguments which could not be parsed are
+ * available in the `_` property of the returned object.
+ *
+ * By default, the flags module tries to determine the type of all arguments
+ * automatically and the return type of the `parse` method will have an index
+ * signature with `any` as value (`{ [x: string]: any }`).
+ *
+ * If the `string`, `boolean` or `collect` option is set, the return value of
+ * the `parse` method will be fully typed and the index signature of the return
+ * type will change to `{ [x: string]: unknown }`.
+ *
+ * Any arguments after `'--'` will not be parsed and will end up in `parsedArgs._`.
+ *
+ * Numeric-looking arguments will be returned as numbers unless `options.string`
+ * or `options.boolean` is set for that argument name.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+ * const parsedArgs = parse(Deno.args);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+ * const parsedArgs = parse(["--foo", "--bar=baz", "./quux.txt"]);
+ * // parsedArgs: { foo: true, bar: "baz", _: ["./quux.txt"] }
+ * ```
+ */
+export declare function parse<TArgs extends Values<TBooleans, TStrings, TCollectable, TNegatable, TDefaults, TAliases>, TDoubleDash extends boolean | undefined = undefined, TBooleans extends BooleanType = undefined, TStrings extends StringType = undefined, TCollectable extends Collectable = undefined, TNegatable extends Negatable = undefined, TDefaults extends Record<string, unknown> | undefined = undefined, TAliases extends Aliases<TAliasArgNames, TAliasNames> | undefined = undefined, TAliasArgNames extends string = string, TAliasNames extends string = string>(args: string[], { "--": doubleDash, alias, boolean, default: defaults, stopEarly, string, collect, negatable, unknown, }?: ParseOptions<TBooleans, TStrings, TCollectable, TNegatable, TDefaults, TAliases, TDoubleDash>): Args<TArgs, TDoubleDash>;
+export {};

package/script/deps/deno.land/{std@0.173.0 → std@0.189.0}/flags/mod.js

@@ -1,7 +1,8 @@
 "use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = void 0;
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 /**
  * Command line arguments parser based on
  * [minimist](https://github.com/minimistjs/minimist).
@@ -333,10 +334,10 @@ function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, de
     }
     for (const [key, value] of Object.entries(defaults)) {
         if (!hasKey(argv, key.split("."))) {
-            setKey(argv, key, value);
+            setKey(argv, key, value, false);
             if (aliases[key]) {
                 for (const x of aliases[key]) {
-                    setKey(argv, x, value);
+                    setKey(argv, x, value, false);
                 }
             }
         }

package/script/deps/deno.land/std@0.189.0/path/_constants.d.ts

@@ -0,0 +1,39 @@
+export declare const CHAR_UPPERCASE_A = 65;
+export declare const CHAR_LOWERCASE_A = 97;
+export declare const CHAR_UPPERCASE_Z = 90;
+export declare const CHAR_LOWERCASE_Z = 122;
+export declare const CHAR_DOT = 46;
+export declare const CHAR_FORWARD_SLASH = 47;
+export declare const CHAR_BACKWARD_SLASH = 92;
+export declare const CHAR_VERTICAL_LINE = 124;
+export declare const CHAR_COLON = 58;
+export declare const CHAR_QUESTION_MARK = 63;
+export declare const CHAR_UNDERSCORE = 95;
+export declare const CHAR_LINE_FEED = 10;
+export declare const CHAR_CARRIAGE_RETURN = 13;
+export declare const CHAR_TAB = 9;
+export declare const CHAR_FORM_FEED = 12;
+export declare const CHAR_EXCLAMATION_MARK = 33;
+export declare const CHAR_HASH = 35;
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_NO_BREAK_SPACE = 160;
+export declare const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
+export declare const CHAR_LEFT_SQUARE_BRACKET = 91;
+export declare const CHAR_RIGHT_SQUARE_BRACKET = 93;
+export declare const CHAR_LEFT_ANGLE_BRACKET = 60;
+export declare const CHAR_RIGHT_ANGLE_BRACKET = 62;
+export declare const CHAR_LEFT_CURLY_BRACKET = 123;
+export declare const CHAR_RIGHT_CURLY_BRACKET = 125;
+export declare const CHAR_HYPHEN_MINUS = 45;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_DOUBLE_QUOTE = 34;
+export declare const CHAR_SINGLE_QUOTE = 39;
+export declare const CHAR_PERCENT = 37;
+export declare const CHAR_SEMICOLON = 59;
+export declare const CHAR_CIRCUMFLEX_ACCENT = 94;
+export declare const CHAR_GRAVE_ACCENT = 96;
+export declare const CHAR_AT = 64;
+export declare const CHAR_AMPERSAND = 38;
+export declare const CHAR_EQUAL = 61;
+export declare const CHAR_0 = 48;
+export declare const CHAR_9 = 57;