SYMBOL INDEX (172 symbols across 45 files)

FILE: example/app.ts
  method from (line 144) | async from(s) {
  function main (line 221) | async function main() {

FILE: example/app2.ts
  method from (line 15) | async from(branchName) {

FILE: example/app3.ts
  method handler (line 35) | handler({ name, age }) {

FILE: example/app4.ts
  method from (line 6) | async from(str) {

FILE: example/app5.ts
  method from (line 6) | async from(str) {

FILE: example/app7.ts
  method from (line 8) | async from(strings) {

FILE: example/negative-numbers.ts
  function createCmd (line 3) | function createCmd() {

FILE: example/rest-example.ts
  method handler (line 9) | handler({ scriptName, everythingElse }) {

FILE: example/test-types.ts
  method from (line 10) | async from(n) {
  function stdin (line 18) | function stdin() {
  method from (line 25) | async from(str) {
  function readStreamToString (line 58) | function readStreamToString(s: Stream): Promise<string> {
  method from (line 71) | async from(s) {

FILE: src/Result.ts
  type Ok (line 4) | type Ok<R> = { _tag: "ok"; value: R };
  type Err (line 9) | type Err<L> = { _tag: "error"; error: L };
  type Result (line 18) | type Result<L, R> = Err<L> | Ok<R>;
  function ok (line 20) | function ok<O>(value: O): Ok<O> {
  function err (line 24) | function err<E>(error: E): Err<E> {
  function isOk (line 32) | function isOk<R>(result: Result<any, R>): result is Ok<R> {
  function isErr (line 40) | function isErr<L>(either: Result<L, any>): either is Err<L> {
  function safeAsync (line 48) | async function safeAsync<O>(

FILE: src/argparser.ts
  type Nodes (line 4) | type Nodes = AstNode[];
  type ParsingError (line 6) | type ParsingError = {
  type FailedParse (line 13) | type FailedParse = {
  type ParseContext (line 19) | type ParseContext = {
  type ParsingResult (line 31) | type ParsingResult<Into> = Result<FailedParse, Into>;
  type RegisterOptions (line 46) | type RegisterOptions = {
  type Register (line 53) | type Register = {
  type ArgParser (line 61) | type ArgParser<Into> = Partial<Register> & {
  type ParsingInto (line 70) | type ParsingInto<AP extends ArgParser<any>> = AP extends ArgParser<

FILE: src/batteries/fs.ts
  method from (line 12) | async from(str) {
  method from (line 28) | async from(resolved) {
  method from (line 45) | async from(resolved) {

FILE: src/batteries/url.ts
  method from (line 10) | async from(str): Promise<URL> {
  method from (line 28) | async from(url): Promise<URL> {

FILE: src/batteries/vercel-formatter.ts
  type VercelFormatterConfig (line 12) | type VercelFormatterConfig = {
  function getArgHint (line 27) | function getArgHint(helpTopics: { category: string; usage: string }[]): ...
  function formatCommandName (line 38) | function formatCommandName(name: string, aliases?: string[]): string {
  function createVercelFormatter (line 68) | function createVercelFormatter(
  function capitalize (line 208) | function capitalize(str: string): string {

FILE: src/binary.ts
  function binary (line 10) | function binary<Command extends Runner<any, any> & Named>(

FILE: src/chalk.ts
  function setMode (line 5) | function setMode(newMode: typeof mode) {
  type ColorizerFunction (line 9) | type ColorizerFunction = (...strings: string[]) => string;
  type AllColorOptions (line 11) | type AllColorOptions = Extract<
  type Colored (line 16) | type Colored = {
  type ColoredFunction (line 19) | type ColoredFunction = ColorizerFunction & Colored;
  type Strategy (line 21) | type Strategy = (
  function withLevels (line 26) | function withLevels(
  function generateColoredBody (line 59) | function generateColoredBody<T>(
  function colored (line 98) | function colored(): Colored {

FILE: src/circuitbreaker.ts
  type CircuitBreaker (line 8) | type CircuitBreaker = "help" | "version";
  function handleCircuitBreaker (line 24) | function handleCircuitBreaker(
  function createCircuitBreaker (line 51) | function createCircuitBreaker(

FILE: src/command.ts
  type ArgTypes (line 27) | type ArgTypes = Record<string, ArgParser<any> & Partial<ProvidesHelp>>;
  type HandlerFunc (line 28) | type HandlerFunc<Args extends ArgTypes> = (args: Output<Args>) => any;
  type CommandConfig (line 30) | type CommandConfig<
  type Output (line 44) | type Output<Args extends ArgTypes> = {
  function command (line 54) | function command<

FILE: src/default.ts
  type Default (line 1) | type Default<T> = {
  type OnMissing (line 11) | type OnMissing<T> = {

FILE: src/effects.ts
  class Exit (line 27) | class Exit {
    method constructor (line 28) | constructor(
    method run (line 36) | run(): never {
    method dryRun (line 42) | dryRun(): string {
    method output (line 50) | private output() {

FILE: src/errorBox.ts
  type HighlightResult (line 7) | type HighlightResult = { colorized: string; errorIndex: number };
  function highlight (line 16) | function highlight(
  function errorBox (line 64) | function errorBox(

FILE: src/flag.ts
  type FlagConfig (line 22) | type FlagConfig<Decoder extends Type<boolean, any>> = LongDoc &
  method from (line 32) | async from(str) {
  function fullFlag (line 43) | function fullFlag<Decoder extends Type<boolean, any>>(
  type BooleanType (line 194) | type BooleanType = Type<boolean, boolean>;
  function flag (line 225) | function flag(

FILE: src/from.ts
  type FromFn (line 1) | type FromFn<A, B> = (input: A) => Promise<B>;
  type From (line 4) | type From<A, B> = {
  type OutputOf (line 12) | type OutputOf<F extends From<any, any> | FromFn<any, any>> =
  type InputOf (line 20) | type InputOf<F extends From<any, any> | FromFn<any, any>> =
  function identity (line 30) | function identity<T>(): From<T, T> {

FILE: src/helpFormatter.ts
  type Example (line 9) | type Example = {
  type CommandHelpData (line 19) | type CommandHelpData = {
  type SubcommandsHelpData (line 39) | type SubcommandsHelpData = {
  type HelpFormatter (line 64) | interface HelpFormatter {
  function setDefaultHelpFormatter (line 91) | function setDefaultHelpFormatter(formatter: HelpFormatter): void {
  function resetHelpFormatter (line 99) | function resetHelpFormatter(): void {
  function getHelpFormatter (line 107) | function getHelpFormatter(): HelpFormatter {
  method formatCommand (line 115) | formatCommand(data: CommandHelpData, _context: ParseContext): string {
  method formatSubcommands (line 164) | formatSubcommands(data: SubcommandsHelpData, _context: ParseContext): st...

FILE: src/helpdoc.ts
  type Descriptive (line 3) | type Descriptive = {
  type Versioned (line 8) | type Versioned = {
  type Named (line 13) | type Named = {
  type Displayed (line 18) | type Displayed = {
  type HelpTopic (line 23) | type HelpTopic = {
  type ProvidesHelp (line 45) | type ProvidesHelp = {
  type PrintHelp (line 49) | type PrintHelp = {
  type Aliased (line 56) | type Aliased = {
  type ShortDoc (line 61) | type ShortDoc = {
  type LongDoc (line 69) | type LongDoc = {
  type EnvDoc (line 77) | type EnvDoc = {

FILE: src/multiflag.ts
  type MultiFlagConfig (line 14) | type MultiFlagConfig<Decoder extends From<boolean[], any>> = HasType<Dec...
  function multiflag (line 22) | function multiflag<Decoder extends From<boolean[], any>>(

FILE: src/multioption.ts
  type MultiOptionConfig (line 17) | type MultiOptionConfig<Decoder extends Type<string[], any>> = HasType<De...
  function multioption (line 30) | function multioption<Decoder extends Type<string[], any>>(

FILE: src/newparser/findOption.ts
  type Option (line 3) | type Option = LongOption | ShortOption;
  function findOption (line 11) | function findOption(

FILE: src/newparser/parser.ts
  type AstNode (line 7) | type AstNode =
  type BaseAstNode (line 15) | type BaseAstNode<Type extends string> = {
  type LongOption (line 21) | interface LongOption extends BaseAstNode<"longOption"> {
  type Delimiter (line 26) | interface Delimiter extends BaseAstNode<"delimiter"> {}
  type Value (line 28) | interface Value extends BaseAstNode<"value"> {}
  type OptionValue (line 30) | interface OptionValue extends BaseAstNode<"optionValue"> {
  type ShortOptions (line 35) | interface ShortOptions extends BaseAstNode<"shortOptions"> {
  type ShortOption (line 39) | interface ShortOption extends BaseAstNode<"shortOption"> {
  type PositionalArgument (line 44) | interface PositionalArgument extends BaseAstNode<"positionalArgument"> {}
  type ForcePositional (line 46) | interface ForcePositional extends BaseAstNode<"forcePositional"> {
  function parse (line 56) | function parse(tokens: Token[], forceFlag: RegisterOptions): AstNode[] {
  function parseOptionValue (line 249) | function parseOptionValue(opts: {

FILE: src/newparser/tokenizer.ts
  type Token (line 3) | type Token =
  function tokenize (line 26) | function tokenize(strings: string[]): Token[] {

FILE: src/oneOf.ts
  function oneOf (line 7) | function oneOf<T extends string>(

FILE: src/option.ts
  type OptionConfig (line 23) | type OptionConfig<Decoder extends Type<string, any>> = LongDoc &
  function fullOption (line 28) | function fullOption<Decoder extends Type<string, any>>(
  type StringType (line 180) | type StringType = Type<string, string>;
  function option (line 208) | function option(

FILE: src/positional.ts
  type PositionalConfig (line 12) | type PositionalConfig<Decoder extends Type<string, any>> = HasType<Decod...
  type PositionalParser (line 16) | type PositionalParser<Decoder extends Type<string, any>> = ArgParser<
  function fullPositional (line 22) | function fullPositional<Decoder extends Type<string, any>>(
  type StringType (line 107) | type StringType = Type<string, string>;
  function positional (line 123) | function positional(

FILE: src/rest.ts
  function rest (line 6) | function rest(
  function getOriginal (line 66) | function getOriginal(node: {

FILE: src/restPositionals.ts
  type RestPositionalsConfig (line 14) | type RestPositionalsConfig<Decoder extends Type<string, any>> =
  function fullRestPositionals (line 22) | function fullRestPositionals<Decoder extends Type<string, any>>(
  type StringType (line 77) | type StringType = Type<string, string>;
  type RestPositionalsParser (line 79) | type RestPositionalsParser<Decoder extends Type<string, any>> = ArgParser<
  function restPositionals (line 97) | function restPositionals(

FILE: src/runner.ts
  type Handling (line 14) | type Handling<Values, Result> = { handler: (values: Values) => Result };
  type Runner (line 16) | type Runner<HandlerArgs, HandlerResult> = PrintHelp &
  type Into (line 24) | type Into<R extends Runner<any, any>> = R extends Runner<any, infer X>
  function run (line 28) | async function run<R extends Runner<any, any>>(
  function runSafely (line 42) | async function runSafely<R extends Runner<any, any>>(
  function dryRun (line 71) | async function dryRun<R extends Runner<any, any>>(
  function parse (line 85) | function parse<R extends Runner<any, any>>(
  function parseCommon (line 94) | function parseCommon<R extends Runner<any, any>>(

FILE: src/subcommands.ts
  type Output (line 28) | type Output<
  type RunnerOutput (line 34) | type RunnerOutput<
  function subcommands (line 46) | function subcommands<
  function flatMap (line 211) | function flatMap<T, R>(array: T[], f: (t: T) => R[]): R[] {

FILE: src/type.ts
  type Type (line 7) | type Type<From_, To> = From<From_, To> &
  function typeDef (line 13) | function typeDef<T extends From<any, any> | FromFn<any, any>>(
  function fromFn (line 25) | function fromFn<A, B>(t: FromFn<A, B> | From<A, B>): FromFn<A, B> {
  function extendType (line 42) | function extendType<
  type HasType (line 73) | type HasType<T extends Type<any, any>> = {

FILE: src/types.ts
  method from (line 9) | async from(str) {
  method defaultValue (line 37) | defaultValue() {
  function optional (line 45) | function optional<T extends Type<any, any>>(
  function array (line 60) | function array<T extends Type<any, any>>(

FILE: src/union.ts
  type Any (line 5) | type Any<A = any> = FromFn<A, any> | From<A, any>;
  function union (line 11) | function union<T1 extends Any, T2s extends Any<InputOf<T1>>>(

FILE: src/utils.ts
  function padNoAnsi (line 6) | function padNoAnsi(
  function groupBy (line 25) | function groupBy<A, B extends string>(
  function entries (line 43) | function entries<Obj extends Record<string, any>>(
  function flatMap (line 65) | function flatMap<A, B>(xs: A[], fn: (a: A) => B[]): B[] {
  function flatten (line 78) | function flatten<A>(xs: A[][]): A[] {
  type AllOrNothing (line 89) | type AllOrNothing<T> = T | { [key in keyof T]?: never };

FILE: test/createRegisterOptions.ts
  function createRegisterOptions (line 3) | function createRegisterOptions(): RegisterOptions {

FILE: test/test-types.ts
  method from (line 6) | async from(str) {
  function single (line 18) | function single<T extends Type<any, any>>(
  method defaultValue (line 50) | defaultValue() {
  function optional (line 55) | function optional<T extends Type<any, any>>(

FILE: test/util.ts
  function app (line 3) | function app(

FILE: test/utils.test.ts
  type Person (line 46) | type Person = { name: string; age: number };