Prevent infinite recursion resolving nested conditional types with import types in them

[andrewbranch]

Fixes #31824

In the provided repro, a large circular code path something like this occurs:

getTypeFromConditionalTypeNode
  -> isTypeParameterPossiblyReferenced
  -> [deep forEachChild down to a type alias Name<k>]
  -> [try to get the type of k]
  -> getConstrainedTypeVariable
  -> [walk up the parse tree until a conditional type is found]
  -> getImpliedConstraint
  -> [some uninteresting stuff]
  -> getTypeFromConditionalTypeNode

Unfortunately, I’m unable to figure out logically what’s happening because the declaration emit is so huge and convoluted that no human can understand it. As such, I have no idea where to begin to try writing a test for this, but the repro no longer crashes and existing tests pass ¯\(ツ)/¯

---

UPDATE, I FIGURED IT OUT

The issue occurs under these exact circumstances:

• You have a conditional type inside a conditional type, the outer of which contains an outer type parameter
• One of the types in the outer conditional type is or contains an import type with a qualifier and a type argument of the aforementioned outer type parameter:

type T<X> = any extends ((any extends any ? any : string) extends any ? import("./name").Name<X> : any)
  ? any
  : any;

The reason is that we weren’t properly short circuiting when trying to determine whether Name itself is a reference to X. In trying to figure that out, we ask for the type of Name, which ends up asking for the type of the whole import("./name").Name<X>, which tries to get the type of of X, which tries to resolve the type of T<X>, which we were already doing. Q.E.D. Drops mic. 🎤

[weswigham]

Usually we use a combination of pushTypeResolution and popTypeResolution (although admittedly, TypeSystemPropertyName has no entry for Node.resolvedType, so either it'd need to be added or we'd need to be OK with this), this way the error case when entering and exiting the recursion is explicitly handled. It should probably also report a circularity error using reportCircularityError, or error(symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, name); directly (since we're inevitably going to cache results using this unformed "circular" type).

[weswigham]

And a repro for the test harness would be swell, since this is exactly the kind of thing that could randomly go away in another bugfix without a test case demonstrating how it can occur. (In fact, without an isolated repro, it's hard to even know if this is the right place to insert a break)

[andrewbranch]

Yeah, totally agree, but I just can’t make sense out of the repro provided :/

[andrewbranch]

@AnyhowStep with this change, your library produces the error “Conditional type circularly references itself” in several places. Here are a few of them:

node_modules/type-mapping/dist/fluent-lib/index.d.ts:52:13960 - error TS2755: Conditional type circularly references itself.

52     } : unknown)> & import("..").ExpectedInput<({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]?: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; }) & (string extends MapT[Extract<keyof MapT, string>]["__name"] ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

node_modules/type-mapping/dist/fluent-lib/index.d.ts:52:15556 - error TS2755: Conditional type circularly references itself.

52     } : unknown)> & import("..").ExpectedInput<({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: ((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? undefined extends Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]?: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; }) & (string extends MapT[Extract<keyof MapT, string>]["__name"] ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

node_modules/type-mapping/dist/fluent-lib/index.d.ts:54:8804 - error TS2755: Conditional type circularly references itself.

54     } : unknown)> & import("..").MappableInput<(({ [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[Extract<keyof MapT, string>] extends never ? unknown : { [src in { [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[Extract<keyof MapT, string>]]: Extract<((MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) extends any ? (k: MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[Extract<keyof MapT, string>] extends never ? unknown : { [src in { [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[Extract<keyof MapT, string>]]?: Extract<((MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) extends any ? (k: MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; })) | (({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]?: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; }) & (string extends MapT[Extract<keyof MapT, string>]["__name"] ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

node_modules/type-mapping/dist/fluent-lib/index.d.ts:54:15340 - error TS2755: Conditional type circularly references itself.

54     } : unknown)> & import("..").MappableInput<(({ [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[Extract<keyof MapT, string>] extends never ? unknown : { [src in { [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[Extract<keyof MapT, string>]]: Extract<((MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) extends any ? (k: MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[Extract<keyof MapT, string>] extends never ? unknown : { [src in { [k in Extract<keyof MapT, string>]: (MapT[k] extends import("..").Optional ? undefined extends Extract<((MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) extends any ? (k: MapT[k] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & MapT[k] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & MapT[k]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[Extract<keyof MapT, string>]]?: Extract<((MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) extends any ? (k: MapT[src] extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? MapT[src] extends import("..").MappableInput<infer T> ? [T] : MapT[src] extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<MapT[src]>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; })) | (({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? never : k; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]; }) & ({ [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]] extends never ? unknown : { [dst in { [k in { [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]: (Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").Optional ? undefined extends Extract<((import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) extends any ? (k: import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & import("..").Optional & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<k>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] ? true : false : false) extends true ? k : never; }[{ [key in Extract<keyof MapT, string>]: string extends ("__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string) ? never : "__name" extends keyof MapT[key] ? MapT[key][Extract<"__name", keyof MapT[key]>] extends string ? MapT[key][Extract<"__name", keyof MapT[key]>] : string : string; }[Extract<keyof MapT, string>]]]?: Extract<((Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) extends any ? (k: Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").MappableInput<infer T> ? [T] : ((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>> extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<((name: string, mixed: T, ...args: any) => any) & Extract<MapT[Extract<keyof MapT, string>], import("..").Name<dst>>>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0] | undefined; }) & (string extends MapT[Extract<keyof MapT, string>]["__name"] ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If you can make any sense of this, it would be incredibly helpful if you could figure out a smaller, more focused repro that we can add to our tests. Especially if you think that the circularity error is incorrect—I’m not sure how we’re going to figure out how to diagnose this without a smaller example.

Clarification: the version you mentioned in the original issue produces that error—master does not.

[andrewbranch]

Actually, this is fairly troubling:

git clone AnyhowStep/type-mapping && cd type-mapping
git checkout 1a999792f00fe25d2d3d1038d48b857a82b94219 # v1.1.2

# no errors
node ../TypeScript/built/local/tsc.js -p .

# Before this PR: Maximum call stack size exceeded
# With this PR: 12 circularity errors
node ../TypeScript/built/local/tsc.js dist/fluent-lib/index.d.ts

Not hitting the max call stack size is nice and all, but the root of the problem seems to be a declaration emit bug 😐

[AnyhowStep]

@andrewbranch

I'll take a look at it when I get back home but this reminds me a lot of this other thing that happened to me recently,
typescript-eslint/typescript-eslint#730

---

Basically, I was using that exact library and forgot to add an explicit return type annotation to the generic function.

tsc inferred the return type and emitted a monstrosity that caused compile times to increase by 5 minutes.

After adding an explicit return type annotation, the emitted .d.ts was only a few lines long and the compile times decreased by 5 minutes.

---

I looked at the index.d.ts file you linked and saw this,

arrayLike<F extends import("..").Mapper<unknown, any>>(f: F): import("..").FluentMapper<import("..").Mapper<unknown, ArrayLike<ReturnType<F>>> & import("..").ExpectedInput<ArrayLike<Extract<((F extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? F extends import("..").ExpectedInput<infer T> ? [T] : F extends import("..").MappableInput<infer T> ? [T] : [ReturnType<F>] : [T] : never) extends any ? (k: F extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? F extends import("..").ExpectedInput<infer T> ? [T] : F extends import("..").MappableInput<infer T> ? [T] : [ReturnType<F>] : [T] : never) => void : never) extends (k: infer I) => void ? I : never, [any]>[0]>> & import("..").MappableInput<ArrayLike<Extract<((F extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? F extends import("..").MappableInput<infer T> ? [T] : F extends import("..").ExpectedInput<infer T> ? [T] : [ReturnType<F>] : [T] : never) extends any ? (k: F extends (name: string, mixed: infer T, ...args: any) => any ? unknown extends T ? F extends import("..").MappableInput<infer T> ? [T] : F extends import("..").ExpectedInput<
/*snip*/

Looks like arrayLike<>()'s emitted return type is a monstrosity.

If we look at the .ts file,
https://github.com/AnyhowStep/type-mapping/blob/1a999792f00fe25d2d3d1038d48b857a82b94219/src/fluent-lib/generic.ts#L9

export function arrayLike<F extends AnySafeMapper> (f : F) {
    return fluentMapper(m.arrayLike<F>(f));
}

We can see that I forgot to supply an explicit return type annotation.

So, tsc inferred that giant wall of text.

---

In a newer version of the library, I've added explicit return type annotations,
https://github.com/AnyhowStep/type-mapping/blob/5d65da02aabd4a0d000da64e2f242b14248a6444/src/fluent-lib/generic.ts#L9

export function arrayLike<F extends AnySafeMapper> (f : F) : (
    FluentMapper<m.ArrayLikeMapper<F>>
) {
    return fluentMapper(m.arrayLike<F>(f));
}

It looks like the emitted .d.ts is better now,
https://unpkg.com/[email protected]/dist/fluent-lib/generic.d.ts

export declare function arrayLike<F extends AnySafeMapper>(f: F): (FluentMapper<m.ArrayLikeMapper<F>>);

Just one line!

---

I wonder if I will still get that error you pointed out, now that I have explicit return type annotations,

TS2755: Conditional type circularly references itself.

[andrewbranch]

Yeah, I noticed in the declaration emit that it seemed to be inlining a lot of stuff for which type aliases exist. I’m honestly not too familiar with how declaration emit works, but it seems like what you found is definitely relevant—I confirmed that tsc can understand the declaration emit of what’s currently in master. When I originally pinged you, I thought maybe there was actually a type error in your library, but it looks like it’s something to do with declaration emit.

[andrewbranch]

@typescript-bot test this
@typescript-bot run dt

[typescript-bot]

Heya @andrewbranch, I've started to run the extended test suite on this PR at 174c0b8. You can monitor the build here. It should now contribute to this PR's status checks.

[typescript-bot]

Heya @andrewbranch, I've started to run the parallelized Definitely Typed test suite on this PR at 174c0b8. You can monitor the build here. It should now contribute to this PR's status checks.

[andrewbranch]

I think I’ve whittled it down to nearly the smallest possible repro:

And here’s the twist. If you paste Name’s definition into this file and remove import("..").... the error goes away 😱

In fact, I’ve replaced Name with this:

And the error still occurs, as long as the import type is used! I thought I was onto something, so I changed the import path to be "../mapper/name", right to the source—but the error remains!

@weswigham any clues now?

[weswigham]

@weswigham any clues now?

Well! That's interesting! Almost certainly it's because we're doing something too eagerly in import type resolution then.

[andrewbranch]

Clarification: the circularity error I added repros with this, but the stack size crash doesn’t 🤦‍♂

[weswigham]

The difference between the import type and in-file alias is still concerning, IMO.

[andrewbranch]

Agreed. I think I’m going to prioritize this behind the rest of my 3.6 bugs, but plan to come back to it due to that very strange discrepancy.

Just went back to the original declaration files and determined that, yep, if you just import Name at the top of the file, or inline the definition in the file, it compiles just fine.

[AnyhowStep]

Am I still needed for anything? I kind of lost track because it seemed like you got the circularity thing down.

Do I still need to try and reproduce the stack size crash?

[andrewbranch]

Nope, thanks for the help @AnyhowStep :)

[weswigham]

Nice job tracking down the root cause! I like the smallness of the change.