politty 0.7.0 → 0.9.0

package/dist/index-WyViqW59.d.cts

@@ -1,663 +0,0 @@
-import { J as ResolvedFieldMeta, _ as AnyCommand, d as ResolvedExpandCandidate, h as DynamicCompletionResolver, u as ExpandCompletion, v as ArgsSchema, x as Command } from "./arg-registry-DDJpsUea.cjs";
-import { z } from "zod";
-
-//#region src/completion/types.d.ts
-/**
- * A single resolved entry in an "expand" lookup table.
- *
- * `key` is the tuple of `dependsOn` values that triggers this entry, in the
- * same order as the originating `dependsOn` array. `candidates` is the
- * (already deduplicated) list returned by the user's `enumerate` callback
- * for that combination.
- */
-interface ExpandTableEntry {
-  readonly key: readonly string[];
-  readonly candidates: readonly ResolvedExpandCandidate[];
-}
-/**
- * Supported shell types for completion
- */
-type ShellType = "bash" | "zsh" | "fish";
-/**
- * Completion script generation mode.
- *
- * - `dispatcher`: small runtime script that resolves the executable visible on
- *   PATH at TAB time and delegates to its `__complete` command.
- * - `static`: self-contained script with command metadata baked in at
- *   generation time.
- */
-type CompletionMode = "dispatcher" | "static";
-/**
- * Optional published worker artifact lookup.
- *
- * Paths are resolved relative to the visible executable's real directory.
- * Templates may include `{shell}`, `{ext}`, and `{program}`.
- */
-interface BundledWorkerOptions {
-  /** Disable bundled-worker lookup while keeping cache/dynamic fallbacks. */
-  disabled?: boolean | undefined;
-  /** Shell-specific worker paths relative to the executable directory. */
-  relativePaths?: Partial<Record<ShellType, readonly string[]>> | undefined;
-  /**
-   * Let dispatcher scripts ask the CLI for `__completion-worker-path <shell>`
-   * when package-relative lookup misses. Disabled by default because it starts
-   * the CLI process on that miss path.
-   */
-  queryCommand?: boolean | undefined;
-}
-/**
- * Options for completion generation
- */
-interface CompletionOptions {
-  /** The shell type to generate completion for */
-  shell: ShellType;
-  /** The command name as it will be invoked */
-  programName: string;
-  /** Include subcommand completions (default: true) */
-  includeSubcommands?: boolean;
-  /** Include description in completions where supported (default: true) */
-  includeDescriptions?: boolean;
-  /**
-   * Completion script mode.
-   *
-   * `generateCompletion` defaults to `static` when this is omitted. The
-   * `completion <shell>` subcommand passes `dispatcher` explicitly by default.
-   */
-  mode?: CompletionMode;
-  /** Global args schema for deriving global options in completion */
-  globalArgsSchema?: ArgsSchema;
-  /**
-   * Path to the binary whose mtime is the freshness signature.
-   * Defaults to `process.argv[1]`.
-   */
-  binPath?: string;
-  /** Program version to embed in the script header. */
-  programVersion?: string;
-  /**
-   * Cache directory for the loader to write the regenerated script into.
-   * Defaults to `${XDG_CACHE_HOME:-$HOME/.cache}/<programName>` at runtime.
-   * Setting this hardcodes the location into the generated loader.
-   */
-  cacheDir?: string;
-  /**
-   * Internal static-worker generation hook used by dispatcher caches.
-   * Worker scripts define suffixed functions and skip shell registration.
-   */
-  staticWorker?: {
-    functionSuffix: string;
-  };
-  /** Published static-worker artifact lookup used by dispatcher mode. */
-  bundledWorker?: BundledWorkerOptions | undefined;
-}
-/**
- * Value completion specification for shell scripts.
- *
- * Discriminated by `type`. The `dynamic` variant carries a JS resolver that
- * the static shell scripts delegate to via `<program> __complete`. All
- * variants share the same optional metadata fields (left undefined where
- * inapplicable) so consumers can read `vc.choices`/`vc.extensions`/etc.
- * without narrowing first.
- */
-type ValueCompletion = ({
-  /** Completion type */type: "choices" | "file" | "directory" | "command" | "none"; /** List of valid choices (for "choices" type) */
-  choices?: string[]; /** Shell command for dynamic completion (for "command" type) */
-  shellCommand?: string;
-  resolve?: never;
-  dependsOn?: never;
-  table?: never;
-} & ({
-  extensions?: string[];
-  matcher?: never;
-} | {
-  /** Glob patterns for file matching (for "file" type) */matcher?: string[];
-  extensions?: never;
-})) | {
-  /** In-process dynamic completion via JS callback. */type: "dynamic";
-  resolve: DynamicCompletionResolver;
-  choices?: never;
-  shellCommand?: never;
-  extensions?: never;
-  matcher?: never;
-  dependsOn?: never;
-  table?: never;
-} | {
-  /**
-   * Pre-enumerated completion baked into the generated shell script.
-   * The `table` is the cartesian product of the `dependsOn` arg values
-   * (each having a static `choices` or enum schema). At completion time
-   * the shell dispatches on the runtime values of those args — no Node
-   * is spawned.
-   */
-  type: "expand";
-  dependsOn: readonly string[];
-  table: readonly ExpandTableEntry[];
-  choices?: never;
-  shellCommand?: never;
-  resolve?: never;
-  extensions?: never;
-  matcher?: never;
-} | {
-  /**
-   * Runtime form of `completion.custom.expand` used by `__complete`.
-   * The dispatcher invokes `__complete` at TAB time, so it can call the
-   * user's `enumerate` function against the already typed dependency
-   * values instead of baking a table into the shell script.
-   */
-  type: "runtime-expand";
-  dependsOn: readonly string[];
-  enumerate: (deps: Readonly<Record<string, string>>) => ReadonlyArray<string | {
-    value: string;
-    description?: string;
-  }>;
-  choices?: never;
-  shellCommand?: never;
-  resolve?: never;
-  extensions?: never;
-  matcher?: never;
-  table?: never;
-};
-/**
- * Information about a completable option
- */
-interface CompletableOption {
-  /** Long option name (e.g., "verbose") */
-  name: string;
-  /** CLI name (kebab-case, e.g., "dry-run") */
-  cliName: string;
-  /**
-   * Aliases for this option (both short and long).
-   * 1-char entries are short (`-v`); multi-char entries are long (`--to-be`).
-   */
-  alias?: string[] | undefined;
-  /**
-   * Negation name to advertise in shell completions (no `--` prefix),
-   * or `undefined` to hide the negation. Mirrors `ResolvedFieldMeta.negationDisplay`.
-   */
-  negation?: string | undefined;
-  /** Description for the negation option (when distinct from the main description) */
-  negationDescription?: string | undefined;
-  /**
-   * Whether the runtime parser accepts the implicit `--no-<cliName>` (and
-   * camelCase) form for this boolean option. False when the user set
-   * `negation: false` (suppressed) or `negation: <custom name>` (only the
-   * custom name is accepted). Used by the completion context parser so
-   * dynamic resolvers see the same `parsedArgs` state the runtime would
-   * compute.
-   */
-  defaultNegationAccepted?: boolean;
-  /** Description for completion */
-  description?: string | undefined;
-  /**
-   * True when this option originates from a `globalArgsSchema` and was
-   * propagated into every subcommand frame. The runtime parser keeps
-   * global values visible across subcommand descent, so shell generators
-   * must keep their tracker buckets separate from per-frame state.
-   */
-  isGlobal?: boolean;
-  /** Whether this option takes a value */
-  takesValue: boolean;
-  /** Type of value expected */
-  valueType: "string" | "number" | "boolean" | "array" | "unknown";
-  /** Whether the option is required */
-  required: boolean;
-  /** Value completion specification */
-  valueCompletion?: ValueCompletion | undefined;
-}
-/**
- * Information about a positional argument for completion
- */
-interface CompletablePositional {
-  /** Field name */
-  name: string;
-  /** CLI name (kebab-case) */
-  cliName: string;
-  /** Position index (0-based) */
-  position: number;
-  /** Description */
-  description?: string | undefined;
-  /** Whether required */
-  required: boolean;
-  /** Whether this positional accepts multiple values (array type) */
-  variadic?: boolean | undefined;
-  /** Value completion specification */
-  valueCompletion?: ValueCompletion | undefined;
-}
-/**
- * Information about a subcommand for completion
- */
-interface CompletableSubcommand {
-  /** Subcommand name */
-  name: string;
-  /** Subcommand description */
-  description?: string | undefined;
-  /** Alternative names (aliases) for this subcommand */
-  aliases?: string[] | undefined;
-  /** Nested subcommands */
-  subcommands: CompletableSubcommand[];
-  /** Options for this subcommand */
-  options: CompletableOption[];
-  /** Positional arguments */
-  positionals: CompletablePositional[];
-}
-/**
- * Extracted completion data from a command
- */
-interface CompletionData {
-  /** The root command */
-  command: CompletableSubcommand;
-  /** Program name */
-  programName: string;
-  /** Global options (available to all subcommands) */
-  globalOptions: CompletableOption[];
-}
-/**
- * Result of completion generation
- */
-interface CompletionResult {
-  /** The generated completion script */
-  script: string;
-  /** The shell type this script is for */
-  shell: ShellType;
-  /** Instructions for installing the completion */
-  installInstructions: string;
-}
-/**
- * Generator function type for shell completions
- */
-type CompletionGenerator = (command: AnyCommand, options: CompletionOptions) => CompletionResult;
-//#endregion
-//#region src/completion/dynamic/context-parser.d.ts
-/**
- * Completion type indicates what kind of completion is expected
- */
-type CompletionType = "subcommand" | "option-name" | "option-value" | "positional";
-/**
- * Context for completion at current cursor position
- */
-interface CompletionContext {
-  /** Subcommand path from root (e.g., ["plugin", "add"]) */
-  subcommandPath: string[];
-  /** The resolved command at current path */
-  currentCommand: AnyCommand;
-  /** Current word being typed (may be partial) */
-  currentWord: string;
-  /** Previous word (useful for option value detection) */
-  previousWord: string;
-  /** What type of completion is expected */
-  completionType: CompletionType;
-  /** Target option when completing option value */
-  targetOption?: CompletableOption | undefined;
-  /** Positional index when completing positional argument */
-  positionalIndex?: number | undefined;
-  /** Available options for current command */
-  options: CompletableOption[];
-  /** Available subcommands */
-  subcommands: string[];
-  /** Available positionals */
-  positionals: CompletablePositional[];
-  /** Options already used (to avoid duplicates) */
-  usedOptions: Set<string>;
-  /** Number of positional arguments already provided */
-  providedPositionalCount: number;
-  /**
-   * Best-effort parsed values for the CURRENT command, keyed by camelCase
-   * field name. Includes positionals (single value or string[] for variadic
-   * positionals) and options (string for scalars, string[] for array
-   * options). Zod validation is NOT applied — values are raw strings.
-   */
-  parsedArgs: Record<string, unknown>;
-  /**
-   * Values already supplied for the option/positional currently being
-   * completed (for de-duplicating array options and oneof exclusivity in
-   * dynamic resolvers).
-   */
-  previousValues: string[];
-}
-/**
- * Parse completion context from command line arguments
- *
- * @param argv - Arguments after the program name (e.g., ["build", "--fo"])
- * @param rootCommand - The root command
- * @param globalArgsSchema - Optional global args. When provided, options
- *   derived from this schema are merged into every command level so dynamic
- *   resolvers attached to global options can be reached from any subcommand.
- * @returns Completion context
- */
-declare function parseCompletionContext(argv: string[], rootCommand: AnyCommand, globalArgsSchema?: ArgsSchema): CompletionContext;
-//#endregion
-//#region src/completion/dynamic/candidate-generator.d.ts
-/**
- * Completion directive flags (bitwise)
- */
-declare const CompletionDirective: {
-  /** Default completion behavior */readonly Default: 0; /** Don't add space after completion */
-  readonly NoSpace: 1; /** Don't offer file completion (even if no other completions) */
-  readonly NoFileCompletion: 2; /** Filter completions using current word as prefix */
-  readonly FilterPrefix: 4; /** Keep the order of completions */
-  readonly KeepOrder: 8; /** Trigger file completion */
-  readonly FileCompletion: 16; /** Trigger directory completion */
-  readonly DirectoryCompletion: 32; /** Error occurred during completion */
-  readonly Error: 64;
-};
-/**
- * A completion candidate
- */
-interface CompletionCandidate {
-  /** The completion value */
-  value: string;
-  /** Optional description */
-  description?: string | undefined;
-  /** Type hint for display purposes */
-  type?: "option" | "subcommand" | "value" | "file" | "directory";
-}
-/**
- * Result of candidate generation
- */
-interface CandidateResult {
-  /** Completion candidates */
-  candidates: CompletionCandidate[];
-  /** Directive flags for shell behavior */
-  directive: number;
-  /** File extensions for shell-native filtering (e.g., ["json", "yaml"]) */
-  fileExtensions?: string[] | undefined;
-  /** Glob patterns for shell-native file matching (e.g., [".env.*"]) */
-  fileMatchers?: string[] | undefined;
-}
-/**
- * Options for candidate generation.
- */
-interface GenerateCandidatesOptions {
-  /**
-   * Target shell. Forwarded to dynamic resolvers so they can vary output
-   * (e.g. include descriptions only for shells that render them).
-   */
-  shell: ShellType;
-}
-/**
- * Generate completion candidates based on context.
- *
- * Async because dynamic resolvers may return promises. Sync completion
- * sources (choices/file/directory/command/none, subcommand, option name)
- * still resolve synchronously and the await is a no-op for them.
- *
- * Inline option-value prefixes (`--field=foo`) on the option-value path
- * are stripped here so resolvers and post-processing always see the
- * value portion regardless of whether the caller pre-normalized.
- */
-declare function generateCandidates(context: CompletionContext, options: GenerateCandidatesOptions): Promise<CandidateResult>;
-//#endregion
-//#region src/completion/dynamic/complete-command.d.ts
-/**
- * Schema for the __complete command
- */
-declare const completeArgsSchema: z.ZodObject<{
-  shell: z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>;
-  args: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type CompleteArgs = z.infer<typeof completeArgsSchema>;
-/**
- * Create the dynamic completion command
- *
- * @param rootCommand - The root command to generate completions for
- * @param programName - The program name (optional, defaults to rootCommand.name)
- * @param globalArgsSchema - Global args schema. Forwarded to
- *   `parseCompletionContext` so resolvers attached to global options remain
- *   reachable at every subcommand level.
- * @returns A command that outputs completion candidates
- */
-declare function createDynamicCompleteCommand(rootCommand: AnyCommand, _programName?: string, globalArgsSchema?: ArgsSchema): Command<typeof completeArgsSchema, CompleteArgs, any>;
-/**
- * Check if a command tree contains the __complete command
- */
-declare function hasCompleteCommand(command: AnyCommand): boolean;
-//#endregion
-//#region src/completion/dynamic/shell-formatter.d.ts
-/**
- * Options for shell-specific formatting
- */
-interface ShellFormatOptions {
-  /** Target shell type */
-  shell: ShellType;
-  /** Current word being completed (used for prefix filtering) */
-  currentWord: string;
-  /** For bash: the prefix before '=' in --opt=value completions */
-  inlinePrefix?: string | undefined;
-}
-/**
- * Format completion candidates for the specified shell
- *
- * @returns Shell-ready output string (lines separated by newline, last line is :directive)
- */
-declare function formatForShell(result: CandidateResult, options: ShellFormatOptions): string;
-//#endregion
-//#region src/completion/extractor.d.ts
-/**
- * Extract positional arguments from a command
- */
-declare function extractPositionals(command: AnyCommand): ResolvedFieldMeta[];
-/**
- * Extract completion data from a command tree
- *
- * @param command - The root command
- * @param programName - Program name for completion scripts
- * @param globalArgsSchema - Optional global args schema. When provided, global options
- *   are derived from this schema instead of the root command's options.
- */
-declare function extractCompletionData(command: AnyCommand, programName: string, globalArgsSchema?: ArgsSchema, validateOnly?: boolean): CompletionData;
-//#endregion
-//#region src/completion/bundled-worker.d.ts
-interface GenerateBundledCompletionWorkerOptions {
-  /** CLI binary or built JS entry file to invoke. */
-  bin: string;
-  /** Program name embedded in completion metadata. */
-  programName: string;
-  /** Shell worker to generate. */
-  shell: ShellType;
-  /** Output path. Defaults to `dist/completion/<shell>-worker.<ext>`. */
-  outputPath?: string | undefined;
-  /** Verify that `__completion-worker-path <shell>` resolves to the generated file. */
-  verify?: boolean | undefined;
-  /** Working directory used for relative paths. Defaults to `process.cwd()`. */
-  cwd?: string | undefined;
-  /** Extra environment passed to the target binary. */
-  env?: Readonly<Record<string, string | undefined>> | undefined;
-  /** Suppress the success message. */
-  quiet?: boolean | undefined;
-}
-interface GenerateBundledCompletionWorkerResult {
-  /** Absolute generated worker path. */
-  outputPath: string;
-  /** Generated file size in bytes. */
-  size: number;
-  /** Absolute path reported by `__completion-worker-path`, when verified. */
-  reportedPath?: string | undefined;
-}
-declare function bundledWorkerShellExtension(shell: ShellType): string;
-declare function defaultBundledWorkerOutputPath(shell: ShellType): string;
-declare function validateBundledWorkerFile(path: string, programName: string, shell: ShellType): void;
-declare function generateBundledCompletionWorker(options: GenerateBundledCompletionWorkerOptions): Promise<GenerateBundledCompletionWorkerResult>;
-//#endregion
-//#region src/completion/value-completion-resolver.d.ts
-/**
- * Sentinel returned when a field uses `completion.custom.expand`. The static
- * extractor recognises this and replaces it with a fully resolved
- * `{ type: "expand", ... }` ValueCompletion after sibling args' static
- * values are known. Internal: never assigned onto `CompletableOption` /
- * `CompletablePositional` directly; callers stash it in a side map keyed by
- * field name and patch the resolved spec in afterwards.
- */
-interface PendingExpandValueCompletion {
-  type: "pending-expand";
-  spec: ExpandCompletion;
-}
-/**
- * Minimal field interface needed for resolving value completion.
- * Both ResolvedFieldMeta and inline context-parser types satisfy this.
- */
-interface ValueCompletionField {
-  completion?: ({
-    type?: string;
-    custom?: {
-      choices?: string[];
-      shellCommand?: string;
-      resolve?: DynamicCompletionResolver;
-      expand?: ExpandCompletion;
-    };
-  } & ({
-    extensions?: string[];
-    matcher?: never;
-  } | {
-    matcher?: string[];
-    extensions?: never;
-  })) | undefined;
-  enumValues?: string[] | undefined;
-  /** Field name surfaced in error messages when custom variants are mixed. */
-  name?: string;
-}
-/**
- * Resolve value completion from field metadata.
- *
- * Priority (within `custom`): `expand` > `resolve` > `choices` > `shellCommand`.
- * Specifying more than one of these on the same field throws so the
- * misconfiguration surfaces at command-definition time rather than at
- * completion time. The `expand` variant returns a sentinel — the extractor
- * resolves it against sibling fields and replaces the sentinel with a
- * `{ type: "expand", table, dependsOn }` entry.
- *
- * Outside `custom`: explicit `type` (file/directory/none) > auto-detected
- * enum values from the schema.
- */
-declare function resolveValueCompletion(field: ValueCompletionField): ValueCompletion | PendingExpandValueCompletion | undefined;
-//#endregion
-//#region src/completion/index.d.ts
-/**
- * Generate completion script for the specified shell
- */
-declare function generateCompletion(command: AnyCommand, options: CompletionOptions): CompletionResult;
-/**
- * Get the list of supported shells
- */
-declare function getSupportedShells(): ShellType[];
-/**
- * Detect the current shell from environment
- */
-declare function detectShell(): ShellType | null;
-/**
- * Schema for the completion command arguments
- */
-declare const completionArgsSchema: z.ZodObject<{
-  shell: z.ZodOptional<z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>>;
-  instructions: z.ZodDefault<z.ZodBoolean>;
-  loader: z.ZodDefault<z.ZodBoolean>;
-  install: z.ZodDefault<z.ZodBoolean>;
-  static: z.ZodDefault<z.ZodBoolean>;
-  dispatcher: z.ZodDefault<z.ZodBoolean>;
-  worker: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type CompletionArgs = z.infer<typeof completionArgsSchema>;
-declare const refreshArgsSchema: z.ZodObject<{
-  shell: z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>;
-  target: z.ZodOptional<z.ZodString>;
-  static: z.ZodDefault<z.ZodBoolean>;
-  worker: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type RefreshArgs = z.infer<typeof refreshArgsSchema>;
-declare const workerPathArgsSchema: z.ZodObject<{
-  shell: z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>;
-}, z.core.$strip>;
-type WorkerPathArgs = z.infer<typeof workerPathArgsSchema>;
-/**
- * Create a completion subcommand for your CLI
- *
- * This creates a ready-to-use subcommand that generates completion scripts.
- *
- * @example
- * ```typescript
- * const mainCommand = defineCommand({
- *   name: "mycli",
- *   subCommands: {
- *     completion: createCompletionCommand(mainCommand)
- *   }
- * });
- * ```
- */
-declare function createCompletionCommand(rootCommand: AnyCommand, programName?: string, globalArgsSchema?: ArgsSchema, extra?: {
-  cacheDir?: string;
-  programVersion?: string;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof completionArgsSchema, CompletionArgs, any>;
-/**
- * Hidden subcommand that the runMain background hook spawns. It does
- * the same stat-compare + atomic rewrite as the rc loader, but in a
- * detached child process so it's invisible to the user.
- */
-declare function createRefreshCompletionCommand(rootCommand: AnyCommand, programName: string, extra?: {
-  cacheDir?: string;
-  programVersion?: string;
-  globalArgsSchema?: ArgsSchema;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof refreshArgsSchema, RefreshArgs, any>;
-declare function createCompletionWorkerPathCommand(programName: string, extra?: {
-  binPath?: string;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof workerPathArgsSchema, WorkerPathArgs, any>;
-/**
- * Options for withCompletionCommand
- */
-interface WithCompletionOptions {
-  /** Override the program name (defaults to command.name) */
-  programName?: string;
-  /** Global args schema for deriving global options in completion */
-  globalArgsSchema?: ArgsSchema;
-  /**
-   * Hardcode the cache directory used by the rc loader and the
-   * background refresh. When omitted, the loader derives
-   * `${XDG_CACHE_HOME:-$HOME/.cache}/<programName>` at runtime, which
-   * is the right answer for almost every CLI.
-   */
-  cacheDir?: string;
-  /** Program version embedded in the script header. */
-  programVersion?: string;
-  /** Published worker artifact lookup used by dispatcher mode. */
-  bundledWorker?: BundledWorkerOptions;
-}
-/**
- * Wrap a command with a completion subcommand
- *
- * This avoids circular references that occur when a command references itself
- * in its subCommands (e.g., for completion generation).
- *
- * @param command - The command to wrap
- * @param options - Options including programName
- * @returns A new command with the completion subcommand added
- *
- * @example
- * ```typescript
- * const mainCommand = withCompletionCommand(
- *   defineCommand({
- *     name: "mycli",
- *     subCommands: { ... },
- *   }),
- * );
- * ```
- */
-declare function withCompletionCommand<T extends AnyCommand>(command: T, options?: string | WithCompletionOptions): T;
-//#endregion
-export { BundledWorkerOptions as A, CandidateResult as C, CompletionContext as D, generateCandidates as E, CompletionMode as F, CompletionOptions as I, CompletionResult as L, CompletableSubcommand as M, CompletionData as N, CompletionType as O, CompletionGenerator as P, ShellType as R, hasCompleteCommand as S, CompletionDirective as T, extractCompletionData as _, detectShell as a, formatForShell as b, withCompletionCommand as c, GenerateBundledCompletionWorkerOptions as d, GenerateBundledCompletionWorkerResult as f, validateBundledWorkerFile as g, generateBundledCompletionWorker as h, createRefreshCompletionCommand as i, CompletableOption as j, parseCompletionContext as k, ValueCompletionField as l, defaultBundledWorkerOutputPath as m, createCompletionCommand as n, generateCompletion as o, bundledWorkerShellExtension as p, createCompletionWorkerPathCommand as r, getSupportedShells as s, WithCompletionOptions as t, resolveValueCompletion as u, extractPositionals as v, CompletionCandidate as w, createDynamicCompleteCommand as x, ShellFormatOptions as y };
-//# sourceMappingURL=index-WyViqW59.d.cts.map

package/dist/index-WyViqW59.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-WyViqW59.d.cts","names":[],"sources":["../src/completion/types.ts","../src/completion/dynamic/context-parser.ts","../src/completion/dynamic/candidate-generator.ts","../src/completion/dynamic/complete-command.ts","../src/completion/dynamic/shell-formatter.ts","../src/completion/extractor.ts","../src/completion/bundled-worker.ts","../src/completion/value-completion-resolver.ts","../src/completion/index.ts"],"mappings":"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"}