@seyuna/cli 1.0.0-canary.23 → 1.0.0-canary.25

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/flags.js

@@ -0,0 +1,401 @@
+import { getDefaultValue, getOption, matchWildCardOptions, paramCaseToCamelCase, } from "./_utils.js";
+import { DuplicateOptionError, InvalidOptionError, InvalidOptionValueError, MissingOptionValueError, UnexpectedArgumentAfterVariadicArgumentError, UnexpectedOptionValueError, UnexpectedRequiredArgumentError, UnknownConflictingOptionError, UnknownOptionError, UnknownRequiredOptionError, UnknownTypeError, } from "./_errors.js";
+import { OptionType } from "./deprecated.js";
+import { boolean } from "./types/boolean.js";
+import { number } from "./types/number.js";
+import { string } from "./types/string.js";
+import { validateFlags } from "./_validate_flags.js";
+import { integer } from "./types/integer.js";
+const DefaultTypes = {
+    string,
+    number,
+    integer,
+    boolean,
+};
+/**
+ * Parse command line arguments.
+ *
+ * @param argsOrCtx Command line arguments e.g: `Deno.args` or parse context.
+ * @param opts      Parse options.
+ *
+ * ```
+ * import { parseFlags } from "./flags.ts";
+ *
+ * parseFlags(Deno.args);
+ * ```
+ *
+ * ```console
+ * $ examples/flags/flags.ts -x 3 -y.z -n5 -abc --beep=boop foo bar baz --deno.land --deno.com -- --cliffy
+ * {
+ *   flags: {
+ *     x: "3",
+ *     y: { z: true },
+ *     n: "5",
+ *     a: true,
+ *     b: true,
+ *     c: true,
+ *     beep: "boop",
+ *     deno: { land: true, com: true }
+ *   },
+ *   literal: [ "--cliffy" ],
+ *   unknown: [ "foo", "bar", "baz" ],
+ *   stopEarly: false,
+ *   stopOnUnknown: false
+ * }
+ * ```
+ */
+export function parseFlags(argsOrCtx, opts = {}) {
+    let args;
+    let ctx;
+    if (Array.isArray(argsOrCtx)) {
+        ctx = {};
+        args = argsOrCtx;
+    }
+    else {
+        ctx = argsOrCtx;
+        args = argsOrCtx.unknown;
+        argsOrCtx.unknown = [];
+    }
+    args = args.slice();
+    ctx.flags ??= {};
+    ctx.literal ??= [];
+    ctx.unknown ??= [];
+    ctx.stopEarly = false;
+    ctx.stopOnUnknown = false;
+    ctx.defaults ??= {};
+    opts.dotted ??= true;
+    validateOptions(opts);
+    const options = parseArgs(ctx, args, opts);
+    validateFlags(ctx, opts, options);
+    if (opts.dotted) {
+        parseDottedOptions(ctx);
+    }
+    return ctx;
+}
+function validateOptions(opts) {
+    opts.flags?.forEach((opt) => {
+        opt.depends?.forEach((flag) => {
+            if (!opts.flags || !getOption(opts.flags, flag)) {
+                throw new UnknownRequiredOptionError(flag, opts.flags ?? []);
+            }
+        });
+        opt.conflicts?.forEach((flag) => {
+            if (!opts.flags || !getOption(opts.flags, flag)) {
+                throw new UnknownConflictingOptionError(flag, opts.flags ?? []);
+            }
+        });
+    });
+}
+function parseArgs(ctx, args, opts) {
+    /** Option name mapping: propertyName -> option.name */
+    const optionsMap = new Map();
+    let inLiteral = false;
+    for (let argsIndex = 0; argsIndex < args.length; argsIndex++) {
+        let option;
+        let current = args[argsIndex];
+        let currentValue;
+        let negate = false;
+        // literal args after --
+        if (inLiteral) {
+            ctx.literal.push(current);
+            continue;
+        }
+        else if (current === "--") {
+            inLiteral = true;
+            continue;
+        }
+        else if (ctx.stopEarly || ctx.stopOnUnknown) {
+            ctx.unknown.push(current);
+            continue;
+        }
+        const isFlag = current.length > 1 && current[0] === "-";
+        if (!isFlag) {
+            if (opts.stopEarly) {
+                ctx.stopEarly = true;
+            }
+            ctx.unknown.push(current);
+            continue;
+        }
+        const isShort = current[1] !== "-";
+        const isLong = isShort ? false : current.length > 3 && current[2] !== "-";
+        if (!isShort && !isLong) {
+            throw new InvalidOptionError(current, opts.flags ?? []);
+        }
+        // normalize short flags: -abc => -a -b -c
+        if (isShort && current.length > 2 && current[2] !== ".") {
+            args.splice(argsIndex, 1, ...splitFlags(current));
+            current = args[argsIndex];
+        }
+        else if (isLong && current.startsWith("--no-")) {
+            negate = true;
+        }
+        // split value: --foo="bar=baz" => --foo bar=baz
+        const equalSignIndex = current.indexOf("=");
+        if (equalSignIndex !== -1) {
+            currentValue = current.slice(equalSignIndex + 1) || undefined;
+            current = current.slice(0, equalSignIndex);
+        }
+        if (opts.flags) {
+            option = getOption(opts.flags, current);
+            if (!option) {
+                const name = current.replace(/^-+/, "");
+                option = matchWildCardOptions(name, opts.flags);
+                if (!option) {
+                    if (opts.stopOnUnknown) {
+                        ctx.stopOnUnknown = true;
+                        ctx.unknown.push(args[argsIndex]);
+                        continue;
+                    }
+                    throw new UnknownOptionError(current, opts.flags);
+                }
+            }
+        }
+        else {
+            option = {
+                name: current.replace(/^-+/, ""),
+                optionalValue: true,
+                type: OptionType.STRING,
+            };
+        }
+        if (option.standalone) {
+            ctx.standalone = option;
+        }
+        const positiveName = negate
+            ? option.name.replace(/^no-?/, "")
+            : option.name;
+        const propName = paramCaseToCamelCase(positiveName);
+        if (typeof ctx.flags[propName] !== "undefined") {
+            if (!opts.flags?.length) {
+                option.collect = true;
+            }
+            else if (!option.collect && !ctx.defaults[option.name]) {
+                throw new DuplicateOptionError(current);
+            }
+        }
+        if (option.type && !option.args?.length) {
+            option.args = [{
+                    type: option.type,
+                    optional: option.optionalValue,
+                    variadic: option.variadic,
+                    list: option.list,
+                    separator: option.separator,
+                }];
+        }
+        if (opts.flags?.length && !option.args?.length &&
+            typeof currentValue !== "undefined") {
+            throw new UnexpectedOptionValueError(option.name, currentValue);
+        }
+        let optionArgsIndex = 0;
+        let inOptionalArg = false;
+        const next = () => currentValue ?? args[argsIndex + 1];
+        const previous = ctx.flags[propName];
+        parseNext(option);
+        if (typeof ctx.flags[propName] === "undefined") {
+            if (option.args?.length && !option.args?.[optionArgsIndex].optional) {
+                throw new MissingOptionValueError(option.name);
+            }
+            else if (typeof option.default !== "undefined" &&
+                (option.type || option.value || option.args?.length)) {
+                ctx.flags[propName] = getDefaultValue(option);
+            }
+            else {
+                setFlagValue(true);
+            }
+        }
+        if (option.value) {
+            const value = option.value(ctx.flags[propName], previous);
+            setFlagValue(value);
+        }
+        else if (option.collect) {
+            const value = typeof previous !== "undefined"
+                ? (Array.isArray(previous) ? previous : [previous])
+                : [];
+            value.push(ctx.flags[propName]);
+            setFlagValue(value);
+        }
+        optionsMap.set(propName, option);
+        opts.option?.(option, ctx.flags[propName]);
+        /** Parse next argument for current option. */
+        // deno-lint-ignore no-inner-declarations
+        function parseNext(option) {
+            if (negate) {
+                setFlagValue(false);
+                return;
+            }
+            else if (!option.args?.length) {
+                setFlagValue(undefined);
+                return;
+            }
+            const arg = option.args[optionArgsIndex];
+            if (!arg) {
+                const flag = next();
+                throw new UnknownOptionError(flag, opts.flags ?? []);
+            }
+            if (!arg.type) {
+                arg.type = OptionType.BOOLEAN;
+            }
+            // make boolean values optional by default
+            if (!option.args?.length &&
+                arg.type === OptionType.BOOLEAN &&
+                arg.optional === undefined) {
+                arg.optional = true;
+            }
+            if (arg.optional) {
+                inOptionalArg = true;
+            }
+            else if (inOptionalArg) {
+                throw new UnexpectedRequiredArgumentError(option.name);
+            }
+            let result;
+            let increase = false;
+            if (arg.list && hasNext(arg)) {
+                const parsed = next()
+                    .split(arg.separator || ",")
+                    .map((nextValue) => {
+                    const value = parseValue(option, arg, nextValue);
+                    if (typeof value === "undefined") {
+                        throw new InvalidOptionValueError(option.name, arg.type ?? "?", nextValue);
+                    }
+                    return value;
+                });
+                if (parsed?.length) {
+                    result = parsed;
+                }
+            }
+            else {
+                if (hasNext(arg)) {
+                    result = parseValue(option, arg, next());
+                }
+                else if (arg.optional && arg.type === OptionType.BOOLEAN) {
+                    result = true;
+                }
+            }
+            if (increase && typeof currentValue === "undefined") {
+                argsIndex++;
+                if (!arg.variadic) {
+                    optionArgsIndex++;
+                }
+                else if (option.args[optionArgsIndex + 1]) {
+                    throw new UnexpectedArgumentAfterVariadicArgumentError(next());
+                }
+            }
+            if (typeof result !== "undefined" &&
+                (option.args.length > 1 || arg.variadic)) {
+                if (!ctx.flags[propName]) {
+                    setFlagValue([]);
+                }
+                ctx.flags[propName].push(result);
+                if (hasNext(arg)) {
+                    parseNext(option);
+                }
+            }
+            else {
+                setFlagValue(result);
+            }
+            /** Check if current option should have an argument. */
+            function hasNext(arg) {
+                if (!option.args?.length) {
+                    return false;
+                }
+                const nextValue = currentValue ?? args[argsIndex + 1];
+                if (!nextValue) {
+                    return false;
+                }
+                if (option.args.length > 1 && optionArgsIndex >= option.args.length) {
+                    return false;
+                }
+                if (!arg.optional) {
+                    return true;
+                }
+                // require optional values to be called with an equal sign: foo=bar
+                if (option.equalsSign && arg.optional && !arg.variadic &&
+                    typeof currentValue === "undefined") {
+                    return false;
+                }
+                if (arg.optional || arg.variadic) {
+                    return nextValue[0] !== "-" ||
+                        typeof currentValue !== "undefined" ||
+                        (arg.type === OptionType.NUMBER && !isNaN(Number(nextValue)));
+                }
+                return false;
+            }
+            /** Parse argument value.  */
+            function parseValue(option, arg, value) {
+                const result = opts.parse
+                    ? opts.parse({
+                        label: "Option",
+                        type: arg.type || OptionType.STRING,
+                        name: `--${option.name}`,
+                        value,
+                    })
+                    : parseDefaultType(option, arg, value);
+                if (typeof result !== "undefined") {
+                    increase = true;
+                }
+                return result;
+            }
+        }
+        // deno-lint-ignore no-inner-declarations
+        function setFlagValue(value) {
+            ctx.flags[propName] = value;
+            if (ctx.defaults[propName]) {
+                delete ctx.defaults[propName];
+            }
+        }
+    }
+    return optionsMap;
+}
+function parseDottedOptions(ctx) {
+    // convert dotted option keys into nested objects
+    ctx.flags = Object.keys(ctx.flags).reduce((result, key) => {
+        if (~key.indexOf(".")) {
+            key.split(".").reduce((
+            // deno-lint-ignore no-explicit-any
+            result, subKey, index, parts) => {
+                if (index === parts.length - 1) {
+                    result[subKey] = ctx.flags[key];
+                }
+                else {
+                    result[subKey] = result[subKey] ?? {};
+                }
+                return result[subKey];
+            }, result);
+        }
+        else {
+            result[key] = ctx.flags[key];
+        }
+        return result;
+    }, {});
+}
+function splitFlags(flag) {
+    flag = flag.slice(1);
+    const normalized = [];
+    const index = flag.indexOf("=");
+    const flags = (index !== -1 ? flag.slice(0, index) : flag).split("");
+    if (isNaN(Number(flag[flag.length - 1]))) {
+        flags.forEach((val) => normalized.push(`-${val}`));
+    }
+    else {
+        normalized.push(`-${flags.shift()}`);
+        if (flags.length) {
+            normalized.push(flags.join(""));
+        }
+    }
+    if (index !== -1) {
+        normalized[normalized.length - 1] += flag.slice(index);
+    }
+    return normalized;
+}
+function parseDefaultType(option, arg, value) {
+    const type = arg.type || OptionType.STRING;
+    const parseType = DefaultTypes[type];
+    if (!parseType) {
+        throw new UnknownTypeError(type, Object.keys(DefaultTypes));
+    }
+    return parseType({
+        label: "Option",
+        type,
+        name: `--${option.name}`,
+        value,
+    });
+}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/mod.d.ts

@@ -0,0 +1,9 @@
+export { parseFlags } from "./flags.js";
+export { type ArgumentOptions, type ArgumentType, type ArgumentValue, type DefaultValue, type DefaultValueHandler, type FlagOptions, type ParseFlagsContext, type ParseFlagsOptions, type TypeHandler, type ValueHandler, } from "./types.js";
+export { boolean } from "./types/boolean.js";
+export { integer } from "./types/integer.js";
+export { number } from "./types/number.js";
+export { string } from "./types/string.js";
+export { type IDefaultValue, type IFlagArgument, type IFlagOptions, type IFlagsResult, type IFlagValueHandler, type IParseOptions, type ITypeHandler, type ITypeInfo, OptionType, } from "./deprecated.js";
+export { InvalidTypeError, UnexpectedArgumentAfterVariadicArgumentError, UnexpectedRequiredArgumentError, UnknownTypeError, ValidationError, } from "./_errors.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gBAAgB,EAChB,4CAA4C,EAC5C,+BAA+B,EAC/B,gBAAgB,EAChB,eAAe,GAChB,MAAM,cAAc,CAAC"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/mod.js

@@ -0,0 +1,7 @@
+export { parseFlags } from "./flags.js";
+export { boolean } from "./types/boolean.js";
+export { integer } from "./types/integer.js";
+export { number } from "./types/number.js";
+export { string } from "./types/string.js";
+export { OptionType, } from "./deprecated.js";
+export { InvalidTypeError, UnexpectedArgumentAfterVariadicArgumentError, UnexpectedRequiredArgumentError, UnknownTypeError, ValidationError, } from "./_errors.js";

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/boolean.d.ts

@@ -0,0 +1,4 @@
+import type { TypeHandler } from "../types.js";
+/** Boolean type handler. Excepts `true`, `false`, `1`, `0` */
+export declare const boolean: TypeHandler<boolean>;
+//# sourceMappingURL=boolean.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,aAAa,CAAC;AAG9D,8DAA8D;AAC9D,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,OAAO,CAYxC,CAAC"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/boolean.js

@@ -0,0 +1,11 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Boolean type handler. Excepts `true`, `false`, `1`, `0` */
+export const boolean = (type) => {
+    if (~["1", "true"].indexOf(type.value)) {
+        return true;
+    }
+    if (~["0", "false"].indexOf(type.value)) {
+        return false;
+    }
+    throw new InvalidTypeError(type, ["true", "false", "1", "0"]);
+};

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/integer.d.ts

@@ -0,0 +1,4 @@
+import type { TypeHandler } from "../types.js";
+/** Integer type handler. Excepts any integer value. */
+export declare const integer: TypeHandler<number>;
+//# sourceMappingURL=integer.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/integer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,aAAa,CAAC;AAG9D,uDAAuD;AACvD,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,MAAM,CAOvC,CAAC"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/integer.js

@@ -0,0 +1,9 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Integer type handler. Excepts any integer value. */
+export const integer = (type) => {
+    const value = Number(type.value);
+    if (Number.isInteger(value)) {
+        return value;
+    }
+    throw new InvalidTypeError(type);
+};

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/number.d.ts

@@ -0,0 +1,4 @@
+import type { TypeHandler } from "../types.js";
+/** Number type handler. Excepts any numeric value. */
+export declare const number: TypeHandler<number>;
+//# sourceMappingURL=number.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,aAAa,CAAC;AAG9D,sDAAsD;AACtD,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAOtC,CAAC"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/number.js

@@ -0,0 +1,9 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Number type handler. Excepts any numeric value. */
+export const number = (type) => {
+    const value = Number(type.value);
+    if (Number.isFinite(value)) {
+        return value;
+    }
+    throw new InvalidTypeError(type);
+};

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/string.d.ts

@@ -0,0 +1,4 @@
+import type { TypeHandler } from "../types.js";
+/** String type handler. Excepts any value. */
+export declare const string: TypeHandler<string>;
+//# sourceMappingURL=string.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,aAAa,CAAC;AAE9D,8CAA8C;AAC9C,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAItC,CAAC"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types/string.js

@@ -0,0 +1,4 @@
+/** String type handler. Excepts any value. */
+export const string = ({ value }) => {
+    return value;
+};

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types.d.ts

@@ -0,0 +1,137 @@
+/** Parser options. */
+export interface ParseFlagsOptions<TFlagOptions extends FlagOptions = FlagOptions> {
+    /** An array of flag options. */
+    flags?: Array<TFlagOptions>;
+    /** Parser callback function for custom types. */
+    parse?: TypeHandler<unknown>;
+    /** Option callback function. Will be called for all parsed options. */
+    option?: (option: TFlagOptions, value?: unknown) => void;
+    /**
+     * Enable stop early. If enabled, all arguments starting from the first non
+     * option argument will be added to the unknown array.
+     *
+     * For example:
+     *     `command --debug-level warning server --port 80`
+     *
+     * Will result in:
+     *     - flags: `{ debugLevel: 'warning' }`
+     *     - unknown: `['server', '--port', '80']`
+     */
+    stopEarly?: boolean;
+    /** Works similar to `stopEarly`, bit stops on first unknown option or argument. */
+    stopOnUnknown?: boolean;
+    /**
+     * Don't throw an error when no arguments are passed to the `parseFlags`
+     * function.
+     */
+    allowEmpty?: boolean;
+    /** Ignore default values for defined flags. */
+    ignoreDefaults?: Record<string, unknown>;
+    /** Enable/disable dotted options. Default is `true`. */
+    dotted?: boolean;
+}
+/** Flag options. */
+export interface FlagOptions extends Omit<ArgumentOptions, "optional"> {
+    /** The name of the flag. */
+    name: string;
+    /** An array of argument options. */
+    args?: Array<ArgumentOptions>;
+    /** Mark argument as optional. */
+    optionalValue?: boolean;
+    /** Name aliases. */
+    aliases?: string[];
+    /** If enabled, option cannot be combined with other options. */
+    standalone?: boolean;
+    /** Default value. */
+    default?: DefaultValue;
+    /** Mark flag as required. */
+    required?: boolean;
+    /**
+     * An array of required flags that needs to be called together with this flag.
+     * If one of the flags is missing, an error will be thrown.
+     */
+    depends?: string[];
+    /**
+     * An array of conflicting flags that cannot be called together with this flag.
+     * If one of the flags is used together with this flag, an error will be
+     * thrown.
+     */
+    conflicts?: string[];
+    /**
+     * A callback function to map the flag value(s). The first argument if the
+     * callback function is the current value, and the second argument is an array
+     * of previous values when combined with the `collect` option.
+     */
+    value?: ValueHandler;
+    /**
+     * If enabled, the flag can be used multiple times and all values will be
+     * collected into an array.
+     */
+    collect?: boolean;
+    /**
+     * If enabled, the argument must be assigned with an equals sign to the flag
+     * `--flag=<value>`, otherwise the value for this option will be ignored.
+     */
+    equalsSign?: boolean;
+}
+/** Options for a flag argument. */
+export interface ArgumentOptions {
+    /** Argument type. */
+    type?: ArgumentType | string;
+    /** Make argument optional. */
+    optional?: boolean;
+    /** Make argument variadic. */
+    variadic?: boolean;
+    /**
+     * If enabled, argument will be separated by a separator defined with the
+     * `separator` option.
+     */
+    list?: boolean;
+    /** List separator. */
+    separator?: string;
+}
+/** Available build-in argument types. */
+export type ArgumentType = "string" | "boolean" | "number" | "integer";
+/** Default flag value or a callback method that returns the default value. */
+export type DefaultValue<TValue = unknown> = TValue | DefaultValueHandler<TValue>;
+/** Default value callback function to lazy load the default value. */
+export type DefaultValueHandler<TValue = unknown> = () => TValue;
+/** A callback method for custom processing or mapping of flag values. */
+export type ValueHandler<TValue = any, TReturn = TValue> = (val: TValue, previous?: TReturn) => TReturn;
+/**
+ * Parse result. The parse context will be returned by the `parseFlags` method
+ * and can be also passed as first argument to the `parseFlags` method.
+ */
+export interface ParseFlagsContext<TFlags extends Record<string, any> = Record<string, any>, TStandaloneOption extends FlagOptions = FlagOptions> {
+    /** An object of parsed flags. */
+    flags: TFlags;
+    /** An array of unknown arguments. */
+    unknown: Array<string>;
+    /** An array of arguments defined after the double dash ` -- `. */
+    literal: Array<string>;
+    /** Matched standalone option. */
+    standalone?: TStandaloneOption;
+    /** Is set to `true` if `stopEarly` option is enabled. */
+    stopEarly: boolean;
+    /** Is set to `true` if `stopOnUnknown` option is enabled. */
+    stopOnUnknown: boolean;
+    /** A map of option names and default values. */
+    defaults: Record<string, boolean>;
+}
+/** Argument parsing informations. */
+export interface ArgumentValue {
+    /** A lable/name which describes the kind of argument, e.g: `Option`. */
+    label: string;
+    /** The type of the argument. */
+    type: ArgumentType | string;
+    /** The name of the argument. */
+    name: string;
+    /** The value of the argument. */
+    value: string;
+}
+/**
+ * Parse method for custom types. Gets the raw user input passed as argument
+ * and returns the parsed value.
+ */
+export type TypeHandler<TReturn = unknown> = (arg: ArgumentValue) => TReturn;
+//# sourceMappingURL=types.d.ts.map

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.8/types.js

@@ -0,0 +1 @@
+export {};

package/esm/deps/jsr.io/@cliffy/internal/1.0.0-rc.8/runtime/exit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Exit the current process with optional exit code.
+ *
+ * @internal
+ * @param code The exit code.
+ */
+export declare function exit(code: number): never;
+//# sourceMappingURL=exit.d.ts.map

package/esm/deps/jsr.io/@cliffy/internal/1.0.0-rc.8/runtime/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/internal/1.0.0-rc.8/runtime/exit.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAUxC"}