windmill-cli 0.0.1

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/spinner.js

@@ -0,0 +1,198 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Spinner_spinner, _Spinner_interval, _Spinner_color, _Spinner_intervalId, _Spinner_active;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { getNoColor } from "../../../internal/1.0.0-rc.5/runtime/no_color.js";
+import { writeSync } from "../../../internal/1.0.0-rc.5/runtime/write_sync.js";
+const encoder = new TextEncoder();
+const LINE_CLEAR = encoder.encode("\r\u001b[K"); // From cli/prompt_secret.ts
+const COLOR_RESET = "\u001b[0m";
+const DEFAULT_INTERVAL = 75;
+const DEFAULT_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const COLORS = {
+    black: "\u001b[30m",
+    red: "\u001b[31m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    blue: "\u001b[34m",
+    magenta: "\u001b[35m",
+    cyan: "\u001b[36m",
+    white: "\u001b[37m",
+    gray: "\u001b[90m",
+};
+/**
+ * A spinner that can be used to indicate that something is loading.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * import { Spinner } from "./spinner.ts";
+ *
+ * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+ * spinner.start();
+ *
+ * setTimeout(() => {
+ *  spinner.stop();
+ *  console.log("Finished loading!");
+ * }, 3_000);
+ * ```
+ */
+export class Spinner {
+    /**
+     * Creates a new spinner.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { Spinner } from "./spinner.ts";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.stop();
+     * ```
+     */
+    constructor({ spinner = DEFAULT_SPINNER, message = "", interval = DEFAULT_INTERVAL, color, } = {}) {
+        _Spinner_spinner.set(this, void 0);
+        /**
+         * The message to display next to the spinner.
+         * This can be changed while the spinner is active.
+         *
+         * @example Usage
+         * ```ts no-eval
+         * import { Spinner } from "./spinner.ts";
+         *
+         * const spinner = new Spinner({ message: "Working..." });
+         * spinner.start();
+         *
+         * for (let step = 0; step < 5; step++) {
+         *   // do some work
+         *   await new Promise((resolve) => setTimeout(resolve, 1000));
+         *
+         *   spinner.message = `Finished Step #${step}`;
+         * }
+         *
+         * spinner.stop();
+         * console.log("Done!");
+         * ```
+         */
+        Object.defineProperty(this, "message", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _Spinner_interval.set(this, void 0);
+        _Spinner_color.set(this, void 0);
+        _Spinner_intervalId.set(this, void 0);
+        _Spinner_active.set(this, false);
+        __classPrivateFieldSet(this, _Spinner_spinner, spinner, "f");
+        this.message = message;
+        __classPrivateFieldSet(this, _Spinner_interval, interval, "f");
+        this.color = color;
+    }
+    /**
+     * Set the color of the spinner. This defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     *
+     * Providing `undefined` will use the default terminal color.
+     *
+     * @param value Color to set.
+     *
+     * @example Usage
+     * ```ts no-eval
+     * import { Spinner } from "./spinner.ts";
+     *
+     * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+     * spinner.start();
+     *
+     * // do some work
+     * await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     * spinner.color = "magenta";
+     * ```
+     */
+    set color(value) {
+        __classPrivateFieldSet(this, _Spinner_color, value ? COLORS[value] : undefined, "f");
+    }
+    /**
+     * Get the current color of the spinner.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { Spinner } from "./spinner.ts";
+     *
+     * const spinner = new Spinner({ message: "Loading", color: "blue" });
+     *
+     * spinner.color; // Blue ANSI escape sequence
+     * ```
+     * @returns The color of the spinner or `undefined` if it's using the terminal default.
+     */
+    get color() {
+        return __classPrivateFieldGet(this, _Spinner_color, "f");
+    }
+    /**
+     * Starts the spinner.
+     *
+     * @example Usage
+     * ```ts no-eval
+     * import { Spinner } from "./spinner.ts";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     * ```
+     */
+    start() {
+        // deno-lint-ignore no-explicit-any
+        if (__classPrivateFieldGet(this, _Spinner_active, "f") || dntShim.dntGlobalThis.Deno?.stdout.writable.locked) {
+            return;
+        }
+        __classPrivateFieldSet(this, _Spinner_active, true, "f");
+        let i = 0;
+        const noColor = getNoColor();
+        // Updates the spinner after the given interval.
+        const updateFrame = () => {
+            const color = __classPrivateFieldGet(this, _Spinner_color, "f") ?? "";
+            const frame = encoder.encode(noColor
+                ? __classPrivateFieldGet(this, _Spinner_spinner, "f")[i] + " " + this.message
+                : color + __classPrivateFieldGet(this, _Spinner_spinner, "f")[i] + COLOR_RESET + " " + this.message);
+            // call writeSync once to reduce flickering
+            const writeData = new Uint8Array(LINE_CLEAR.length + frame.length);
+            writeData.set(LINE_CLEAR);
+            writeData.set(frame, LINE_CLEAR.length);
+            writeSync(writeData);
+            i = (i + 1) % __classPrivateFieldGet(this, _Spinner_spinner, "f").length;
+        };
+        __classPrivateFieldSet(this, _Spinner_intervalId, setInterval(updateFrame, __classPrivateFieldGet(this, _Spinner_interval, "f")), "f");
+    }
+    /**
+     * Stops the spinner.
+     *
+     * @example Usage
+     * ```ts no-eval
+     * import { Spinner } from "./spinner.ts";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     *
+     * setTimeout(() => {
+     *  spinner.stop();
+     *  console.log("Finished loading!");
+     * }, 3_000);
+     * ```
+     */
+    stop() {
+        if (__classPrivateFieldGet(this, _Spinner_intervalId, "f") && __classPrivateFieldGet(this, _Spinner_active, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _Spinner_intervalId, "f"));
+            writeSync(LINE_CLEAR); // Clear the current line
+            __classPrivateFieldSet(this, _Spinner_active, false, "f");
+        }
+    }
+}
+_Spinner_spinner = new WeakMap(), _Spinner_interval = new WeakMap(), _Spinner_color = new WeakMap(), _Spinner_intervalId = new WeakMap(), _Spinner_active = new WeakMap();

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeUpgradeOptions } from "./runtime.js";
+import type { DenoRuntimeOptions } from "./runtime/deno_runtime.js";
+/** Shared runtime options. */
+export interface RuntimeOptions {
+    args?: Array<string>;
+    main?: string;
+}
+/** Runtime options map for supported runtimes. */
+export interface RuntimeOptionsMap {
+    deno?: RuntimeOptions & DenoRuntimeOptions;
+    node?: RuntimeOptions;
+    bun?: RuntimeOptions;
+}
+/**
+ * Options for upgrading a package from a provided registry with any supported
+ * runtimes.
+ * Currently supported runtimes are: `deno`, `node` and `bun`.
+ */
+export interface UpgradeOptions extends RuntimeUpgradeOptions {
+    runtime?: RuntimeOptionsMap;
+}
+/**
+ * Upgrade a package from given registry.
+ * Runtime is auto-detected. Currently supported runtimes are: `deno`, `node` and `bun`.
+ */
+export declare function upgrade({ runtime: runtimeOptions, provider, ...options }: UpgradeOptions): Promise<void>;
+//# sourceMappingURL=upgrade.d.ts.map

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,kDAAkD;AAClD,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,cAAc,GAAG,kBAAkB,CAAC;IAC3C,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAe,SAAQ,qBAAqB;IAC3D,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,EACE,OAAO,EAAE,cAAc,EACvB,QAAQ,EACR,GAAG,OAAO,EACX,EAAE,cAAc,GAChB,OAAO,CAAC,IAAI,CAAC,CA0Df"}

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade.js

@@ -0,0 +1,42 @@
+import { bold, brightBlue, dim, red } from "../../../../@std/fmt/0.225.6/colors.js";
+import { getRuntime } from "./get_runtime.js";
+/**
+ * Upgrade a package from given registry.
+ * Runtime is auto-detected. Currently supported runtimes are: `deno`, `node` and `bun`.
+ */
+export async function upgrade({ runtime: runtimeOptions, provider, ...options }) {
+    if (options.force ||
+        !options.from ||
+        await provider.isOutdated(options.name, options.from, options.to)) {
+        if (options.to === "latest") {
+            options.logger?.log(dim("Upgrading %s to the %s version"), options.name, options.to);
+            const { latest } = await provider.getVersions(options.name);
+            options.to = latest;
+        }
+        else {
+            options.logger?.log(dim("Upgrading %s to version %s"), options.name, options.to);
+        }
+        options.logger?.log(dim("Upgrading %s:"), options.name);
+        options.logger?.log(dim("  - current version: %s"), options.from);
+        options.logger?.log(dim("  - target version: %s"), options.to);
+        try {
+            if (provider.upgrade) {
+                await provider.upgrade(options);
+            }
+            else {
+                const { runtimeName, runtime } = await getRuntime();
+                options.logger?.log(dim("  - runtime: %s"), runtimeName);
+                await runtime.upgrade({
+                    ...options,
+                    ...(runtimeOptions?.[runtimeName] ?? {}),
+                    provider,
+                });
+            }
+        }
+        catch (error) {
+            options.logger?.error(red(`Failed to upgrade ${bold(options.name)} ${options.from ? `from version ${bold(options.from)} ` : ""}to ${bold(options.to)}.`));
+            throw error;
+        }
+        options.logger?.info(brightBlue(`Successfully upgraded ${bold(options.name)} from version ${bold(options.from ?? "")} to ${bold(options.to)}!`), dim(`(${provider.getRepositoryUrl(options.name, options.to)})`));
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade_command.d.ts

@@ -0,0 +1,52 @@
+import { Command } from "../command.js";
+import type { Provider, Versions } from "./provider.js";
+import { type RuntimeOptions, type RuntimeOptionsMap } from "./upgrade.js";
+export interface UpgradeCommandOptions<TProvider extends Provider = Provider> extends RuntimeOptions {
+    provider: TProvider | Array<TProvider>;
+    runtime?: RuntimeOptionsMap;
+}
+/**
+ * The `UpgradeCommand` adds an upgrade functionality to the cli to be able to
+ * seamlessly upgrade the cli to the latest or a specific version from a
+ * provided registry with any supported runtime.
+ * Currently supported runtimes are: `deno`, `node` and `bun`.
+ *
+ * @example Upgrade command example.
+ *
+ * ```
+ * import { Command } from "@cliffy/command";
+ * import { UpgradeCommand } from "@cliffy/command/upgrade";
+ * import { DenoLandProvider } from "@cliffy/command/upgrade/provider/deno-land";
+ * import { GithubProvider } from "@cliffy/command/upgrade/provider/github";
+ * import { JsrProvider } from "@cliffy/command/upgrade/provider/jsr";
+ * import { NestLandProvider } from "@cliffy/command/upgrade/provider/nest-land";
+ * import { NpmProvider } from "@cliffy/command/upgrade/provider/npm";
+ *
+ * await new Command()
+ *   .name("my-cli")
+ *   .version("0.2.1")
+ *   .command(
+ *     "upgrade",
+ *     new UpgradeCommand({
+ *       provider: [
+ *         new JsrProvider({ scope: "examples" }),
+ *         new NpmProvider({ scope: "examples" }),
+ *         new DenoLandProvider(),
+ *         new NestLandProvider(),
+ *         new GithubProvider({ repository: "examples/my-cli" }),
+ *       ],
+ *     }),
+ *   )
+ *   .parse();
+ * ```
+ */
+export declare class UpgradeCommand extends Command {
+    private readonly providers;
+    constructor({ provider, ...options }: UpgradeCommandOptions);
+    getAllVersions(): Promise<Array<string>>;
+    getLatestVersion(): Promise<string>;
+    getVersions(): Promise<Versions>;
+    private getProvider;
+    private getProviderNames;
+}
+//# sourceMappingURL=upgrade_command.d.ts.map

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade_command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade_command.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEvB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,qBAAqB,CACpC,SAAS,SAAS,QAAQ,GAAG,QAAQ,CACrC,SAAQ,cAAc;IACtB,QAAQ,EAAE,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IACvC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,cAAe,SAAQ,OAAO;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAGlD,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,EAAE,qBAAqB;IAsGpC,cAAc,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAKxC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKzC,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC;IAMvC,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,gBAAgB;CAGzB"}

package/esm/deps/jsr.io/@cliffy/command/1.0.0-rc.5/upgrade/upgrade_command.js

@@ -0,0 +1,133 @@
+import { bold, brightBlue } from "../../../../@std/fmt/0.225.6/colors.js";
+import { ValidationError } from "../_errors.js";
+import { exit } from "../../../internal/1.0.0-rc.5/runtime/exit.js";
+import { Command } from "../command.js";
+import { EnumType } from "../types/enum.js";
+import { createLogger } from "./logger.js";
+import { Spinner } from "./spinner.js";
+import { upgrade, } from "./upgrade.js";
+/**
+ * The `UpgradeCommand` adds an upgrade functionality to the cli to be able to
+ * seamlessly upgrade the cli to the latest or a specific version from a
+ * provided registry with any supported runtime.
+ * Currently supported runtimes are: `deno`, `node` and `bun`.
+ *
+ * @example Upgrade command example.
+ *
+ * ```
+ * import { Command } from "@cliffy/command";
+ * import { UpgradeCommand } from "@cliffy/command/upgrade";
+ * import { DenoLandProvider } from "@cliffy/command/upgrade/provider/deno-land";
+ * import { GithubProvider } from "@cliffy/command/upgrade/provider/github";
+ * import { JsrProvider } from "@cliffy/command/upgrade/provider/jsr";
+ * import { NestLandProvider } from "@cliffy/command/upgrade/provider/nest-land";
+ * import { NpmProvider } from "@cliffy/command/upgrade/provider/npm";
+ *
+ * await new Command()
+ *   .name("my-cli")
+ *   .version("0.2.1")
+ *   .command(
+ *     "upgrade",
+ *     new UpgradeCommand({
+ *       provider: [
+ *         new JsrProvider({ scope: "examples" }),
+ *         new NpmProvider({ scope: "examples" }),
+ *         new DenoLandProvider(),
+ *         new NestLandProvider(),
+ *         new GithubProvider({ repository: "examples/my-cli" }),
+ *       ],
+ *     }),
+ *   )
+ *   .parse();
+ * ```
+ */
+export class UpgradeCommand extends Command {
+    constructor({ provider, ...options }) {
+        super();
+        Object.defineProperty(this, "providers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.providers = Array.isArray(provider) ? provider : [provider];
+        if (!this.providers.length) {
+            throw new Error(`No upgrade provider defined!`);
+        }
+        this
+            .description(() => `Upgrade ${this.getMainCommand().getName()} executable to latest or given version.`)
+            .noGlobals()
+            .type("provider", new EnumType(this.getProviderNames()))
+            .option("-r, --registry <name:provider>", `The registry name from which to upgrade.`, {
+            default: this.getProvider().name,
+            hidden: this.providers.length < 2,
+            value: (registry) => this.getProvider(registry),
+        })
+            .option("-l, --list-versions", "Show available versions.", {
+            action: async ({ registry }) => {
+                await registry.listVersions(this.getMainCommand().getName(), this.getVersion());
+                exit(0);
+            },
+        })
+            .option("--version <version:string:version>", "The version to upgrade to.", { default: "latest" })
+            .option("-f, --force", "Replace current installation even if not out-of-date.")
+            .option("-v, --verbose", "Log verbose output.")
+            .option("--no-spinner", "Disable spinner.")
+            .complete("version", () => this.getAllVersions())
+            .action(async ({ registry: provider, version, force, verbose, spinner: spinnerEnabled, }) => {
+            const name = this.getMainCommand().getName();
+            const currentVersion = this.getVersion();
+            const spinner = spinnerEnabled
+                ? new Spinner({
+                    message: brightBlue(`Upgrading ${bold(name)} from version ${bold(currentVersion ?? "")} to ${bold(version)}...`),
+                })
+                : undefined;
+            const logger = createLogger({ spinner, verbose });
+            spinner?.start();
+            provider.setLogger(logger);
+            try {
+                await upgrade({
+                    name,
+                    to: version,
+                    from: currentVersion,
+                    force,
+                    provider,
+                    verbose,
+                    logger,
+                    ...options,
+                });
+            }
+            catch (error) {
+                logger.error(!verbose && error instanceof Error ? error.message : error);
+                spinner?.stop();
+                exit(1);
+            }
+            finally {
+                spinner?.stop();
+            }
+        });
+    }
+    async getAllVersions() {
+        const { versions } = await this.getVersions();
+        return versions;
+    }
+    async getLatestVersion() {
+        const { latest } = await this.getVersions();
+        return latest;
+    }
+    getVersions() {
+        return this.getProvider().getVersions(this.getMainCommand().getName());
+    }
+    getProvider(name) {
+        const provider = name
+            ? this.providers.find((provider) => provider.name === name)
+            : this.providers[0];
+        if (!provider) {
+            throw new ValidationError(`Unknown provider "${name}"`);
+        }
+        return provider;
+    }
+    getProviderNames() {
+        return this.providers.map((provider) => provider.name);
+    }
+}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.5/_errors.d.ts

@@ -0,0 +1,61 @@
+import type { ArgumentValue, FlagOptions } from "./types.js";
+export declare class FlagsError extends Error {
+    constructor(message: string);
+}
+export declare class UnknownRequiredOptionError extends FlagsError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownConflictingOptionError extends FlagsError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownTypeError extends FlagsError {
+    constructor(type: string, types: Array<string>);
+}
+/**
+ * A validation error is thrown when the command is wrongly used by the user.
+ * For example: If the user passes some invalid options or arguments to the
+ * command.
+ */
+export declare class ValidationError extends FlagsError {
+    constructor(message: string);
+}
+export declare class DuplicateOptionError extends ValidationError {
+    constructor(name: string);
+}
+export declare class InvalidOptionError extends ValidationError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownOptionError extends ValidationError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class MissingOptionValueError extends ValidationError {
+    constructor(option: string);
+}
+export declare class InvalidOptionValueError extends ValidationError {
+    constructor(option: string, expected: string, value: string);
+}
+export declare class UnexpectedOptionValueError extends ValidationError {
+    constructor(option: string, value: string);
+}
+export declare class OptionNotCombinableError extends ValidationError {
+    constructor(option: string);
+}
+export declare class ConflictingOptionError extends ValidationError {
+    constructor(option: string, conflictingOption: string);
+}
+export declare class DependingOptionError extends ValidationError {
+    constructor(option: string, dependingOption: string);
+}
+export declare class MissingRequiredOptionError extends ValidationError {
+    constructor(option: string);
+}
+export declare class UnexpectedRequiredArgumentError extends ValidationError {
+    constructor(arg: string);
+}
+export declare class UnexpectedArgumentAfterVariadicArgumentError extends ValidationError {
+    constructor(arg: string);
+}
+export declare class InvalidTypeError extends ValidationError {
+    constructor({ label, name, value, type }: ArgumentValue, expected?: Array<string | number | boolean>);
+}
+//# sourceMappingURL=_errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_errors.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.5/_errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,0BAA2B,SAAQ,UAAU;gBAC5C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC;CAQxD;AAED,qBAAa,6BAA8B,SAAQ,UAAU;gBAC/C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC;CAQxD;AAED,qBAAa,gBAAiB,SAAQ,UAAU;gBAClC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;CAI/C;AAID;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,UAAU;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,oBAAqB,SAAQ,eAAe;gBAC3C,IAAI,EAAE,MAAM;CAQzB;AAED,qBAAa,kBAAmB,SAAQ,eAAe;gBACzC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC;CAQxD;AAED,qBAAa,kBAAmB,SAAQ,eAAe;gBACzC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC;CAQxD;AAED,qBAAa,uBAAwB,SAAQ,eAAe;gBAC9C,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,uBAAwB,SAAQ,eAAe;gBAC9C,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAQ5D;AAED,qBAAa,0BAA2B,SAAQ,eAAe;gBACjD,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAM1C;AAED,qBAAa,wBAAyB,SAAQ,eAAe;gBAC/C,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,sBAAuB,SAAQ,eAAe;gBAC7C,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;CAQtD;AAED,qBAAa,oBAAqB,SAAQ,eAAe;gBAC3C,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;CAQpD;AAED,qBAAa,0BAA2B,SAAQ,eAAe;gBACjD,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,+BAAgC,SAAQ,eAAe;gBACtD,GAAG,EAAE,MAAM;CASxB;AAED,qBAAa,4CACX,SAAQ,eAAe;gBACX,GAAG,EAAE,MAAM;CAOxB;AAED,qBAAa,gBAAiB,SAAQ,eAAe;gBAEjD,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,aAAa,EAC3C,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAa9C"}

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

@@ -0,0 +1,117 @@
+import { didYouMeanOption, didYouMeanType, getFlag } from "./_utils.js";
+export class FlagsError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, FlagsError.prototype);
+    }
+}
+export class UnknownRequiredOptionError extends FlagsError {
+    constructor(option, options) {
+        super(`Unknown required option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownRequiredOptionError.prototype);
+    }
+}
+export class UnknownConflictingOptionError extends FlagsError {
+    constructor(option, options) {
+        super(`Unknown conflicting option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownConflictingOptionError.prototype);
+    }
+}
+export class UnknownTypeError extends FlagsError {
+    constructor(type, types) {
+        super(`Unknown type "${type}".${didYouMeanType(type, types)}`);
+        Object.setPrototypeOf(this, UnknownTypeError.prototype);
+    }
+}
+/* Validation errors. */
+/**
+ * A validation error is thrown when the command is wrongly used by the user.
+ * For example: If the user passes some invalid options or arguments to the
+ * command.
+ */
+export class ValidationError extends FlagsError {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+export class DuplicateOptionError extends ValidationError {
+    constructor(name) {
+        super(`Option "${getFlag(name).replace(/^--no-/, "--")}" can only occur once, but was found several times.`);
+        Object.setPrototypeOf(this, DuplicateOptionError.prototype);
+    }
+}
+export class InvalidOptionError extends ValidationError {
+    constructor(option, options) {
+        super(`Invalid option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, InvalidOptionError.prototype);
+    }
+}
+export class UnknownOptionError extends ValidationError {
+    constructor(option, options) {
+        super(`Unknown option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownOptionError.prototype);
+    }
+}
+export class MissingOptionValueError extends ValidationError {
+    constructor(option) {
+        super(`Missing value for option "${getFlag(option)}".`);
+        Object.setPrototypeOf(this, MissingOptionValueError.prototype);
+    }
+}
+export class InvalidOptionValueError extends ValidationError {
+    constructor(option, expected, value) {
+        super(`Option "${getFlag(option)}" must be of type "${expected}", but got "${value}".`);
+        Object.setPrototypeOf(this, InvalidOptionValueError.prototype);
+    }
+}
+export class UnexpectedOptionValueError extends ValidationError {
+    constructor(option, value) {
+        super(`Option "${getFlag(option)}" doesn't take a value, but got "${value}".`);
+        Object.setPrototypeOf(this, InvalidOptionValueError.prototype);
+    }
+}
+export class OptionNotCombinableError extends ValidationError {
+    constructor(option) {
+        super(`Option "${getFlag(option)}" cannot be combined with other options.`);
+        Object.setPrototypeOf(this, OptionNotCombinableError.prototype);
+    }
+}
+export class ConflictingOptionError extends ValidationError {
+    constructor(option, conflictingOption) {
+        super(`Option "${getFlag(option)}" conflicts with option "${getFlag(conflictingOption)}".`);
+        Object.setPrototypeOf(this, ConflictingOptionError.prototype);
+    }
+}
+export class DependingOptionError extends ValidationError {
+    constructor(option, dependingOption) {
+        super(`Option "${getFlag(option)}" depends on option "${getFlag(dependingOption)}".`);
+        Object.setPrototypeOf(this, DependingOptionError.prototype);
+    }
+}
+export class MissingRequiredOptionError extends ValidationError {
+    constructor(option) {
+        super(`Missing required option "${getFlag(option)}".`);
+        Object.setPrototypeOf(this, MissingRequiredOptionError.prototype);
+    }
+}
+export class UnexpectedRequiredArgumentError extends ValidationError {
+    constructor(arg) {
+        super(`An required argument cannot follow an optional argument, but "${arg}"  is defined as required.`);
+        Object.setPrototypeOf(this, UnexpectedRequiredArgumentError.prototype);
+    }
+}
+export class UnexpectedArgumentAfterVariadicArgumentError extends ValidationError {
+    constructor(arg) {
+        super(`An argument cannot follow an variadic argument, but got "${arg}".`);
+        Object.setPrototypeOf(this, UnexpectedArgumentAfterVariadicArgumentError.prototype);
+    }
+}
+export class InvalidTypeError extends ValidationError {
+    constructor({ label, name, value, type }, expected) {
+        super(`${label} "${name}" must be of type "${type}", but got "${value}".` + (expected
+            ? ` Expected values: ${expected.map((value) => `"${value}"`).join(", ")}`
+            : ""));
+        Object.setPrototypeOf(this, MissingOptionValueError.prototype);
+    }
+}

package/esm/deps/jsr.io/@cliffy/flags/1.0.0-rc.5/_utils.d.ts

@@ -0,0 +1,17 @@
+import type { FlagOptions } from "./types.js";
+/** Convert param case string to camel case. */
+export declare function paramCaseToCamelCase(str: string): string;
+/**
+ * Find option by flag, name or alias.
+ *
+ * @param flags Source options array.
+ * @param name  Name of the option.
+ */
+export declare function getOption<O extends FlagOptions>(flags: Array<O>, name: string): O | undefined;
+export declare function didYouMeanOption(option: string, options: Array<FlagOptions>): string;
+export declare function didYouMeanType(type: string, types: Array<string>): string;
+export declare function didYouMean(message: string, type: string, types: Array<string>): string;
+export declare function getFlag(name: string): string;
+export declare function matchWildCardOptions(name: string, flags: Array<FlagOptions>): FlagOptions | undefined;
+export declare function getDefaultValue(option: FlagOptions): unknown;
+//# sourceMappingURL=_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.0.0-rc.5/_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,+CAA+C;AAC/C,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAC7C,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,SAAS,CAYf;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,GAC1B,MAAM,CAMR;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAEzE;AAED,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GACnB,MAAM,CAKR;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,UAQnC;AAaD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,GACxB,WAAW,GAAG,SAAS,CAYzB;AAoBD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAI5D"}