keep-a-changelog 2.5.3 → 2.6.1

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

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

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

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

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

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

package/esm/deps/deno.land/std@0.51.0/fs/eol.d.ts

@@ -1,12 +0,0 @@
-/** EndOfLine character enum */
-export declare enum EOL {
-    LF = "\n",
-    CRLF = "\r\n"
-}
-/**
- * Detect the EOL character for string input.
- * returns null if no newline
- */
-export declare function detect(content: string): EOL | null;
-/** Format the file to the targeted EOL */
-export declare function format(content: string, eol: EOL): string;

package/esm/deps/deno.land/std@0.51.0/fs/eol.js

@@ -1,29 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-/** EndOfLine character enum */
-export var EOL;
-(function (EOL) {
-    EOL["LF"] = "\n";
-    EOL["CRLF"] = "\r\n";
-})(EOL || (EOL = {}));
-const regDetect = /(?:\r?\n)/g;
-/**
- * Detect the EOL character for string input.
- * returns null if no newline
- */
-export function detect(content) {
-    const d = content.match(regDetect);
-    if (!d || d.length === 0) {
-        return null;
-    }
-    const crlf = d.filter((x) => x === EOL.CRLF);
-    if (crlf.length > 0) {
-        return EOL.CRLF;
-    }
-    else {
-        return EOL.LF;
-    }
-}
-/** Format the file to the targeted EOL */
-export function format(content, eol) {
-    return content.replace(regDetect, eol);
-}

package/esm/deps/deno.land/x/ini@v2.1.0/ini.d.ts

@@ -1,53 +0,0 @@
-export declare const parse: typeof decode;
-export declare const stringify: typeof encode;
-export interface EncodeOptions {
-    section?: string;
-    whitespace?: boolean;
-}
-/**
- * Encode the object `object` into an ini-style formatted string. If the
- * optional parameter `section` is given, then all top-level properties
- * of the object are put into this section and the `section`-string is
- * prepended to all sub-sections, see the usage example above.
- *
- * The `options` object may contain the following:
- * - `section` A string which will be the first `section` in the encoded
- *   ini data.  Defaults to none.
- * - `whitespace` Boolean to specify whether to put whitespace around the
- *   `=` character.  By default, whitespace is omitted, to be friendly to
- *   some persnickety old parsers that don't tolerate it well.  But some
- *   find that it's more human-readable and pretty with the whitespace.
- *
- * For backwards compatibility reasons, if a `string` options is passed,
- * then it is assumed to be the `section` value.
- *
- * @param obj Object to encode
- * @param opt Encoding options
- */
-export declare function encode(obj: any, opt?: string | EncodeOptions): string;
-/**
- * Decode the given ini-style formatted document into a nested object.
- * @param str ini-style document
- */
-export declare function decode(str: string): any;
-/**
- * Escapes the string `val` such that it is safe to be used as a key or
- * value in an ini-file. Basically escapes quotes. For example:
- *
- * ```javascript
- * ini.safe('"unsafe string"')
- * ```
- *
- * would result in
- *
- * ```javascript
- * "\"unsafe string\""
- * ```
- * @param val String to escape
- */
-export declare function safe(val: string | any): string;
-/**
- * Unescapes the given string value.
- * @param val String to unescape
- */
-export declare function unsafe(val?: string): string;

package/esm/deps/deno.land/x/ini@v2.1.0/ini.js

@@ -1,226 +0,0 @@
-import * as dntShim from "../../../../_dnt.shims.js";
-import * as eol from '../../std@0.51.0/fs/eol.js';
-const isWindows = dntShim.Deno.build.os == "windows";
-const EOL = isWindows ? eol.EOL.CRLF : eol.EOL.LF;
-export const parse = decode;
-export const stringify = encode;
-/**
- * Encode the object `object` into an ini-style formatted string. If the
- * optional parameter `section` is given, then all top-level properties
- * of the object are put into this section and the `section`-string is
- * prepended to all sub-sections, see the usage example above.
- *
- * The `options` object may contain the following:
- * - `section` A string which will be the first `section` in the encoded
- *   ini data.  Defaults to none.
- * - `whitespace` Boolean to specify whether to put whitespace around the
- *   `=` character.  By default, whitespace is omitted, to be friendly to
- *   some persnickety old parsers that don't tolerate it well.  But some
- *   find that it's more human-readable and pretty with the whitespace.
- *
- * For backwards compatibility reasons, if a `string` options is passed,
- * then it is assumed to be the `section` value.
- *
- * @param obj Object to encode
- * @param opt Encoding options
- */
-export function encode(obj, opt = { whitespace: false }) {
-    const children = [];
-    let out = '';
-    let options = typeof opt === 'string' ? { section: opt, whitespace: false } : opt;
-    const separator = options.whitespace ? ' = ' : '=';
-    Object.keys(obj).forEach(function (k, _, __) {
-        const val = obj[k];
-        if (val && Array.isArray(val)) {
-            val.forEach(function (item) {
-                out += safe(k + '[]') + separator + safe(item) + EOL;
-            });
-        }
-        else if (val && typeof val === 'object') {
-            children.push(k);
-        }
-        else {
-            out += safe(k) + separator + safe(val) + EOL;
-        }
-    });
-    if (options.section && out.length) {
-        out = '[' + safe(options.section) + ']' + EOL + out;
-    }
-    children.forEach(function (k, _, __) {
-        const nk = dotSplit(k).join('\\.');
-        const section = (options.section ? options.section + '.' : '') + nk;
-        const child = encode(obj[k], {
-            section: section,
-            whitespace: options.whitespace
-        });
-        if (out.length && child.length) {
-            out += EOL;
-        }
-        out += child;
-    });
-    return out;
-}
-function dotSplit(str) {
-    return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
-        .replace(/\\\./g, '\u0001')
-        .split(/\./).map(function (part) {
-        return part.replace(/\1/g, '\\.')
-            .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001');
-    });
-}
-/**
- * Decode the given ini-style formatted document into a nested object.
- * @param str ini-style document
- */
-export function decode(str) {
-    const out = {};
-    let p = out;
-    //          section     |key      = value
-    const re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
-    const lines = str.split(/[\r\n]+/g);
-    lines.forEach(function (line, _, __) {
-        if (!line || line.match(/^\s*[;#]/))
-            return;
-        const match = line.match(re);
-        if (!match)
-            return;
-        if (match[1] !== undefined) {
-            let section = unsafe(match[1]);
-            p = out[section] = out[section] || {};
-            return;
-        }
-        let key = unsafe(match[2]);
-        let value = match[3] ? unsafe(match[4]) : true;
-        switch (value) {
-            case 'true':
-            case 'false':
-            case 'null': value = JSON.parse(value);
-        }
-        const valueAsFloat = parseFloat(`${value}`);
-        if (!Number.isNaN(valueAsFloat)) {
-            value = valueAsFloat;
-        }
-        // Convert keys with '[]' suffix to an array
-        if (key.length > 2 && key.slice(-2) === '[]') {
-            key = key.substring(0, key.length - 2);
-            if (!p[key]) {
-                p[key] = [];
-            }
-            else if (!Array.isArray(p[key])) {
-                p[key] = [p[key]];
-            }
-        }
-        // safeguard against resetting a previously defined
-        // array by accidentally forgetting the brackets
-        if (Array.isArray(p[key])) {
-            p[key].push(value);
-        }
-        else {
-            p[key] = value;
-        }
-    });
-    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
-    // use a filter to return the keys that have to be deleted.
-    Object.keys(out).filter(function (k, _, __) {
-        if (!out[k] ||
-            typeof out[k] !== 'object' ||
-            Array.isArray(out[k])) {
-            return false;
-        }
-        // see if the parent section is also an object.
-        // if so, add it to that, and mark this one for deletion
-        const parts = dotSplit(k);
-        let parentSection = out;
-        const lastPart = parts.pop() ?? '';
-        const nl = lastPart.replace(/\\\./g, '.');
-        parts.forEach(function (part, _, __) {
-            if (!parentSection[part] || typeof parentSection[part] !== 'object')
-                parentSection[part] = {};
-            parentSection = parentSection[part];
-        });
-        if (parentSection === out && nl === lastPart) {
-            return false;
-        }
-        parentSection[nl] = out[k];
-        return true;
-    }).forEach(function (del, _, __) {
-        delete out[del];
-    });
-    return out;
-}
-function isQuoted(val) {
-    return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
-        (val.charAt(0) === "'" && val.slice(-1) === "'");
-}
-/**
- * Escapes the string `val` such that it is safe to be used as a key or
- * value in an ini-file. Basically escapes quotes. For example:
- *
- * ```javascript
- * ini.safe('"unsafe string"')
- * ```
- *
- * would result in
- *
- * ```javascript
- * "\"unsafe string\""
- * ```
- * @param val String to escape
- */
-export function safe(val) {
-    return (typeof val !== 'string' ||
-        val.match(/[=\r\n]/) ||
-        val.match(/^\[/) ||
-        (val.length > 1 && isQuoted(val)) ||
-        val !== val.trim())
-        ? JSON.stringify(val)
-        : val.replace(/;/g, '\\;').replace(/#/g, '\\#');
-}
-/**
- * Unescapes the given string value.
- * @param val String to unescape
- */
-export function unsafe(val = '') {
-    val = val.trim();
-    if (isQuoted(val)) {
-        // remove the single quotes before calling JSON.parse
-        if (val.charAt(0) === "'") {
-            val = val.substr(1, val.length - 2);
-        }
-        try {
-            val = JSON.parse(val);
-        }
-        catch (_) { }
-    }
-    else {
-        // walk the val to find the first unescaped ; character
-        let esc = false;
-        let unesc = '';
-        for (let i = 0, l = val.length; i < l; i++) {
-            const c = val.charAt(i);
-            if (esc) {
-                if ('\\;#'.indexOf(c) !== -1) {
-                    unesc += c;
-                }
-                else {
-                    unesc += '\\' + c;
-                }
-                esc = false;
-            }
-            else if (';#'.indexOf(c) !== -1) {
-                break;
-            }
-            else if (c === '\\') {
-                esc = true;
-            }
-            else {
-                unesc += c;
-            }
-        }
-        if (esc) {
-            unesc += '\\';
-        }
-        return unesc.trim();
-    }
-    return val;
-}

package/esm/deps/deno.land/x/ini@v2.1.0/mod.d.ts

@@ -1 +0,0 @@
-export * from './ini.js';

package/esm/deps/deno.land/x/ini@v2.1.0/mod.js

@@ -1 +0,0 @@
-export * from './ini.js';

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

@@ -1,10 +0,0 @@
-/**
- * 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/asserts.js

@@ -1,27 +0,0 @@
-"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.unreachable = exports.assert = exports.DenoStdInternalError = void 0;
-/**
- * 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.
- */
-class DenoStdInternalError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "DenoStdInternalError";
-    }
-}
-exports.DenoStdInternalError = DenoStdInternalError;
-/** Make an assertion, if not `true`, then throw. */
-function assert(expr, msg = "") {
-    if (!expr) {
-        throw new DenoStdInternalError(msg);
-    }
-}
-exports.assert = assert;
-/** Use this to assert unreachable code. */
-function unreachable() {
-    throw new DenoStdInternalError("unreachable");
-}
-exports.unreachable = unreachable;

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

@@ -1,4 +0,0 @@
-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/_util/os.js

@@ -1,44 +0,0 @@
-"use strict";
-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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLinux = exports.isWindows = exports.osType = void 0;
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-const dntShim = __importStar(require("../../../../_dnt.shims.js"));
-exports.osType = (() => {
-    // deno-lint-ignore no-explicit-any
-    const { Deno } = dntShim.dntGlobalThis;
-    if (typeof Deno?.build?.os === "string") {
-        return Deno.build.os;
-    }
-    // deno-lint-ignore no-explicit-any
-    const { navigator } = dntShim.dntGlobalThis;
-    if (navigator?.appVersion?.includes?.("Win")) {
-        return "windows";
-    }
-    return "linux";
-})();
-exports.isWindows = exports.osType === "windows";
-exports.isLinux = exports.osType === "linux";

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

@@ -1,166 +0,0 @@
-/** 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 {};