git-remote-ops 0.1.0

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_errors.d.ts

@@ -0,0 +1,67 @@
+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 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>);
+}
+export declare class MissingArgumentError extends ValidationError {
+    constructor(name: string);
+}
+export declare class MissingArgumentsError extends ValidationError {
+    constructor(names: Array<string>);
+}
+export declare class TooManyArgumentsError extends ValidationError {
+    constructor(args: Array<string>);
+}
+//# sourceMappingURL=_errors.d.ts.map

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_errors.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/_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,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;AAED,qBAAa,oBAAqB,SAAQ,eAAe;gBAC3C,IAAI,EAAE,MAAM;CAIzB;AAED,qBAAa,qBAAsB,SAAQ,eAAe;gBAC5C,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;CAIjC;AAED,qBAAa,qBAAsB,SAAQ,eAAe;gBAC5C,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;CAIhC"}

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_utils.d.ts

@@ -0,0 +1,17 @@
+import type { ArgumentOptions, 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 | ArgumentOptions): unknown;
+//# sourceMappingURL=_utils.d.ts.map

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG/D,+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,GAAG,MAAM,CAQ5C;AAaD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,GACxB,WAAW,GAAG,SAAS,CAYzB;AAgCD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,WAAW,GAAG,eAAe,GACpC,OAAO,CAQT"}

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_validate_flags.d.ts

@@ -0,0 +1,11 @@
+import type { ParseFlagsContext, ParseFlagsOptions } from "./types.js";
+import type { FlagOptions } from "./types.js";
+/**
+ * Flags post validation. Validations that are not already done by the parser.
+ *
+ * @param ctx     Parse context.
+ * @param opts    Parse options.
+ * @param options Option name mappings: propertyName -> option
+ */
+export declare function validateFlags<TOptions extends FlagOptions = FlagOptions>(ctx: ParseFlagsContext<Record<string, unknown>>, opts: ParseFlagsOptions<TOptions>, options?: Map<string, FlagOptions>): void;
+//# sourceMappingURL=_validate_flags.d.ts.map

package/types/deps/jsr.io/@cliffy/flags/1.1.0/_validate_flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_validate_flags.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/_validate_flags.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,WAAW,GAAG,WAAW,EACtE,GAAG,EAAE,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC/C,IAAI,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EACjC,OAAO,GAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAa,GAC5C,IAAI,CA4BN"}

package/types/deps/jsr.io/@cliffy/flags/1.1.0/flags.d.ts

@@ -0,0 +1,154 @@
+import type { FlagOptions, ParseFlagsContext, ParseFlagsOptions } from "./types.js";
+/**
+ * Command-line arguments parser with built-in validations.
+ *
+ * The `parseFlags` method takes as its first argument the arguments to be parsed,
+ * usually `Deno.args`, or a {@linkcode ParseFlagsContext}. As the second
+ * argument you can define {@linkcode ParseFlagsOptions}.
+ *
+ * ### Basic usage
+ *
+ * If `parseFlags` is called without defining specific flags with the options
+ * object, all arguments are parsed and added to the flags object returned by the
+ * `parseFlags` method. All non-options arguments are added to the `unknown` array
+ * and all flags specified after the double dash (`--`) are added to the `literal`
+ * array.
+ *
+ * @example Parse arguments without validation
+ *
+ * ```typescript
+ * import { parseFlags } from "https://deno.land/x/cliffy/flags/mod.ts";
+ *
+ * console.log(parseFlags(Deno.args));
+ * ```
+ *
+ * ```console
+ * $ deno run https://deno.land/x/cliffy/examples/flags/flags.ts -a foo -b bar
+ * {
+ *   flags: { a: "foo", b: "bar" },
+ *   literal: [],
+ *   unknown: [],
+ *   stopEarly: false,
+ *   stopOnUnknown: false
+ * }
+ *
+ * $ deno run https://deno.land/x/cliffy/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
+ * }
+ * ```
+ *
+ * ### Define flags
+ *
+ * You can specify flags with the options object. For all unknown or invalid flags
+ * an `ValidationError` is thrown. Read more about error handling
+ * [here](./error_handling.md). A list of all available flag options can be found
+ * [here](./flag_options.md).
+ *
+ * @example Parse flags with validation
+ *
+ * ```typescript
+ * import { parseFlags } from "https://deno.land/x/cliffy/flags/mod.ts";
+ *
+ * const { flags } = parseFlags(Deno.args, {
+ *   flags: [{
+ *     name: "help",
+ *     aliases: ["h"],
+ *     standalone: true,
+ *   }, {
+ *     name: "verbose",
+ *     aliases: ["v"],
+ *     collect: true,
+ *     value: (val: boolean, previous = 0) => val ? previous + 1 : 0,
+ *   }, {
+ *     name: "file",
+ *     aliases: ["f"],
+ *     type: "string",
+ *   }],
+ * });
+ *
+ * console.log(flags);
+ * ```
+ *
+ * ```console
+ * $ deno run https://deno.land/x/cliffy/examples/flags/options.ts -vvv -f ./example.ts
+ * { verbose: 3, file: "./example.ts" }
+ * ```
+ *
+ * ### Parse context
+ *
+ * The `parseFlags` method accepts also a parse context as first argument. The
+ * context can either be a manually created object or the result of a previously
+ * called `parseFlags` method.
+ *
+ * This can be used to parse command line flags in multiple steps, for example,
+ * when parsing options that precede a subcommand.
+ *
+ * @example Pre-parsing global options
+ *
+ * ```ts
+ * import { parseFlags } from "https://deno.land/x/cliffy/flags/mod.ts";
+ *
+ * const globalFlags = [{
+ *   name: "foo-global",
+ *   alias: ["g"],
+ *   collect: true,
+ * }];
+ *
+ * const flags = [{
+ *   name: "foo",
+ *   alias: ["f"],
+ *   collect: true,
+ * }];
+ *
+ * const args = ["--foo-global", "cmd1", "--foo-global", "--foo", "arg1", "--foo"];
+ *
+ * // Parse main command args (all flags until the first unknown argument).
+ * const ctx = parseFlags(args, {
+ *   flags: globalFlags,
+ *   stopEarly: true, // Stop on first non option argument.
+ *   stopOnUnknown: true, // Stop on first option argument.
+ *   dotted: false, // Don't convert dotted option keys to nested objects.
+ * });
+ *
+ * // Shift sub-command from arguments.
+ * const subCommand = ctx.unknown.shift();
+ *
+ * // Parse all sub command args.
+ * parseFlags(ctx, {
+ *   flags: [
+ *     ...globalFlags,
+ *     ...flags,
+ *   ],
+ * });
+ *
+ * console.log("sub-command:", subCommand); // -> cmd1
+ * console.log("options:", ctx.flags); // -> { fooGlobal: [ true, true ], foo: [ true, true ] }
+ * console.log("arguments:", ctx.unknown); // -> [ "arg1" ]
+ * ```
+ *
+ * @param argsOrCtx Command line arguments e.g: `Deno.args` or parse context.
+ * @param opts      Parse options.
+ */
+export declare function parseFlags<TFlags extends Record<string, unknown>, TFlagOptions extends FlagOptions, TFlagsResult extends ParseFlagsContext>(argsOrCtx?: Array<string> | TFlagsResult, opts?: ParseFlagsOptions<TFlagOptions>): TFlagsResult & ParseFlagsContext<TFlags, TFlagOptions>;
+//# sourceMappingURL=flags.d.ts.map

package/types/deps/jsr.io/@cliffy/flags/1.1.0/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/flags.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAGV,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAcpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,YAAY,SAAS,WAAW,EAChC,YAAY,SAAS,iBAAiB,EAEtC,SAAS,GAAE,KAAK,CAAC,MAAM,CAAC,GAAG,YAAwB,EACnD,IAAI,GAAE,iBAAiB,CAAC,YAAY,CAAM,GACzC,YAAY,GAAG,iBAAiB,CAAC,MAAM,EAAE,YAAY,CAAC,CAmCxD"}

package/types/deps/jsr.io/@cliffy/flags/1.1.0/mod.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A commandline arguments parser for [Deno](https://deno.com),
+ * [Node](https://nodejs.org) and [Bun](https://bun.sh/).
+ *
+ * > [!NOTE]\
+ * > The full documentation can be found at
+ * > [cliffy.io](https://cliffy.io/docs/flags).
+ *
+ * ## Examples
+ *
+ * Some example CLIs.
+ *
+ * ### Basic usage
+ *
+ * Parse all arguments with automatic type detection.
+ *
+ * ```ts
+ * import { parseFlags } from "@cliffy/flags";
+ *
+ * console.log(parseFlags());
+ * ```
+ *
+ * ### Volume converter
+ *
+ * A CLI to convert volume from liters to gallons or vice versa.
+ *
+ * ```ts
+ * import { parseFlags } from "@cliffy/flags";
+ *
+ * const { flags: { unit }, unknown: [volume] } = parseFlags(Deno.args, {
+ *   flags: [{
+ *     name: "unit",
+ *     aliases: ["u"],
+ *     type: "string",
+ *     default: "l",
+ *   }],
+ * });
+ *
+ * if (unit === "l") {
+ *   const gallons = Number(volume) * 0.264172;
+ *   console.log(`${volume} L is ${gallons.toFixed(2)} gal.`);
+ * } else {
+ *   const liters = Number(volume) / 0.264172;
+ *   console.log(`${volume} gal is ${liters.toFixed(2)} L.`);
+ * }
+ * ```
+ *
+ * @module
+ */
+export { parseFlags } from "./flags.js";
+export { type ArgumentOptions, type ArgumentType, type ArgumentValue, type ArgumentValueHandler, 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 { InvalidTypeError, UnexpectedArgumentAfterVariadicArgumentError, UnexpectedRequiredArgumentError, UnknownTypeError, ValidationError, } from "./_errors.js";
+//# sourceMappingURL=mod.d.ts.map

package/types/deps/jsr.io/@cliffy/flags/1.1.0/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,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,gBAAgB,EAChB,4CAA4C,EAC5C,+BAA+B,EAC/B,gBAAgB,EAChB,eAAe,GAChB,MAAM,cAAc,CAAC"}

package/types/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types/integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types/number.d.ts.map

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

package/types/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/flags/1.1.0/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types.d.ts

@@ -0,0 +1,170 @@
+/** Parser options. */
+export interface ParseFlagsOptions<TFlagOptions extends FlagOptions = FlagOptions> {
+    /** An array of flag options. */
+    flags?: Array<TFlagOptions>;
+    args?: Array<ArgumentOptions>;
+    /** 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" | "value"> {
+    /** 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 of 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 {
+    /** An optional name for the argument. */
+    name?: string;
+    /** 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;
+    /**
+     * Separator for list type arguments. If the argument is defined as list type
+     * with `[]` suffix, the separator is used to split the input value into an
+     * array of values. The default separator is comma `,`.
+     */
+    separator?: string;
+    /**
+     * Default value or a callback method that returns the default value. The
+     * default value is used when the argument is optional and not provided in
+     * the command line input.
+     */
+    default?: DefaultValue;
+    /**
+     * Argument value callback method to transform the argument value after
+     * parsing and type conversion. The callback is invoked with the parsed
+     * argument value and should return the transformed value.
+     */
+    value?: ArgumentValueHandler<any, any>;
+}
+/** Available build-in argument types. */
+export type ArgumentType = "string" | "boolean" | "number" | "integer";
+export type ArgumentValueHandler<TValue = unknown, TReturn = TValue> = (value: TValue) => TReturn;
+/** 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 parsed arguments. */
+    args?: Array<unknown>;
+    /** 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>;
+    /**
+     * Raw flag tokens in the order they were encountered, preserving the exact
+     * form used on the command line.
+     *
+     * Space form — flag and value as separate tokens:
+     *     `command --port 80`  →  `['--port', '80']`
+     *
+     * Equals form — flag and value as one token:
+     *     `command --port=80`  →  `['--port=80']`
+     */
+    parsedFlags: ReadonlyArray<string>;
+}
+/** Argument parsing informations. */
+export interface ArgumentValue {
+    /** A label/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/types/deps/jsr.io/@cliffy/flags/1.1.0/types.d.ts.map

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

package/types/deps/jsr.io/@cliffy/internal/1.1.0/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/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/exit.d.ts.map

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

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_args.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get script arguments.
+ *
+ * @internal
+ */
+export declare function getArgs(): Array<string>;
+//# sourceMappingURL=get_args.d.ts.map

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_args.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_args.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,CAKvC"}

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_columns.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the width of the console window.
+ *
+ * @internal
+ */
+export declare function getColumns(): number | null;
+//# sourceMappingURL=get_columns.d.ts.map

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_columns.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_columns.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAkB1C"}

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get environment variable.
+ *
+ * @internal
+ * @param name The name of the environment variable.
+ */
+export declare function getEnv(name: string): string | undefined;
+//# sourceMappingURL=get_env.d.ts.map

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/get_env.d.ts.map

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

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/inspect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Inspect values.
+ *
+ * @internal
+ */
+export declare function inspect(value: unknown, colors: boolean): string;
+//# sourceMappingURL=inspect.d.ts.map

package/types/deps/jsr.io/@cliffy/internal/1.1.0/runtime/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@cliffy/internal/1.1.0/runtime/inspect.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAQ/D"}