SYMBOL INDEX (1440 symbols across 69 files)

FILE: benchmarks/always-last-digit.ts
  type Digit (line 4) | type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

FILE: benchmarks/random-digit.ts
  type Digit (line 4) | type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

FILE: examples/gif-fetcher/src/App.tsx
  type State (line 11) | type State = {
  type Event (line 24) | type Event =
  function App (line 75) | function App() {

FILE: examples/gif-fetcher/src/constants.ts
  constant API_KEY (line 1) | const API_KEY = 'xxxxxxxxxxxxxxxx';

FILE: examples/gif-fetcher/src/searchGif.ts
  function searchGif (line 6) | function searchGif(query: string) {

FILE: examples/one-file-demo/one-file-demo.ts
  type Response (line 20) | type Response =
  type UserType (line 56) | type UserType = 'editor' | 'viewer';
  type OrgPlan (line 58) | type OrgPlan = 'basic' | 'pro' | 'premium';
  type User (line 112) | type User = P.infer<typeof User>;
  type Post (line 133) | type Post = P.infer<typeof Post>;

FILE: src/errors.ts
  class NonExhaustiveError (line 5) | class NonExhaustiveError extends Error {
    method constructor (line 6) | constructor(public input: unknown) {

FILE: src/internals/symbols.ts
  type matcher (line 17) | type matcher = typeof matcher;
  type unset (line 20) | type unset = typeof unset;
  type isVariadic (line 23) | type isVariadic = typeof isVariadic;
  type anonymousSelectKey (line 27) | type anonymousSelectKey = typeof anonymousSelectKey;
  type override (line 30) | type override = typeof override;

FILE: src/is-matching.ts
  type PatternConstraint (line 11) | type PatternConstraint<T> = T extends readonly any[]
  function isMatching (line 53) | function isMatching<const p extends Pattern<any>>(

FILE: src/match.ts
  type MatchState (line 7) | type MatchState<output> =
  function match (line 32) | function match<const input, output = symbols.unset>(
  class MatchExpression (line 47) | class MatchExpression<input, output> {
    method constructor (line 48) | constructor(private input: input, private state: MatchState<output>) {}
    method with (line 50) | with(...args: any[]): MatchExpression<input, output> {
    method when (line 94) | when(
    method otherwise (line 110) | otherwise(handler: (value: input) => output): output {
    method exhaustive (line 115) | exhaustive(unexpectedValueHandler = defaultCatcher): output {
    method run (line 120) | run(): output {
    method returnType (line 124) | returnType() {
    method narrow (line 128) | narrow() {
  function defaultCatcher (line 133) | function defaultCatcher(input: unknown): never {

FILE: src/patterns.ts
  type unstable_Matchable (line 81) | type unstable_Matchable<
  type unstable_Matcher (line 100) | type unstable_Matcher<
  type infer (line 116) | type infer<pattern> = InvertPattern<NoInfer<pattern>, unknown>;
  type narrow (line 131) | type narrow<input, pattern> = ExtractPreciseValue<
  function chainable (line 136) | function chainable<pattern extends Matcher<any, any, any, any, any>>(
  method [Symbol.iterator] (line 150) | [Symbol.iterator](): Iterator<pattern, void, undefined> {
  function arrayChainable (line 165) | function arrayChainable<pattern extends Matcher<any, any, any, any, any>>(
  function optional (line 187) | function optional<
  type UnwrapArray (line 217) | type UnwrapArray<xs> = xs extends readonly (infer x)[] ? x : never;
  type UnwrapSet (line 219) | type UnwrapSet<xs> = xs extends Set<infer x> ? x : never;
  type UnwrapMapKey (line 221) | type UnwrapMapKey<xs> = xs extends Map<infer k, any> ? k : never;
  type UnwrapMapValue (line 223) | type UnwrapMapValue<xs> = xs extends Map<any, infer v> ? v : never;
  type UnwrapRecordKey (line 225) | type UnwrapRecordKey<xs> = xs extends Record<infer k, any> ? k : never;
  type UnwrapRecordValue (line 227) | type UnwrapRecordValue<xs> = xs extends Record<any, infer v> ? v : never;
  type WithDefault (line 229) | type WithDefault<a, b> = [a] extends [never] ? b : a;
  function array (line 246) | function array(
  function set (line 299) | function set<
  function map (line 362) | function map<
  function record (line 445) | function record(
  function intersection (line 536) | function intersection<
  function union (line 572) | function union<
  function not (line 611) | function not<
  function when (line 646) | function when<input, predicate extends (value: input) => unknown>(
  function select (line 696) | function select(
  function isUnknown (line 734) | function isUnknown(x: unknown): x is unknown {
  function isNumber (line 738) | function isNumber<T>(x: T | number): x is number {
  function isString (line 742) | function isString<T>(x: T | string): x is string {
  function isBoolean (line 746) | function isBoolean<T>(x: T | boolean): x is boolean {
  function isBigInt (line 750) | function isBigInt<T>(x: T | bigint): x is bigint {
  function isSymbol (line 754) | function isSymbol<T>(x: T | symbol): x is symbol {
  function isNullish (line 758) | function isNullish<T>(x: T | null | undefined): x is null | undefined {
  function isNonNullable (line 762) | function isNonNullable(x: unknown): x is {} {
  type AnyConstructor (line 766) | type AnyConstructor = abstract new (...args: any[]) => any;
  function isInstanceOf (line 768) | function isInstanceOf<T extends AnyConstructor>(classConstructor: T) {
  function instanceOf (line 1251) | function instanceOf<T extends AnyConstructor>(
  function shape (line 1274) | function shape(pattern: UnknownValuePattern) {

FILE: src/types/BuildMany.ts
  type BuildMany (line 4) | type BuildMany<data, xs extends readonly any[]> = xs extends any
  type BuildOne (line 11) | type BuildOne<data, xs extends readonly any[]> = xs extends [
  type SetDeep (line 19) | type SetDeep<data, value, path> = path extends readonly [

FILE: src/types/DeepExclude.ts
  type DeepExclude (line 3) | type DeepExclude<a, b> = Exclude<DistributeMatchingUnions<a, b>, b>;

FILE: src/types/DistributeUnions.ts
  type DistributeMatchingUnions (line 41) | type DistributeMatchingUnions<a, p> = IsAny<a> extends true
  type FindUnionsMany (line 46) | type FindUnionsMany<
  type FindUnions (line 80) | type FindUnions<
  type ArrayToVariadicUnion (line 174) | type ArrayToVariadicUnion<input, excluded> = MaybeAddReadonly<
  type Distribute (line 183) | type Distribute<unions extends readonly any[]> =

FILE: src/types/ExtractPreciseValue.ts
  type ExtractPreciseValue (line 13) | type ExtractPreciseValue<a, b> = b extends Override<infer b1>
  type ExtractPreciseArrayValue (line 81) | type ExtractPreciseArrayValue<

FILE: src/types/FindSelected.ts
  type SelectionsRecord (line 11) | type SelectionsRecord = Record<string, [unknown, unknown[]]>;
  type None (line 13) | type None = {
  type Some (line 16) | type Some<key extends string> = {
  type SelectionType (line 21) | type SelectionType = None | Some<string>;
  type MapOptional (line 24) | type MapOptional<selections> = {
  type MapList (line 31) | type MapList<selections> = {
  type ReduceFindSelectionUnion (line 38) | type ReduceFindSelectionUnion<
  type FindSelectionUnionInArray (line 47) | type FindSelectionUnionInArray<
  type FindSelectionUnion (line 96) | type FindSelectionUnion<
  type SeveralAnonymousSelectError (line 159) | type SeveralAnonymousSelectError<
  type MixedNamedAndAnonymousSelectError (line 165) | type MixedNamedAndAnonymousSelectError<
  type SelectionToArgs (line 174) | type SelectionToArgs<selections extends SelectionsRecord> =
  type Selections (line 185) | type Selections<i, p> = FindSelectionUnion<i, p> extends infer u
  type FindSelected (line 191) | type FindSelected<i, p> =

FILE: src/types/InvertPattern.ts
  type OptionalKeys (line 29) | type OptionalKeys<p> = ValueOf<{
  type ReduceUnion (line 39) | type ReduceUnion<
  type ReduceIntersection (line 47) | type ReduceIntersection<
  type InvertArrayPattern (line 55) | type InvertArrayPattern<
  type InvertPattern (line 106) | type InvertPattern<p, input> = Equal<Pattern<input>, p> extends true
  type InvertPatternInternal (line 110) | type InvertPatternInternal<p, input> = 0 extends 1 & p
  type ReduceIntersectionForExclude (line 180) | type ReduceIntersectionForExclude<
  type ReduceUnionForExclude (line 192) | type ReduceUnionForExclude<
  type ExcludeIfExists (line 204) | type ExcludeIfExists<a, b> =
  type InvertArrayPatternForExclude (line 231) | type InvertArrayPatternForExclude<
  type InvertPatternForExclude (line 303) | type InvertPatternForExclude<p, i> = Equal<Pattern<i>, p> extends true
  type InvertPatternForExcludeInternal (line 307) | type InvertPatternForExcludeInternal<p, i, empty = never> =

FILE: src/types/IsMatching.ts
  type IsMatchingTuple (line 12) | type IsMatchingTuple<a extends readonly any[], b extends readonly any[]>...
  type IsMatchingArray (line 26) | type IsMatchingArray<
  type IsMatching (line 57) | type IsMatching<a, b> = true extends IsUnion<a> | IsUnion<b>

FILE: src/types/Match.ts
  type PickReturnValue (line 8) | type PickReturnValue<a, b> = a extends symbols.unset ? b : a;
  type NonExhaustiveError (line 10) | interface NonExhaustiveError<i> {
  type TSPatternError (line 14) | interface TSPatternError<i> {
  type Match (line 22) | type Match<
  type DeepExcludeAll (line 245) | type DeepExcludeAll<a, tupleList extends any[]> = [a] extends [never]
  type MakeTuples (line 251) | type MakeTuples<ps extends readonly any[], value> = {
  type Exhaustive (line 261) | type Exhaustive<output, inferredOutput> = {

FILE: src/types/Pattern.ts
  type MatcherType (line 7) | type MatcherType =
  type MatcherProtocol (line 23) | type MatcherProtocol<
  type MatchResult (line 38) | type MatchResult = {
  type Matcher (line 50) | interface Matcher<
  type PatternMatcher (line 71) | type PatternMatcher<input> = Matcher<input, unknown, any, any>;
  type MatchedValue (line 74) | type MatchedValue<a, invpattern> = WithDefault<
  type AnyMatcher (line 79) | type AnyMatcher = Matcher<any, any, any, any, any>;
  type UnknownMatcher (line 81) | type UnknownMatcher = PatternMatcher<unknown>;
  type CustomP (line 83) | type CustomP<input, pattern, narrowedOrFn> = Matcher<
  type ArrayP (line 94) | type ArrayP<input, p> = Matcher<input, p, 'array'>;
  type RecordP (line 96) | type RecordP<input, pkey, pvalue> = Matcher<
  type OptionalP (line 102) | type OptionalP<input, p> = Matcher<input, p, 'optional'>;
  type MapP (line 104) | type MapP<input, pkey, pvalue> = Matcher<input, [pkey, pvalue], 'map'>;
  type SetP (line 106) | type SetP<input, p> = Matcher<input, p, 'set'>;
  type AndP (line 108) | type AndP<input, ps> = Matcher<input, ps, 'and'>;
  type OrP (line 110) | type OrP<input, ps> = Matcher<input, ps, 'or'>;
  type NotP (line 112) | type NotP<input, p> = Matcher<input, p, 'not'>;
  type GuardP (line 114) | type GuardP<input, narrowed> = Matcher<input, narrowed>;
  type GuardExcludeP (line 116) | type GuardExcludeP<input, narrowed, excluded> = Matcher<
  type SelectP (line 124) | type SelectP<
  type AnonymousSelectP (line 130) | type AnonymousSelectP = SelectP<symbols.anonymousSelectKey>;
  type Override (line 132) | interface Override<a> {
  type UnknownProperties (line 136) | type UnknownProperties = { readonly [k: PropertyKey]: unknown };
  type UnknownValuePattern (line 138) | type UnknownValuePattern =
  type Pattern (line 157) | type Pattern<a = unknown> = unknown extends a
  type KnownPattern (line 161) | type KnownPattern<a> = KnownPatternInternal<a>;
  type KnownPatternInternal (line 163) | type KnownPatternInternal<
  type ObjectPattern (line 174) | type ObjectPattern<a> =
  type ArrayPattern (line 180) | type ArrayPattern<a> = a extends readonly (infer i)[]
  type UnknownPattern (line 190) | type UnknownPattern = Chainable<GuardP<unknown, unknown>, never>;
  type StringPattern (line 191) | type StringPattern = StringChainable<GuardP<unknown, string>, never>;
  type NumberPattern (line 192) | type NumberPattern = NumberChainable<GuardP<unknown, number>, never>;
  type BooleanPattern (line 193) | type BooleanPattern = Chainable<GuardP<unknown, boolean>, never>;
  type BigIntPattern (line 194) | type BigIntPattern = BigIntChainable<GuardP<unknown, bigint>, never>;
  type SymbolPattern (line 195) | type SymbolPattern = Chainable<GuardP<unknown, symbol>, never>;
  type NullishPattern (line 196) | type NullishPattern = Chainable<
  type NonNullablePattern (line 201) | type NonNullablePattern = Chainable<GuardP<unknown, {}>, never>;
  type MergeGuards (line 203) | type MergeGuards<input, guard1, guard2> = [guard1, guard2] extends [
  type Chainable (line 210) | type Chainable<p, omitted extends string = never> = p &
  type StringChainable (line 276) | type StringChainable<
  type NumberChainable (line 391) | type NumberChainable<p, omitted extends string = never> = Chainable<
  type BigIntChainable (line 530) | type BigIntChainable<p, omitted extends string = never> = Chainable<
  type Variadic (line 643) | type Variadic<pattern> = pattern & Iterable<pattern>;
  type ArrayChainable (line 645) | type ArrayChainable<

FILE: src/types/helpers.ts
  type ValueOf (line 1) | type ValueOf<a> = a extends readonly any[] ? a[number] : a[keyof a];
  type Values (line 3) | type Values<a extends object> = UnionToTuple<ValueOf<a>>;
  type LeastUpperBound (line 14) | type LeastUpperBound<a, b> = b extends a ? b : a extends b ? a : never;
  type Contains (line 16) | type Contains<a, b> = a extends any
  type UnionToIntersection (line 25) | type UnionToIntersection<union> = (
  type IsUnion (line 31) | type IsUnion<a> = [a] extends [UnionToIntersection<a>] ? false : true;
  type UnionToTuple (line 33) | type UnionToTuple<
  type Flatten (line 42) | type Flatten<
  type Equal (line 49) | type Equal<a, b> = (<T>() => T extends a ? 1 : 2) extends <
  type Expect (line 55) | type Expect<a extends true> = a;
  type IsAny (line 57) | type IsAny<a> = 0 extends 1 & a ? true : false;
  type IsNever (line 59) | type IsNever<T> = [T] extends [never] ? true : false;
  type Length (line 61) | type Length<it extends readonly any[]> = it['length'];
  type Iterator (line 63) | type Iterator<
  type Next (line 68) | type Next<it extends any[]> = [any, ...it];
  type Prev (line 69) | type Prev<it extends any[]> = it extends readonly [any, ...infer tail]
  type Take (line 73) | type Take<
  type Drop (line 83) | type Drop<
  type UpdateAt (line 92) | type UpdateAt<
  type BuiltInObjects (line 105) | type BuiltInObjects =
  type IsPlainObject (line 113) | type IsPlainObject<o, excludeUnion = BuiltInObjects> = o extends object
  type Compute (line 122) | type Compute<a extends any> = a extends BuiltInObjects
  type IntersectObjects (line 126) | type IntersectObjects<a> = (
  type WithDefault (line 138) | type WithDefault<a, def> = [a] extends [never] ? def : a;
  type IsLiteral (line 140) | type IsLiteral<a> = [a] extends [null | undefined]
  type Primitives (line 164) | type Primitives =
  type NonLiteralPrimitive (line 173) | type NonLiteralPrimitive = Exclude<Primitives, undefined | null>;
  type TupleKeys (line 175) | type TupleKeys = '0' | '1' | '2' | '3' | '4';
  type Union (line 177) | type Union<a, b> = [b] extends [a] ? a : [a] extends [b] ? b : a | b;
  type GuardValue (line 182) | type GuardValue<fn> = fn extends (value: any) => value is infer b
  type GuardFunction (line 188) | type GuardFunction<input, narrowed> =
  type Some (line 192) | type Some<bools extends boolean[]> = true extends bools[number]
  type All (line 196) | type All<bools extends boolean[]> = bools[number] extends true
  type Extends (line 200) | type Extends<a, b> = [a] extends [b] ? true : false;
  type Not (line 202) | type Not<a extends boolean> = a extends true ? false : true;
  type AllKeys (line 204) | type AllKeys<a> = a extends any ? keyof a : never;
  type MergeUnion (line 207) | type MergeUnion<a> =
  type IsFixedSizeTuple (line 217) | type IsFixedSizeTuple<a extends readonly any[]> = IsLiteral<Length<a>>;
  type IsTuple (line 220) | type IsTuple<a> = a extends
  type IsStrictArray (line 227) | type IsStrictArray<a extends readonly any[]> = Not<IsTuple<a>>;
  type IsReadonlyArray (line 229) | type IsReadonlyArray<a> = a extends readonly any[]
  type MaybeAddReadonly (line 235) | type MaybeAddReadonly<
  type MapKey (line 240) | type MapKey<T> = T extends Map<infer K, any> ? K : never;
  type MapValue (line 242) | type MapValue<T> = T extends Map<any, infer V> ? V : never;
  type SetValue (line 244) | type SetValue<T> = T extends Set<infer V> ? V : never;
  type RecordKey (line 246) | type RecordKey<T> = T extends Record<infer K, any> ? K : never;
  type RecordValue (line 248) | type RecordValue<T> = T extends Record<any, infer V> ? V : never;
  type ReadonlyArrayValue (line 250) | type ReadonlyArrayValue<T> = T extends ReadonlyArray<infer V>
  type ExtractPlainObject (line 254) | type ExtractPlainObject<T> = T extends any
  type GetKey (line 260) | type GetKey<O, K> = O extends any
  type Fn (line 266) | interface Fn {
  type Call (line 271) | type Call<fn extends Fn, input> = (fn & {
  type IsOptionalKeysOf (line 275) | type IsOptionalKeysOf<obj, key extends keyof obj> = {} extends Pick<

FILE: tests/bigints.test.ts
  type t (line 9) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 13) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 27) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 31) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 43) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 47) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 59) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 63) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 75) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 79) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 91) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 95) | type t = Expect<Equal<typeof value, string | bigint>>;
  type t (line 107) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 111) | type t = Expect<Equal<typeof value, string | bigint>>;

FILE: tests/branded-nominal-types.test.ts
  type BrandedId (line 4) | type BrandedId = string & { __brand: 'brandId' };
  type FooBar (line 5) | type FooBar = { type: 'foo'; id: BrandedId; value: string } | { type: 'b...
  type State (line 6) | type State = {
  type Tagged (line 29) | type Tagged<Token> = { readonly [tag]: Token };
  type Opaque (line 30) | type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
  type Branded (line 43) | interface Branded<key extends string> {
  type Brand (line 47) | type Brand<a, key extends string> = a & Branded<key>;
  type BrandId (line 48) | type BrandId = Brand<number, 'BrandId'>;

FILE: tests/build-many.test.ts
  type cases (line 7) | type cases = [

FILE: tests/chainable.test.ts
  type t (line 10) | type t = Expect<Equal<typeof value, string | undefined>>;
  type t (line 14) | type t = Expect<Equal<typeof value, number>>;
  type t (line 27) | type t = Expect<Equal<typeof value, string>>;
  type t (line 40) | type t = Expect<Equal<typeof value, number | undefined>>;
  type t (line 53) | type t = Expect<Equal<typeof value, string | undefined>>;
  type t (line 70) | type t = Expect<
  type t (line 86) | type t = Expect<
  type t (line 105) | type t = Expect<Equal<typeof value, number | undefined>>;
  type t (line 109) | type t = Expect<Equal<typeof value, string>>;
  type t (line 122) | type t = Expect<Equal<typeof value, number>>;
  type t (line 146) | type t = Expect<Equal<typeof value, number | undefined>>;
  type t (line 167) | type t = Expect<Equal<typeof value, bigint | undefined>>;
  type t (line 171) | type t = Expect<Equal<typeof value, string>>;
  type t (line 184) | type t = Expect<Equal<typeof value, bigint>>;
  type t (line 202) | type t = Expect<Equal<typeof value, bigint | undefined>>;
  type t (line 223) | type t = Expect<
  type t (line 245) | type t = Expect<

FILE: tests/deep-exclude.test.ts
  type Colors (line 11) | type Colors = 'pink' | 'purple' | 'red' | 'yellow' | 'blue';
  type cases (line 15) | type cases = [
  type cases (line 31) | type cases = [
  type cases (line 46) | type cases = [
  type cases (line 53) | type cases = [
  type x (line 64) | type x = DeepExclude<{ str: string | null | undefined }, { str: string }>;
  type xx (line 65) | type xx = DistributeMatchingUnions<
  type xxx (line 69) | type xxx = FindUnionsMany<
  type xxxx (line 73) | type xxxx = IsMatching<
  type xxxxx (line 77) | type xxxxx = FindUnions<
  type y (line 82) | type y = DeepExclude<
  type cases (line 87) | type cases = [
  type input (line 133) | type input = {
  type pattern (line 137) | type pattern = {
  type res1 (line 141) | type res1 = DeepExclude<input, pattern>;
  type test1 (line 142) | type test1 = Expect<
  type cases (line 150) | type cases = [
  type cases (line 182) | type cases = [
  type cases (line 190) | type cases = [
  type State (line 211) | type State = {};
  type Msg (line 212) | type Msg = [type: 'Login'] | [type: 'UrlChange', url: string];
  type Input (line 213) | type Input = [State, Msg];
  type cases (line 215) | type cases = [
  type res1 (line 246) | type res1 = DeepExclude<number[], [number, ...number[]]>;
  type test1 (line 247) | type test1 = Expect<Equal<res1, []>>;
  type res2 (line 249) | type res2 = DeepExclude<number[], []>;
  type test2 (line 250) | type test2 = Expect<Equal<res2, [number, ...number[]]>>;
  type res3 (line 252) | type res3 = DeepExclude<number[], [...number[], number]>;
  type test3 (line 253) | type test3 = Expect<Equal<res3, []>>;
  type res4 (line 255) | type res4 = DeepExclude<[number, ...number[]], [...number[], number]>;
  type test4 (line 257) | type test4 = Expect<Equal<res4, never>>;
  type res1 (line 261) | type res1 = DeepExclude<number[], [string, ...number[]]>;
  type test1 (line 262) | type test1 = Expect<Equal<res1, number[]>>;
  type res3 (line 264) | type res3 = DeepExclude<number[], [...string[], number]>;
  type test3 (line 265) | type test3 = Expect<Equal<res3, number[]>>;
  type res4 (line 268) | type res4 = DeepExclude<[number, ...string[]], [...number[], string]>;
  type test4 (line 269) | type test4 = Expect<Equal<res4, [number, ...string[]]>>;
  type cases (line 274) | type cases = [
  type res1 (line 284) | type res1 = DeepExclude<{ values: (1 | 2 | 3)[] }, { values: [] }>;
  type test1 (line 285) | type test1 = Expect<
  type cases (line 289) | type cases = [
  type cases (line 308) | type cases = [
  type cases (line 322) | type cases = [
  type cases (line 351) | type cases = [
  type cases (line 396) | type cases = [
  type cases (line 464) | type cases = [
  type cases (line 489) | type cases = [
  type Input (line 548) | type Input = readonly ['a' | 'b', 'c' | 'd'];
  type p (line 549) | type p = ['a', 'c'] | ['a', 'd'] | ['b', 'c'] | ['b', 'd'];
  type cases (line 551) | type cases = [
  type cases (line 563) | type cases = [
  type t (line 577) | type t = Expect<

FILE: tests/distribute-unions.test.ts
  type res1 (line 13) | type res1 = FindUnions<{ a: 1 | 2; b: 3 | 4; c: 6 | 7 }, { a: 1; b: 3 }>;
  type test1 (line 14) | type test1 = Expect<
  type res2 (line 45) | type res2 = FindUnions<
  type test2 (line 54) | type test2 = Expect<
  type res3 (line 97) | type res3 = FindUnions<
  type test3 (line 113) | type test3 = Expect<
  type res4 (line 181) | type res4 = FindUnions<
  type test4 (line 185) | type test4 = Expect<
  type res5 (line 227) | type res5 = FindUnions<
  type test5 (line 239) | type test5 = Expect<
  type cases (line 285) | type cases = [
  type res1 (line 430) | type res1 = FindUnions<readonly number[], readonly []>;
  type tes1 (line 431) | type tes1 = Expect<
  type res2 (line 451) | type res2 = FindUnions<[number], []>;
  type tes2 (line 452) | type tes2 = Expect<Equal<res2, []>>;
  type res3 (line 454) | type res3 = FindUnions<[number], [number, ...number[]]>;
  type tes3 (line 455) | type tes3 = Expect<Equal<res3, []>>;
  type res4 (line 457) | type res4 = FindUnions<[number], [...number[], number]>;
  type tes4 (line 458) | type tes4 = Expect<Equal<res4, []>>;
  type res5 (line 460) | type res5 = FindUnions<[number], [...number[], number]>;
  type tes5 (line 461) | type tes5 = Expect<Equal<res5, []>>;
  type res6 (line 463) | type res6 = FindUnions<readonly number[], readonly [number, ...number[]]>;
  type tes6 (line 464) | type tes6 = Expect<
  type res7 (line 484) | type res7 = FindUnions<readonly number[], readonly [...number[], number]>;
  type tes7 (line 485) | type tes7 = Expect<
  type res8 (line 505) | type res8 = FindUnions<
  type tes8 (line 509) | type tes8 = Expect<Equal<res8, []>>;
  type res9 (line 511) | type res9 = FindUnions<
  type tes9 (line 515) | type tes9 = Expect<Equal<res9, []>>;
  type cases (line 519) | type cases = [
  type cases (line 567) | type cases = [
  type cases (line 716) | type cases = [
  type cases (line 756) | type cases = [
  type cases (line 764) | type cases = [
  type cases (line 797) | type cases = [
  type res1 (line 845) | type res1 = DistributeMatchingUnions<[], []>;
  type test1 (line 846) | type test1 = Expect<Equal<res1, []>>;
  type cases (line 848) | type cases = [
  type X (line 868) | type X = 1 | 2 | 3 | 4 | 5 | 6 | 7;
  type cases (line 870) | type cases = [
  type cases (line 941) | type cases = [
  type cases (line 993) | type cases = [
  type cases (line 1026) | type cases = [

FILE: tests/exhaustive-fallback.test.ts
  type t (line 12) | type t = Expect<

FILE: tests/exhaustive-match.test.ts
  type Input (line 15) | type Input = 'a' | 'b' | 'c';
  type t (line 20) | type t = Expect<Equal<typeof x, 'b'>>;
  type t (line 34) | type t = Expect<Equal<typeof x, 'a'>>;
  type t (line 38) | type t = Expect<Equal<typeof x, 'b'>>;
  type t (line 46) | type t = Expect<Equal<typeof x, 'a'>>;
  type t (line 50) | type t = Expect<Equal<typeof x, 'b'>>;
  type t (line 54) | type t = Expect<Equal<typeof x, 'c'>>;
  type Input (line 61) | type Input = 1 | 2 | 3;
  type t (line 66) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 80) | type t = Expect<Equal<typeof x, 1>>;
  type t (line 84) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 92) | type t = Expect<Equal<typeof x, 1>>;
  type t (line 96) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 100) | type t = Expect<Equal<typeof x, 3>>;
  type Input (line 107) | type Input =
  type Input (line 130) | type Input = [boolean, boolean];
  type letter (line 149) | type letter =
  type Input (line 177) | type Input =
  type t (line 199) | type t = Expect<Equal<typeof data, number>>;
  type t (line 204) | type t = Expect<Equal<typeof data, true>>;
  type t (line 208) | type t = Expect<Equal<typeof data, boolean>>;
  type Input (line 259) | type Input = [1, number] | ['two', string] | [3, boolean];
  type Input (line 288) | type Input =
  type Input (line 321) | type Input = ['two', Option<string>];
  type Input (line 357) | type Input = { value: 'a' | 'b' };
  type Input (line 376) | type Input =
  type Input (line 431) | type Input = Set<string> | Set<number>;
  type Input (line 446) | type Input = Set<string> | Set<number>;
  type Input (line 465) | type Input = Map<string, 1 | 2 | 3>;
  type X (line 495) | type X = 1 | 2 | 3 | 4 | 5 | 6 | 7;
  type t (line 575) | type t = Expect<Equal<typeof res, Option<string>>>;
  type Input (line 581) | type Input = { type: 'test' } | ['hello', Option<string>] | 'hello'[];
  type t (line 594) | type t = Expect<
  type Input (line 604) | type Input = { type: 'video'; duration: number };
  type t (line 621) | type t = Expect<Equal<typeof x, { x: 1 }>>;
  type t (line 625) | type t = Expect<Equal<typeof x, { x: 2 }>>;
  type t (line 629) | type t = Expect<Equal<typeof x, { x: 3 }>>;
  type t (line 670) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 678) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 686) | type t = Expect<Equal<typeof x, 1>>;
  type t (line 690) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 694) | type t = Expect<Equal<typeof x, 3>>;
  type Input (line 702) | type Input =
  type Input (line 773) | type Input = { type: 3; data: number };
  type t (line 779) | type t = Expect<Equal<typeof data, number>>;
  type Input2 (line 784) | type Input2 = { type: 3; data: true } | 2;
  type t (line 787) | type t = Expect<Equal<typeof data, true>>;
  type FlagComponent (line 795) | type FlagComponent = { color: 'red' | 'white' | 'blue' };
  function checkFlagComponent (line 797) | function checkFlagComponent(component: FlagComponent) {
  type t (line 911) | type t = Expect<Equal<typeof x, { t: 'a'; x: any }>>;
  type Person (line 933) | type Person = {
  function withTypo (line 938) | function withTypo(person: Person) {
  function withoutTypo (line 966) | function withoutTypo(person: Person) {
  type Input (line 984) | type Input = string | Date | readonly string[];
  type Input (line 997) | type Input = { type?: 'one' } | { type: 'two' };
  type t (line 1028) | type t = Expect<Equal<typeof x, { type: undefined }>>;
  type t (line 1050) | type t = Expect<Equal<typeof x, { type?: undefined }>>;
  type t (line 1071) | type t = Expect<Equal<typeof x, { type: undefined }>>;

FILE: tests/extract-precise-value.test.ts
  type res1 (line 9) | type res1 = ExtractPreciseValue<
  type test1 (line 14) | type test1 = Expect<
  type cases (line 18) | type cases = [
  type cases (line 75) | type cases = [
  type cases (line 86) | type cases = [
  type cases (line 97) | type cases = [
  type cases (line 142) | type cases = [
  type Input (line 174) | type Input = { t: 'a'; data: 'string'; x: any } | { t: 'b' };
  type cases (line 176) | type cases = [
  type res1 (line 214) | type res1 = ExtractPreciseValue<
  type test1 (line 218) | type test1 = Expect<Equal<res1, string[]>>;
  type res2 (line 220) | type res2 = ExtractPreciseValue<
  type test2 (line 224) | type test2 = Expect<Equal<res2, { b: number; c: string }[]>>;
  type Input (line 230) | type Input =
  type cases (line 235) | type cases = [
  type Input (line 258) | type Input =
  type cases (line 268) | type cases = [
  type nonNullable (line 298) | type nonNullable = InvertPattern<NonNullablePattern, unknown>;
  type res1 (line 301) | type res1 = ExtractPreciseValue<{ a: string }, { b: nonNullable }>;
  type test1 (line 302) | type test1 = Expect<Equal<res1, never>>;
  type res2 (line 304) | type res2 = ExtractPreciseValue<
  type test2 (line 308) | type test2 = Expect<Equal<res2, { b: number }>>;
  type res3 (line 310) | type res3 = ExtractPreciseValue<
  type test3 (line 314) | type test3 = Expect<
  type res1 (line 320) | type res1 = ExtractPreciseValue<
  type test1 (line 324) | type test1 = Expect<Equal<res1, { b: {} }>>;
  type res1 (line 328) | type res1 = ExtractPreciseValue<{ a: number }, { b: { c: nonNullable } }>;
  type test1 (line 329) | type test1 = Expect<Equal<res1, never>>;
  type res2 (line 331) | type res2 = ExtractPreciseValue<
  type test2 (line 337) | type test2 = Expect<
  type BrandedId (line 351) | type BrandedId = string & { __brand: 'brandId' };
  type FooBar (line 353) | type FooBar =
  type cases (line 357) | type cases = [
  class A (line 386) | class A {
  class B (line 389) | class B {
  type cases (line 392) | type cases = [Expect<Equal<ExtractPreciseValue<A | B, A>, A>>];
  class FooError (line 396) | class FooError extends Error {
  class BazError (line 400) | class BazError extends Error {
  class ErrorWithOptionalKeys1 (line 404) | class ErrorWithOptionalKeys1 extends Error {
  class ErrorWithOptionalKeys2 (line 408) | class ErrorWithOptionalKeys2 extends Error {
  type cases (line 412) | type cases = [
  type res1 (line 436) | type res1 = ExtractPreciseValue<unknown[], [unknown, ...unknown[]]>;
  type t1 (line 437) | type t1 = Expect<Equal<res1, [unknown, ...unknown[]]>>;
  type res2 (line 439) | type res2 = ExtractPreciseValue<unknown[], [number, ...string[]]>;
  type t2 (line 440) | type t2 = Expect<Equal<res2, [number, ...string[]]>>;
  type res3 (line 442) | type res3 = ExtractPreciseValue<
  type t3 (line 446) | type t3 = Expect<Equal<res3, ['a', ...boolean[]]>>;
  type res4 (line 448) | type res4 = ExtractPreciseValue<
  type t4 (line 452) | type t4 = Expect<Equal<res4, ['a', ...(string | boolean)[]]>>;
  type res1 (line 456) | type res1 = ExtractPreciseValue<
  type t1 (line 460) | type t1 = Expect<Equal<res1, [unknown, unknown, ...unknown[]]>>;
  type res2 (line 462) | type res2 = ExtractPreciseValue<
  type t2 (line 466) | type t2 = Expect<Equal<res2, [number, boolean, ...string[]]>>;
  type res3 (line 468) | type res3 = ExtractPreciseValue<
  type t3 (line 472) | type t3 = Expect<Equal<res3, ['a', 2, ...boolean[]]>>;
  type res1 (line 476) | type res1 = ExtractPreciseValue<unknown[], [...unknown[], unknown]>;
  type t1 (line 477) | type t1 = Expect<Equal<res1, [...unknown[], unknown]>>;
  type res2 (line 479) | type res2 = ExtractPreciseValue<unknown[], [...string[], number]>;
  type t2 (line 480) | type t2 = Expect<Equal<res2, [...string[], number]>>;
  type res3 (line 482) | type res3 = ExtractPreciseValue<
  type t3 (line 486) | type t3 = Expect<Equal<res3, [...boolean[], 'a']>>;
  type res1 (line 489) | type res1 = ExtractPreciseValue<
  type t1 (line 493) | type t1 = Expect<Equal<res1, [...unknown[], unknown, unknown]>>;
  type res2 (line 495) | type res2 = ExtractPreciseValue<
  type t2 (line 499) | type t2 = Expect<Equal<res2, [...string[], number, boolean]>>;
  type res3 (line 501) | type res3 = ExtractPreciseValue<
  type t3 (line 505) | type t3 = Expect<Equal<res3, [...boolean[], 'a', true]>>;
  type res1 (line 508) | type res1 = ExtractPreciseValue<
  type t1 (line 512) | type t1 = Expect<Equal<res1, [unknown, ...unknown[], unknown]>>;
  type res2 (line 514) | type res2 = ExtractPreciseValue<
  type t2 (line 518) | type t2 = Expect<Equal<res2, [number, ...string[], boolean]>>;
  type res3 (line 520) | type res3 = ExtractPreciseValue<
  type t3 (line 524) | type t3 = Expect<Equal<res3, ['a', ...boolean[], 2]>>;
  type res1 (line 532) | type res1 = ExtractPreciseValue<
  type test1 (line 538) | type test1 = Expect<

FILE: tests/find-selected.test.ts
  type AnonymousSelectP (line 17) | type AnonymousSelectP = SelectP<symbols.anonymousSelectKey>;
  type res1 (line 22) | type res1 = FindSelected<
  type test1 (line 32) | type test1 = Expect<Equal<res1, { c: 3 }>>;
  type cases (line 34) | type cases = [
  type res1 (line 79) | type res1 = FindSelected<
  type test1 (line 83) | type test1 = Expect<Equal<res1, { state: State; event: Event[] }>>;
  type res2 (line 85) | type res2 = FindSelected<
  type test2 (line 89) | type test2 = Expect<Equal<res2, 1>>;
  type res3 (line 91) | type res3 = FindSelected<
  type test3 (line 95) | type test3 = Expect<Equal<res3, number[]>>;
  type res1 (line 99) | type res1 = FindSelected<
  type test1 (line 107) | type test1 = Expect<
  type res2 (line 111) | type res2 = FindSelected<
  type test2 (line 115) | type test2 = Expect<Equal<res2, 1>>;
  type res3 (line 117) | type res3 = FindSelected<
  type test3 (line 121) | type test3 = Expect<Equal<res3, 2>>;
  type res4 (line 123) | type res4 = FindSelected<
  type test4 (line 127) | type test4 = Expect<Equal<res4, number[]>>;
  type res1 (line 130) | type res1 = FindSelected<
  type test1 (line 134) | type test1 = Expect<Equal<res1, { state: State; event: Event[] }>>;
  type res2 (line 136) | type res2 = FindSelected<
  type test2 (line 140) | type test2 = Expect<Equal<res2, 1>>;
  type res3 (line 142) | type res3 = FindSelected<
  type test3 (line 146) | type test3 = Expect<Equal<res3, number[]>>;
  type res1 (line 149) | type res1 = FindSelected<
  type test1 (line 157) | type test1 = Expect<
  type res2 (line 161) | type res2 = FindSelected<
  type test2 (line 165) | type test2 = Expect<Equal<res2, 1>>;
  type res3 (line 167) | type res3 = FindSelected<
  type test3 (line 171) | type test3 = Expect<Equal<res3, 2>>;
  type res4 (line 173) | type res4 = FindSelected<
  type test4 (line 177) | type test4 = Expect<Equal<res4, number[]>>;
  type res1 (line 181) | type res1 = FindSelected<
  type test1 (line 189) | type test1 = Expect<
  type res2 (line 193) | type res2 = FindSelected<
  type test2 (line 197) | type test2 = Expect<Equal<res2, 1>>;
  type res3 (line 199) | type res3 = FindSelected<
  type test3 (line 203) | type test3 = Expect<Equal<res3, 2>>;
  type res4 (line 205) | type res4 = FindSelected<
  type test4 (line 209) | type test4 = Expect<Equal<res4, number[]>>;
  type res1 (line 213) | type res1 = FindSelected<
  type test1 (line 217) | type test1 = Expect<Equal<res1, number>>;
  type res2 (line 219) | type res2 = FindSelected<
  type test2 (line 223) | type test2 = Expect<Equal<res2, Event>>;
  type res1 (line 227) | type res1 = FindSelected<
  type test1 (line 231) | type test1 = Expect<Equal<res1, number>>;
  type res2 (line 233) | type res2 = FindSelected<
  type test2 (line 237) | type test2 = Expect<Equal<res2, State>>;
  type cases (line 242) | type cases = [
  type cases (line 274) | type cases = [
  type res1 (line 302) | type res1 = FindSelected<
  type res12 (line 307) | type res12 = FindSelected<
  type x (line 312) | type x = Extract<[1, 2], readonly any[]>;
  type test1 (line 313) | type test1 = Expect<Equal<res1, { c: 3 }>>;
  type res2 (line 314) | type res2 = FindSelected<
  type test2 (line 321) | type test2 = Expect<Equal<res2, { c: 3; d: string[] }>>;
  type cases (line 327) | type cases = [
  type cases (line 343) | type cases = [
  type Input (line 411) | type Input =
  type cases (line 423) | type cases = [
  type Input (line 444) | type Input = { type: 'text'; text: string; author: { name: string } };
  type cases (line 446) | type cases = [
  type p (line 479) | type p = {
  type value (line 506) | type value = {
  type t (line 516) | type t = Expect<Equal<FindSelected<value, p>, value>>;

FILE: tests/generics.test.ts
  type State (line 13) | type State<T> =
  type t (line 22) | type t = Expect<Equal<typeof x, { t: 'success'; value: T }>>;
  type t (line 26) | type t = Expect<Equal<typeof x, { t: 'error'; error: Error }>>;
  type t (line 30) | type t = Expect<Equal<typeof x, { t: 'loading' }>>;
  type t (line 42) | type t = Expect<Equal<typeof x, a[]>>;
  type t2 (line 43) | type t2 = Expect<Equal<typeof y, a[]>>;
  type State (line 50) | type State<T> = { t: 'success'; value: T } | { t: 'error'; error: Error };
  type t (line 55) | type t = Expect<Equal<typeof x, { t: 'success'; value: a }>>;
  type t2 (line 56) | type t2 = Expect<Equal<typeof y, { t: 'success'; value: b }>>;
  type t (line 60) | type t = Expect<Equal<typeof x, { t: 'success'; value: a }>>;
  type t2 (line 61) | type t2 = Expect<Equal<typeof y, { t: 'error'; error: Error }>>;
  type t (line 65) | type t = Expect<Equal<typeof x, { t: 'error'; error: Error }>>;
  type t2 (line 66) | type t2 = Expect<Equal<typeof y, State<b>>>;
  type t (line 88) | type t = Expect<
  type t (line 97) | type t = Expect<
  type test (line 113) | type test = Expect<
  type test (line 118) | type test = Expect<
  type test (line 123) | type test = Expect<
  type test (line 135) | type test = Expect<

FILE: tests/helpers.test.ts
  type cases (line 16) | type cases = [
  type cases (line 26) | type cases = [
  type cases (line 38) | type cases = [
  type cases (line 48) | type cases = [
  type cases (line 61) | type cases = [
  class B (line 78) | class B {}
  class A (line 79) | class A extends B {}
  type t (line 80) | type t = Expect<Equal<LeastUpperBound<A | B, B>, B>>;
  type x (line 86) | type x = IntersectObjects<
  type t (line 92) | type t = Expect<
  type t2 (line 105) | type t2 = Expect<
  type t3 (line 119) | type t3 = Expect<
  type t1 (line 134) | type t1 = IsReadonlyArray<readonly []>;
  type test1 (line 135) | type test1 = Expect<Equal<t1, true>>;
  type t2 (line 136) | type t2 = IsReadonlyArray<readonly number[]>;
  type test2 (line 137) | type test2 = Expect<Equal<t2, true>>;
  type t3 (line 138) | type t3 = IsReadonlyArray<readonly [number]>;
  type test3 (line 139) | type test3 = Expect<Equal<t3, true>>;
  type t4 (line 140) | type t4 = IsReadonlyArray<readonly [number, ...(readonly any[])]>;
  type test4 (line 141) | type test4 = Expect<Equal<t4, true>>;
  type t5 (line 142) | type t5 = IsReadonlyArray<readonly [...(readonly any[]), number]>;
  type test5 (line 143) | type test5 = Expect<Equal<t5, true>>;
  type t6 (line 145) | type t6 = IsReadonlyArray<[]>;
  type test6 (line 146) | type test6 = Expect<Equal<t6, false>>;
  type t7 (line 147) | type t7 = IsReadonlyArray<number[]>;
  type test7 (line 148) | type test7 = Expect<Equal<t7, false>>;
  type t8 (line 149) | type t8 = IsReadonlyArray<[number]>;
  type test8 (line 150) | type test8 = Expect<Equal<t8, false>>;
  type t9 (line 151) | type t9 = IsReadonlyArray<[number, ...any[]]>;
  type test9 (line 152) | type test9 = Expect<Equal<t9, false>>;
  type t10 (line 153) | type t10 = IsReadonlyArray<[...any[], number]>;
  type test10 (line 154) | type test10 = Expect<Equal<t10, false>>;

FILE: tests/infer.test.ts
  type QuizValue (line 13) | type QuizValue = P.infer<typeof QuizValue>;
  type expected1 (line 14) | type expected1 = 'initial' | 'correct' | 'incorrect';
  type test1 (line 15) | type test1 = Expect<Equal<QuizValue, expected1>>;
  type QuizState (line 17) | type QuizState = P.infer<typeof QuizState>;
  type expected2 (line 18) | type expected2 = {
  type test2 (line 22) | type test2 = Expect<Equal<QuizState, expected2>>;

FILE: tests/instance-of.test.ts
  class A (line 4) | class A {
  class B (line 7) | class B {
  type t (line 16) | type t = Expect<Equal<typeof x, A>>;
  type t (line 20) | type t = Expect<Equal<typeof x, B>>;
  type Input (line 30) | type Input = { value: A | B };
  type t (line 36) | type t = Expect<Equal<typeof a, { value: A }>>;
  type t (line 40) | type t = Expect<Equal<typeof b, { value: B }>>;
  class FooError (line 49) | class FooError extends Error {
    method constructor (line 50) | constructor(public foo: string) {
  class BazError (line 55) | class BazError extends Error {
    method constructor (line 56) | constructor(public baz: string) {
  type Input (line 61) | type Input = FooError | BazError | Error;
  class A (line 76) | class A extends Abstract {}
  class B (line 77) | class B extends Abstract {}
  type t (line 82) | type t = Expect<Equal<typeof x, A | B>>;

FILE: tests/intersection-and-union.test.ts
  type A (line 5) | type A = {
    method constructor (line 730) | constructor(public foo: 'bar' | 'baz') {}
  type B (line 13) | type B = {
    method constructor (line 734) | constructor(public str: string) {}
  type Input (line 21) | type Input = A | B;
  class Child1 (line 25) | class Child1 extends Parent {
    method constructor (line 26) | constructor(public a?: Parent, public b?: Parent) {
  class Child2 (line 31) | class Child2 extends Parent {
    method constructor (line 32) | constructor(public a?: Parent, public b?: Parent) {
  type t (line 49) | type t = Expect<
  type t (line 68) | type t = Expect<
  type t (line 87) | type t = Expect<Equal<typeof x, A>>;
  type C (line 95) | type C = {
  type Input (line 103) | type Input =
  type t (line 111) | type t = Expect<
  type t (line 120) | type t = Expect<Equal<typeof x, C>>;
  type t (line 128) | type t = Expect<
  type t (line 137) | type t = Expect<
  type t (line 151) | type t = Expect<
  type Country (line 166) | type Country = 'France' | 'Germany' | 'Spain' | 'USA';
  type t (line 190) | type t = Expect<
  type t (line 231) | type t = Expect<
  type t (line 244) | type t = Expect<
  type t (line 294) | type t = Expect<Equal<typeof x, number>>;
  type t (line 314) | type t = Expect<Equal<typeof x, number>>;
  type t (line 337) | type t = Expect<Equal<typeof x, number>>;
  type Input (line 350) | type Input = {
  type t (line 366) | type t = Expect<
  type Input (line 384) | type Input = {
  type t (line 400) | type t = Expect<
  type t (line 417) | type t = Expect<Equal<typeof x, number | undefined>>;
  type Input (line 438) | type Input = {
  type t (line 447) | type t = Expect<
  type t (line 453) | type t = Expect<
  type Input (line 469) | type Input = {
  type t (line 479) | type t = Expect<
  type t (line 495) | type t = Expect<
  type Input (line 532) | type Input = {
  type t (line 542) | type t = Expect<
  type t (line 557) | type t = Expect<
  type Input (line 593) | type Input =
  type t (line 614) | type t = Expect<
  type t (line 639) | type t = Expect<
  type Input (line 672) | type Input = {
  type t (line 683) | type t = Expect<
  type t (line 698) | type t = Expect<
  type t (line 719) | type t = Expect<
  class A (line 729) | class A {
    method constructor (line 730) | constructor(public foo: 'bar' | 'baz') {}
  class B (line 733) | class B {
    method constructor (line 734) | constructor(public str: string) {}
  type t (line 743) | type t = Expect<Equal<typeof prop, A & { foo: 'bar' }>>;
  type t (line 751) | type t = Expect<Equal<typeof prop, A & { foo: 'baz' }>>;
  type t (line 759) | type t = Expect<Equal<typeof prop, B>>;

FILE: tests/invert-pattern.test.ts
  type pattern1 (line 11) | type pattern1 = [
  type inverted1 (line 15) | type inverted1 = InvertPattern<pattern1, unknown>;
  type test1 (line 17) | type test1 = Expect<Equal<inverted1, ['Hello', ...number[]]>>;
  type pattern2 (line 19) | type pattern2 = [
  type inverted2 (line 23) | type inverted2 = InvertPattern<pattern2, unknown>;
  type test2 (line 25) | type test2 = Expect<Equal<inverted2, [unknown, ...unknown[]]>>;
  type pattern3 (line 27) | type pattern3 = [
  type inverted3 (line 31) | type inverted3 = InvertPattern<pattern3, unknown>;
  type test3 (line 33) | type test3 = Expect<Equal<inverted3, [string, ...number[]]>>;
  type pattern6 (line 35) | type pattern6 = {
  type input6 (line 41) | type input6 = unknown;
  type inverted6 (line 42) | type inverted6 = InvertPattern<pattern6, input6>;
  type test6 (line 44) | type test6 = Expect<Equal<inverted6, { key: [string, ...string[]] }>>;
  type pattern1 (line 48) | type pattern1 = [
  type inverted1 (line 53) | type inverted1 = InvertPattern<pattern1, unknown>;
  type test1 (line 55) | type test1 = Expect<Equal<inverted1, ['Hello', 7, ...number[]]>>;
  type pattern2 (line 57) | type pattern2 = [
  type inverted2 (line 62) | type inverted2 = InvertPattern<pattern2, unknown>;
  type test2 (line 64) | type test2 = Expect<Equal<inverted2, [unknown, unknown, ...unknown[]]>>;
  type pattern3 (line 66) | type pattern3 = [
  type inverted3 (line 71) | type inverted3 = InvertPattern<pattern3, unknown>;
  type test3 (line 73) | type test3 = Expect<Equal<inverted3, [string, boolean, ...number[]]>>;
  type pattern1 (line 76) | type pattern1 = [
  type inverted1 (line 80) | type inverted1 = InvertPattern<pattern1, unknown>;
  type test1 (line 82) | type test1 = Expect<Equal<inverted1, [...number[], 'Hello']>>;
  type pattern2 (line 84) | type pattern2 = [
  type inverted2 (line 88) | type inverted2 = InvertPattern<pattern2, unknown>;
  type test2 (line 90) | type test2 = Expect<Equal<inverted2, [...unknown[], unknown]>>;
  type pattern3 (line 92) | type pattern3 = [
  type inverted3 (line 96) | type inverted3 = InvertPattern<pattern3, unknown>;
  type test3 (line 98) | type test3 = Expect<Equal<inverted3, [...number[], string]>>;
  type pattern1 (line 101) | type pattern1 = [
  type inverted1 (line 106) | type inverted1 = InvertPattern<pattern1, unknown>;
  type test1 (line 108) | type test1 = Expect<Equal<inverted1, [...number[], 'Hello', 7]>>;
  type pattern2 (line 110) | type pattern2 = [
  type inverted2 (line 115) | type inverted2 = InvertPattern<pattern2, unknown>;
  type test2 (line 117) | type test2 = Expect<Equal<inverted2, [...unknown[], unknown, unknown]>>;
  type pattern3 (line 119) | type pattern3 = [
  type inverted3 (line 124) | type inverted3 = InvertPattern<pattern3, unknown>;
  type test3 (line 126) | type test3 = Expect<Equal<inverted3, [...number[], string, boolean]>>;
  type pattern1 (line 129) | type pattern1 = [
  type inverted1 (line 134) | type inverted1 = InvertPattern<pattern1, unknown>;
  type test1 (line 136) | type test1 = Expect<Equal<inverted1, [7, ...number[], 'Hello']>>;
  type pattern2 (line 138) | type pattern2 = [
  type inverted2 (line 143) | type inverted2 = InvertPattern<pattern2, unknown>;
  type test2 (line 145) | type test2 = Expect<Equal<inverted2, [unknown, ...unknown[], unknown]>>;
  type pattern3 (line 147) | type pattern3 = [
  type inverted3 (line 152) | type inverted3 = InvertPattern<pattern3, unknown>;
  type test3 (line 154) | type test3 = Expect<Equal<inverted3, [string, ...number[], boolean]>>;
  type pattern1 (line 158) | type pattern1 = [
  type inverted1 (line 165) | type inverted1 = InvertPattern<pattern1, undefined>;
  type test1 (line 167) | type test1 = Expect<
  type pattern2 (line 171) | type pattern2 = [
  type inverted2 (line 178) | type inverted2 = InvertPattern<pattern2, undefined>;
  type test2 (line 180) | type test2 = Expect<
  type pattern3 (line 184) | type pattern3 = [
  type inverted3 (line 191) | type inverted3 = InvertPattern<pattern3, undefined>;
  type test3 (line 193) | type test3 = Expect<
  type cases (line 202) | type cases = [
  type res1 (line 229) | type res1 = InvertPatternForExclude<
  type test1 (line 233) | type test1 = Expect<Equal<res1, Readonly<{ a: string }>>>;
  type res1 (line 238) | type res1 = InvertPatternForExclude<
  type test1 (line 242) | type test1 = Expect<Equal<res1, [1, 2]>>;
  type res1 (line 246) | type res1 = InvertPatternForExclude<
  type test1 (line 250) | type test1 = Expect<Equal<res1, readonly [[readonly [1, 2]]]>>;
  type OptionalPattern (line 255) | type OptionalPattern<a> = Matcher<unknown, a, 'optional'>;
  type input (line 258) | type input = { key?: 'a' | 'b' };
  type pattern (line 259) | type pattern = { key: OptionalPattern<'a'> };
  type inverted (line 260) | type inverted = InvertPatternForExclude<pattern, input>;
  type cases (line 262) | type cases = [
  type x (line 274) | type x = InvertPatternForExclude<
  type cases (line 278) | type cases = [
  type input (line 284) | type input = { key?: 'a' | 'b' };
  type pattern (line 285) | type pattern = { key: OptionalPattern<'a'> };
  type inverted (line 286) | type inverted = InvertPatternForExclude<pattern, input>;
  type cases (line 288) | type cases = [
  type pattern1 (line 303) | type pattern1 = ['Hello', ...Matcher<any, GuardP<unknown, 2>, 'array'>[]];
  type input1 (line 304) | type input1 = { a: string; b: number } | [string, ...number[]];
  type inverted1 (line 305) | type inverted1 = InvertPatternForExclude<pattern1, input1>;
  type test1 (line 306) | type test1 = Expect<Equal<inverted1, ['Hello', ...2[]]>>;
  type pattern2 (line 308) | type pattern2 = ['Hello', ...Matcher<any, GuardP<unknown, 2>, 'array'>[]];
  type input2 (line 309) | type input2 = [string, ...number[]];
  type inverted2 (line 310) | type inverted2 = InvertPatternForExclude<pattern2, input2>;
  type test2 (line 311) | type test2 = Expect<Equal<inverted2, ['Hello', ...2[]]>>;
  type pattern3 (line 313) | type pattern3 = [...Matcher<any, GuardP<unknown, 2>, 'array'>[]];
  type input3 (line 314) | type input3 = [...number[]];
  type inverted3 (line 315) | type inverted3 = InvertPatternForExclude<pattern3, input3>;
  type test3 (line 316) | type test3 = Expect<Equal<inverted3, [...2[]]>>;
  type pattern4 (line 318) | type pattern4 = readonly [
  type input4 (line 322) | type input4 = [string | number, ...(string | number)[]];
  type inverted4 (line 323) | type inverted4 = InvertPatternForExclude<pattern4, input4>;
  type test4 (line 325) | type test4 = Expect<Equal<inverted4, [unknown, ...(string | number)[]]>>;
  type pattern5 (line 327) | type pattern5 = ArrayP<unknown, unknown>;
  type input5 (line 328) | type input5 = (string | number)[];
  type inverted5 (line 329) | type inverted5 = InvertPatternForExclude<pattern5, input5>;
  type test5 (line 330) | type test5 = Expect<Equal<inverted5, (string | number)[]>>;
  type pattern1 (line 334) | type pattern1 = [
  type input1 (line 339) | type input1 = { a: string; b: number } | [string, number, ...number[]];
  type inverted1 (line 340) | type inverted1 = InvertPatternForExclude<pattern1, input1>;
  type test1 (line 341) | type test1 = Expect<Equal<inverted1, ['Hello', 10, ...2[]]>>;
  type pattern1 (line 344) | type pattern1 = [
  type input1 (line 348) | type input1 = { a: string; b: number } | [...number[], string];
  type inverted1 (line 349) | type inverted1 = InvertPatternForExclude<pattern1, input1>;
  type test1 (line 350) | type test1 = Expect<Equal<inverted1, [...number[], 'Hello']>>;
  type pattern1 (line 353) | type pattern1 = [
  type input1 (line 358) | type input1 = { a: string; b: number } | [...number[], string, boolean];
  type inverted1 (line 359) | type inverted1 = InvertPatternForExclude<pattern1, input1>;
  type test1 (line 360) | type test1 = Expect<Equal<inverted1, [...number[], 'Hello', true]>>;
  type pattern1 (line 363) | type pattern1 = [
  type input1 (line 368) | type input1 = { a: string; b: number } | [string, ...number[], boolean];
  type inverted1 (line 369) | type inverted1 = InvertPatternForExclude<pattern1, input1>;
  type test1 (line 370) | type test1 = Expect<Equal<inverted1, ['Hello', ...number[], true]>>;
  type input (line 377) | type input = { sex: 'a' | 'b'; age: 'c' | 'd' };
  type pattern (line 378) | type pattern = Readonly<{ sex: 'a'; unknownKey: 'c' }>;
  type inverted (line 379) | type inverted = InvertPatternForExclude<pattern, input>;
  type cases (line 381) | type cases = [Expect<Equal<inverted, pattern>>];
  type input (line 387) | type input = { sex: 'a' | 'b'; age: 'c' | 'd' };
  type pattern (line 388) | type pattern = Pattern<input>;
  type inverted (line 389) | type inverted = InvertPattern<pattern, input>;
  type test1 (line 391) | type test1 = Expect<Equal<inverted, never>>;
  type input (line 395) | type input = { sex: 'a' | 'b'; age: 'c' | 'd' };
  type pattern (line 396) | type pattern = Pattern<input>;
  type inverted (line 397) | type inverted = InvertPatternForExclude<pattern, input>;
  type test1 (line 399) | type test1 = Expect<Equal<inverted, never>>;

FILE: tests/is-matching.test.ts
  type t (line 17) | type t = Expect<
  type t (line 46) | type t = Expect<
  type Pizza (line 101) | type Pizza = { type: 'pizza'; topping: string };
  type Sandwich (line 102) | type Sandwich = { type: 'sandwich'; condiments: string[] };
  type Food (line 103) | type Food = Pizza | Sandwich;
  type t (line 111) | type t = Expect<Equal<typeof food, Pizza>>;
  type t (line 117) | type t = Expect<Equal<typeof food, Pizza>>;
  type t (line 140) | type t = Expect<
  type t (line 152) | type t = Expect<Equal<typeof food, Food & { unknownProp: Error }>>;
  type Input (line 157) | type Input = { someProperty: string[] } | { this: 'is a string' };
  type t (line 162) | type t = Expect<Equal<typeof input.someProperty, string[]>>;

FILE: tests/large-exhaustive.test.ts
  type LargeObject (line 6) | type LargeObject<T> = Compute<{
  type test1 (line 80) | type test1 = Expect<Not<Equal<typeof x, never>>>;
  type test2 (line 81) | type test2 = Expect<Not<Equal<typeof x, unknown>>>;
  type test3 (line 82) | type test3 = Expect<Not<Equal<typeof x, any>>>;
  type DeepObject (line 123) | type DeepObject = {
  type States (line 156) | type States = 'idle' | 'loading' | 'success' | 'error' | 'partial_result';
  type input (line 170) | type input = typeof input;

FILE: tests/lists.test.ts
  type t (line 13) | type t = Expect<Equal<typeof x, []>>;
  type t (line 17) | type t = Expect<Equal<typeof blogs, { id: number; title: string }[]>>;
  type t (line 24) | type t = Expect<Equal<typeof x, 20>>;
  type Input (line 44) | type Input = readonly {
  type t (line 69) | type t = Expect<

FILE: tests/maps.test.ts
  type t (line 21) | type t = Expect<Equal<typeof res, { name: string }>>;
  type t (line 35) | type t = Expect<Equal<typeof res, boolean>>;

FILE: tests/matcher-protocol.test.ts
  type SomeValue (line 5) | type SomeValue<T> = T extends Some<infer V> ? V : never;
  type SomeNarrowFn (line 7) | interface SomeNarrowFn extends P.unstable_Fn {
  class Some (line 11) | class Some<const T> {
    method constructor (line 12) | constructor(public value: T) {}
  method [P.matcher] (line 14) | static [P.matcher](): P.unstable_Matcher<SomeNarrowFn> {
  method [P.matcher] (line 22) | [P.matcher](): P.unstable_Matcher<
  class None (line 37) | class None {
    method constructor (line 39) | constructor() {
  method [P.matcher] (line 42) | static [P.matcher](): P.unstable_Matcher<None> {
  type Option (line 50) | type Option<T> = Some<T> | None;
  type t (line 57) | type t = Expect<Equal<typeof value, { option: Some<7> }>>;
  type t (line 61) | type t = Expect<Equal<typeof value, { option: Some<12> }>>;
  type t (line 73) | type t = Expect<Equal<typeof some, Some<number>>>;
  type t (line 83) | type t = Expect<Equal<typeof x, { option: Some<number | string> }>>;
  type t (line 87) | type t = Expect<Equal<typeof x, { option: None }>>;
  type t (line 99) | type t = Expect<Equal<typeof some, Some<10>>>;
  type t (line 111) | type t = Expect<Equal<typeof some, Some<number>>>;
  type t (line 117) | type t = Expect<Equal<typeof some, Some<number | string>>>;
  type t (line 120) | type t = Expect<Equal<typeof none, None>>;

FILE: tests/multiple-patterns.test.ts
  type t (line 14) | type t = Expect<
  type t (line 26) | type t = Expect<
  type t (line 54) | type t = Expect<
  type t (line 66) | type t = Expect<
  type Country (line 94) | type Country = 'France' | 'Germany' | 'Spain' | 'USA';
  type Input (line 126) | type Input =
  type t (line 140) | type t = Expect<Equal<typeof x, null | undefined>>;
  type t (line 144) | type t = Expect<Equal<typeof x, boolean | number | string>>;
  type t (line 153) | type t = Expect<
  type t (line 167) | type t = Expect<Equal<typeof x, [false, 2]>>;
  type t (line 171) | type t = Expect<Equal<typeof x, [false, number]>>;
  type t (line 175) | type t = Expect<Equal<typeof x, [true, number]>>;
  type t (line 230) | type t = Expect<Equal<typeof arr, number[]>>;
  type t (line 236) | type t = Expect<Equal<typeof arr, number[]>>;
  type t (line 242) | type t = Expect<Equal<typeof arr, number[]>>;

FILE: tests/narrow.test.ts
  type Input (line 6) | type Input = ['a' | 'b' | 'c', 'a' | 'b' | 'c'];
  type Narrowed (line 9) | type Narrowed = P.narrow<Input, typeof Pattern>;
  type test (line 11) | type test = Expect<Equal<Narrowed, ['a', 'a' | 'b']>>;
  type test (line 22) | type test = Expect<Equal<typeof prop, string>>;
  type test (line 33) | type test = Expect<Equal<typeof prop, 1 | 3>>;

FILE: tests/nesting.test.ts
  type Post (line 7) | type Post = {
  type Video (line 12) | type Video = { type: 'video'; id: number; content: { src: string } };
  type t (line 25) | type t = Expect<
  type t (line 50) | type t = Expect<Equal<typeof res, number>>;

FILE: tests/not.test.ts
  type t (line 10) | type t = Expect<Equal<typeof x, unknown>>;
  type t (line 14) | type t = Expect<Equal<typeof x, unknown>>;
  type DS (line 24) | type DS = { x: string | number; y: string | number };
  type t (line 28) | type t = Expect<Equal<typeof x, { x: number; y: number }>>;
  type t (line 45) | type t = Expect<Equal<typeof x, 'two'>>;
  type t (line 49) | type t = Expect<Equal<typeof x, 'one'>>;
  type t (line 65) | type t = Expect<Equal<typeof x, { key: 'two' }>>;
  type t (line 69) | type t = Expect<Equal<typeof x, { key: 'one' }>>;
  type Input (line 79) | type Input =
  type t (line 88) | type t = Expect<Equal<typeof x, { type: 'error' }>>;
  type t (line 92) | type t = Expect<Equal<typeof x, { type: 'success' }>>;
  type t (line 129) | type t = Expect<Equal<typeof str, string>>;
  type t (line 134) | type t = Expect<Equal<typeof str, null | undefined>>;
  type t (line 146) | type t = Expect<Equal<typeof x, { str: any }>>;
  type t (line 168) | type t = Expect<
  type Input (line 200) | type Input =
  type Input (line 236) | type Input =

FILE: tests/numbers.test.ts
  type t (line 8) | type t = Expect<Equal<typeof v, 1>>;
  type t (line 12) | type t = Expect<Equal<typeof v, 2>>;
  type t (line 17) | type t = Expect<Equal<typeof res, number>>;
  type t (line 64) | type t = Expect<Equal<typeof value, number>>;
  type t (line 68) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 82) | type t = Expect<Equal<typeof value, number>>;
  type t (line 86) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 98) | type t = Expect<Equal<typeof value, number>>;
  type t (line 102) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 114) | type t = Expect<Equal<typeof value, number>>;
  type t (line 118) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 130) | type t = Expect<Equal<typeof value, number>>;
  type t (line 134) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 146) | type t = Expect<Equal<typeof value, number>>;
  type t (line 150) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 162) | type t = Expect<Equal<typeof value, number>>;
  type t (line 166) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 178) | type t = Expect<Equal<typeof value, number>>;
  type t (line 182) | type t = Expect<Equal<typeof value, string | number | bigint>>;
  type t (line 195) | type t = Expect<Equal<typeof value, number>>;
  type t (line 199) | type t = Expect<Equal<typeof value, string | number | bigint>>;

FILE: tests/objects.test.ts
  type Input (line 9) | type Input = { [symbolA]: { [symbolB]: 'foo' | 'bar' } };
  type t (line 15) | type t = Expect<Equal<typeof value, 'foo'>>;
  type t (line 24) | type t = Expect<Equal<typeof value, 'bar'>>;
  type t (line 42) | type t = Expect<Equal<typeof sel, { [symbolB]: 'foo' | 'bar' }>>;
  type t (line 55) | type t = Expect<Equal<typeof sel, Input>>;
  type t (line 69) | type t = Expect<Equal<typeof sel, Input>>;
  type t (line 80) | type t = Expect<Equal<typeof sel, Input>>;
  type Vector1 (line 93) | type Vector1 = { x: number };
  type Vector2 (line 94) | type Vector2 = { x: number; y: number };
  type Vector3 (line 95) | type Vector3 = {
  type Vector (line 100) | type Vector = Vector1 | Vector2 | Vector3;
  type t (line 107) | type t = Expect<Equal<typeof x, { x: 1; y: 1; z: 1 }>>;
  type t (line 111) | type t = Expect<
  type t (line 117) | type t = Expect<

FILE: tests/optional-props.test.ts
  type Post (line 6) | type Post = {
  type t (line 18) | type t = Expect<Equal<typeof x, { type: 'post'; id: 2; body: string }>>;
  type t (line 22) | type t = Expect<
  type t (line 28) | type t = Expect<Equal<typeof x, Post>>;
  type Foo (line 39) | type Foo =
  type t (line 47) | type t = Expect<Equal<typeof id, string>>;
  type t (line 52) | type t = Expect<Equal<typeof id, string | undefined>>;
  type t (line 57) | type t = Expect<Equal<typeof id, string | undefined>>;
  type t (line 61) | type t = Expect<Equal<typeof id, string | undefined>>;
  type SomeEnum (line 73) | enum SomeEnum {
  type SomeObject (line 78) | type SomeObject = {
  type t (line 91) | type t = Expect<

FILE: tests/optional.test.ts
  type Input (line 6) | type Input = { a?: 'cool' } | { b: 'lol' };
  type t (line 14) | type t = Expect<Equal<typeof x, { a?: 'cool' | undefined }>>;
  type Input (line 25) | type Input = { a?: { name: string; age: number } } | { b: '' };
  type t (line 30) | type t = Expect<
  type Input (line 48) | type Input =
  type t (line 57) | type t = Expect<Equal<typeof x, string | undefined>>;
  type t (line 63) | type t = Expect<
  type t (line 72) | type t = Expect<Equal<typeof x, 'test' | undefined>>;
  type t (line 78) | type t = Expect<
  type t (line 96) | type t = Expect<Equal<typeof x, string | undefined>>;
  type t (line 100) | type t = Expect<Equal<typeof x, 'test' | undefined>>;
  type Input (line 110) | type Input = { a?: { name: string; age: number } } | { b: 'b' };
  type t1 (line 119) | type t1 = Expect<Equal<typeof name, string | undefined>>;
  type t2 (line 120) | type t2 = Expect<Equal<typeof age, number | undefined>>;
  type Input (line 132) | type Input =
  type t (line 150) | type t = Expect<
  type t (line 166) | type t = Expect<Equal<typeof x, { p: string | undefined }>>;
  type t (line 176) | type t = Expect<Equal<typeof src, number | undefined>>;
  type t (line 186) | type t = Expect<Equal<typeof p, string | undefined>>;
  type Input (line 195) | type Input = { maybeList?: { text: string }[] };
  type t (line 200) | type t = Expect<Equal<typeof x, string[] | undefined>>;

FILE: tests/output-type.test.ts
  type o1 (line 15) | type o1 = Expect<Equal<ReturnType<typeof f>, string>>;
  type o2 (line 24) | type o2 = Expect<Equal<ReturnType<typeof f2>, { x: string }>>;
  type o3 (line 33) | type o3 = Expect<Equal<ReturnType<typeof f3>, (number | null)[]>>;
  type o1 (line 43) | type o1 = Expect<Equal<ReturnType<typeof f1>, (number | null)[]>>;
  type o1 (line 56) | type o1 = Expect<Equal<ReturnType<typeof f1>, State>>;
  type o1 (line 69) | type o1 = Expect<Equal<ReturnType<typeof f>, string>>;
  type o2 (line 78) | type o2 = Expect<Equal<ReturnType<typeof f2>, { x: string }>>;
  type o3 (line 87) | type o3 = Expect<Equal<ReturnType<typeof f3>, (number | null)[]>>;
  type o1 (line 97) | type o1 = Expect<Equal<ReturnType<typeof f1>, (number | null)[]>>;
  type o1 (line 110) | type o1 = Expect<Equal<ReturnType<typeof f1>, State>>;
  type o1 (line 123) | type o1 = Expect<Equal<ReturnType<typeof f>, string>>;
  type o2 (line 132) | type o2 = Expect<Equal<ReturnType<typeof f2>, { x: string }>>;
  type o3 (line 141) | type o3 = Expect<Equal<ReturnType<typeof f3>, (number | null)[]>>;
  type o1 (line 151) | type o1 = Expect<Equal<ReturnType<typeof f1>, (number | null)[]>>;
  type o1 (line 164) | type o1 = Expect<Equal<ReturnType<typeof f1>, State>>;

FILE: tests/pattern.test.ts
  type ExtendsPattern (line 5) | type ExtendsPattern<a, p extends P.Pattern<a>> = true;
  type cases (line 9) | type cases = [
  type res1 (line 18) | type res1 = P.Pattern<{ kind: 'some'; value: number } | { kind: 'none' }>;
  type test1 (line 20) | type test1 = Expect<
  type t (line 39) | type t = P.Pattern<
  type t1 (line 43) | type t1 = Expect<
  type t2 (line 61) | type t2 = Expect<
  type t3 (line 77) | type t3 = Expect<
  type res4 (line 95) | type res4 = P.Pattern<{ name: string; age: number } | [type: 'Hello']>;
  type t4 (line 97) | type t4 = Expect<

FILE: tests/primitive-values.test.ts
  type t (line 11) | type t = Expect<Equal<typeof x, true>>;
  type t (line 15) | type t = Expect<Equal<typeof x, false>>;
  type t (line 19) | type t = Expect<Equal<typeof x, null>>;
  type t (line 23) | type t = Expect<Equal<typeof x, undefined>>;
  type t (line 27) | type t = Expect<Equal<typeof x, symbol>>;
  type t (line 31) | type t = Expect<Equal<typeof x, 'hello'>>;
  type t (line 35) | type t = Expect<Equal<typeof x, 1>>;
  type t (line 39) | type t = Expect<Equal<typeof x, bigint>>;
  type t (line 43) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 54) | type t = Expect<Equal<typeof x, boolean>>;
  type t (line 58) | type t = Expect<Equal<typeof x, null | undefined>>;
  type t (line 62) | type t = Expect<Equal<typeof x, symbol>>;
  type t (line 66) | type t = Expect<Equal<typeof x, string>>;
  type t (line 70) | type t = Expect<Equal<typeof x, number>>;
  type t (line 74) | type t = Expect<Equal<typeof x, bigint>>;

FILE: tests/readonly.test.ts
  type t (line 10) | type t = Expect<Equal<typeof x, readonly ['a', 'c']>>;
  type t (line 14) | type t = Expect<Equal<typeof x, readonly ['a', 'd']>>;
  type t (line 18) | type t = Expect<Equal<typeof x, readonly ['b', 'c']>>;
  type t (line 22) | type t = Expect<Equal<typeof x, readonly ['b', 'd']>>;
  type t (line 34) | type t = Expect<Equal<typeof x, Readonly<{ t: 'a'; x: number }>>>;
  type t (line 38) | type t = Expect<Equal<typeof x, Readonly<{ t: 'b'; x: string }>>>;
  type t (line 52) | type t = Expect<Equal<typeof x, { t: 'a'; x: [2, 'hello', 2] }>>;
  type t (line 56) | type t = Expect<Equal<typeof x, { t: 'a'; x: [2, 'hello', 2] }>>;
  type t (line 60) | type t = Expect<
  type t (line 69) | type t = Expect<Equal<typeof x, Readonly<{ t: 'b'; x: string }>>>;
  type t (line 79) | type t = Expect<Equal<typeof x, readonly []>>;

FILE: tests/real-world.test.ts
  type t (line 18) | type t = Expect<
  type t (line 33) | type t = Expect<Equal<typeof q, string>>;
  type t (line 55) | type t = Expect<Equal<typeof format, 'timeseries' | 'scalar'>>;
  type t2 (line 56) | type t2 = Expect<Equal<typeof dataSource, 'metrics' | 'events'>>;

FILE: tests/record.test.ts
  type t (line 87) | type t = Expect<
  type t (line 109) | type t = Expect<
  type Data (line 158) | type Data = {
  type t (line 168) | type t = Expect<Equal<typeof x, Data>>;
  type t (line 186) | type t = Expect<Equal<typeof value, Record<number, string>>>;
  type t (line 198) | type t = Expect<Equal<typeof value, { readonly a: 1 }>>;
  type OptionalRecord (line 206) | type OptionalRecord = {
  type t (line 218) | type t = Expect<
  type t (line 247) | type t = Expect<
  type t (line 270) | type t = Expect<Equal<typeof value, Record<symbol, number>>>;
  type Input (line 280) | type Input = { key?: Record<string, number> };
  type t (line 286) | type t = Expect<
  type t (line 302) | type t = Expect<Equal<typeof value, Record<number, string>>>;
  type t (line 313) | type t = Expect<Equal<typeof value, Record<1, string>>>;
  type t (line 324) | type t = Expect<Equal<typeof value, Record<1 | 2, string>>>;
  type t (line 335) | type t = Expect<Equal<typeof value, Record<string, string>>>;
  type t (line 348) | type t = Expect<Equal<typeof value, string[]>>;
  type t (line 360) | type t = Expect<Equal<typeof value, number[]>>;
  type t (line 377) | type t = Expect<Equal<typeof value, string[]>>;
  type t (line 405) | type t = Expect<Equal<typeof value, Record<string, 1 | 2>>>;
  type t (line 410) | type t = Expect<Equal<typeof value, Record<string, 1 | 2> | 123>>;
  type t (line 415) | type t = Expect<
  type t (line 422) | type t = Expect<Equal<typeof value, Record<number, number>>>;
  type t (line 426) | type t = Expect<Equal<typeof value, Record<1 | 2 | 3, number>>>;
  type t (line 431) | type t = Expect<Equal<typeof value, number[]>>;
  type t (line 436) | type t = Expect<Equal<typeof value, number[]>>;
  type t (line 441) | type t = Expect<
  type t (line 450) | type t = Expect<Equal<typeof value, number[][]>>;
  type t (line 456) | type t = Expect<
  type t (line 463) | type t = Expect<Equal<typeof value, Record<string, number>[]>>;
  type t (line 468) | type t = Expect<Equal<typeof value, Record<string, number[]>>>;
  type t (line 473) | type t = Expect<
  type Input (line 527) | type Input =
  type ComplexInput (line 564) | type ComplexInput =

FILE: tests/select.test.ts
  type t (line 14) | type t = Expect<Equal<typeof y, number>>;
  type t (line 25) | type t = Expect<Equal<typeof xs, [string]>>;
  type t2 (line 26) | type t2 = Expect<Equal<typeof first, string>>;
  type t (line 30) | type t = Expect<Equal<typeof xs, string[]>>;
  type t2 (line 31) | type t2 = Expect<Equal<typeof texts, string[]>>;
  type t (line 40) | type t = Expect<Equal<typeof xs, { text: string }[]>>;
  type t2 (line 41) | type t2 = Expect<Equal<typeof texts, string[]>>;
  type t (line 55) | type t = Expect<Equal<typeof texts, string[]>>;
  type t (line 77) | type t = Expect<Equal<typeof data, string>>;
  type t2 (line 78) | type t2 = Expect<Equal<typeof other, number>>;
  type t (line 90) | type t = Expect<Equal<typeof x, string>>;
  type t (line 114) | type t = Expect<Equal<typeof time, number | undefined>>;
  type t (line 141) | type t = Expect<Equal<typeof state, State>>;
  type t2 (line 142) | type t2 = Expect<Equal<typeof event, Event>>;
  type Input (line 166) | type Input = [{ name: string }, { post: { title: string }[] }][];
  type t (line 176) | type t = Expect<Equal<typeof x, []>>;
  type t (line 185) | type t = Expect<Equal<typeof names, string[]>>;
  type t2 (line 186) | type t2 = Expect<Equal<typeof titles, string[][]>>;
  type Input (line 202) | type Input = [{ name: string }, { post: { title: string }[] }][];
  type t (line 212) | type t = Expect<Equal<typeof x, []>>;
  type t1 (line 218) | type t1 = Expect<Equal<typeof titles, string[][]>>;
  type t (line 231) | type t = Expect<Equal<typeof x, SeveralAnonymousSelectError>>;
  type t (line 240) | type t = Expect<Equal<typeof x, MixedNamedAndAnonymousSelectError>>;
  type Input (line 247) | type Input =
  type t (line 265) | type t = Expect<Equal<typeof x, { type: 'img'; src: string }>>;
  type t (line 271) | type t = Expect<
  type t (line 281) | type t = Expect<
  type t (line 287) | type t = Expect<
  type t1 (line 330) | type t1 = Expect<
  type t2 (line 336) | type t2 = Expect<Equal<typeof content, string>>;
  type t3 (line 337) | type t3 = Expect<Equal<typeof length, number>>;
  type Input (line 351) | type Input = {
  type t (line 364) | type t = Expect<
  type t (line 381) | type t = Expect<
  type Input (line 404) | type Input =
  type t (line 426) | type t = Expect<Equal<typeof x, boolean | string[]>>;
  type t (line 440) | type t = Expect<Equal<typeof a, string[]>>;
  type t2 (line 441) | type t2 = Expect<Equal<typeof b, string[]>>;
  type t (line 452) | type t = Expect<Equal<typeof a, number[]>>;
  type t (line 462) | type t = Expect<Equal<typeof a, { prop: number }[]>>;
  type t (line 476) | type t = Expect<Equal<typeof arg, string>>;

FILE: tests/sets.test.ts
  type t (line 9) | type t = Expect<Equal<typeof x, Set<'gab'>>>;
  type t (line 13) | type t = Expect<Equal<typeof x, Set<'yo'>>>;
  type t (line 17) | type t = Expect<Equal<typeof x, Set<'gab' | 'yo'>>>;
  type t (line 21) | type t = Expect<Equal<typeof x, Set<string | number>>>;
  type t (line 40) | type t = Expect<Equal<typeof res, boolean>>;

FILE: tests/strings.test.ts
  type t (line 9) | type t = Expect<Equal<typeof value, string>>;
  type t (line 13) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 26) | type t = Expect<Equal<typeof value, `hello ${string}`>>;
  type t (line 30) | type t = Expect<Equal<typeof value, string | number>>;
  type FileFrom2022 (line 38) | type FileFrom2022 = `2022-${number}-${number}`;
  type FileFrom2023 (line 39) | type FileFrom2023 = `2023-${number}-${number}`;
  type t (line 45) | type t = Expect<Equal<typeof x, FileFrom2022>>;
  type t (line 49) | type t = Expect<Equal<typeof x, FileFrom2023>>;
  type Input (line 59) | type Input = { value: FileFrom2022 | FileFrom2023 };
  type t (line 65) | type t = Expect<Equal<typeof a, { value: FileFrom2022 }>>;
  type t (line 69) | type t = Expect<Equal<typeof b, { value: FileFrom2023 }>>;
  type t (line 82) | type t = Expect<Equal<typeof value, `${string}!!`>>;
  type t (line 86) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 98) | type t = Expect<Equal<typeof value, string>>;
  type t (line 102) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 115) | type t = Expect<Equal<typeof value, string>>;
  type t (line 119) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 131) | type t = Expect<Equal<typeof value, string>>;
  type t (line 142) | type t = Expect<Equal<typeof value, string>>;
  type t (line 146) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 159) | type t = Expect<Equal<typeof value, string>>;
  type t (line 163) | type t = Expect<Equal<typeof value, string | number>>;
  type t (line 175) | type t = Expect<Equal<typeof value, string>>;
  type t (line 179) | type t = Expect<Equal<typeof value, string | number>>;

FILE: tests/tuples.test.ts
  type Input (line 22) | type Input =
  type t (line 30) | type t = Expect<Equal<typeof value, ['+', number, number]>>;
  type t (line 35) | type t = Expect<Equal<typeof value, ['*', number, number]>>;
  type t (line 40) | type t = Expect<Equal<typeof value, ['-', number]>>;
  type t (line 49) | type t = Expect<Equal<typeof value, ['+', number, number]>>;
  type t (line 54) | type t = Expect<Equal<typeof value, ['*', number, number]>>;
  type t (line 59) | type t = Expect<Equal<typeof value, ['-', number]>>;
  type t (line 82) | type t = Expect<Equal<typeof x, ['hello', 20]>>;
  type t (line 86) | type t = Expect<Equal<typeof x, ['hello', number]>>;
  type t (line 90) | type t = Expect<Equal<typeof x, [string, 20]>>;
  type t (line 94) | type t = Expect<Equal<typeof x, [string, number]>>;
  type t (line 111) | type t = Expect<Equal<typeof x, [State, { type: 'fetch' }]>>;
  type t (line 119) | type t = Expect<
  type t (line 136) | type t = Expect<
  type t (line 150) | type t = Expect<
  type State (line 176) | type State = { type: 'a' } | { type: 'b' };
  type Event (line 177) | type Event = { type: 'c' } | { type: 'd' };
  type State (line 189) | type State = {};
  type Msg (line 190) | type Msg = [type: 'Login'] | [type: 'UrlChange', url: string];
  function update (line 192) | function update(state: State, msg: Msg) {

FILE: tests/type-error.test.ts
  type Country (line 5) | type Country = 'France' | 'Germany' | 'Spain' | 'USA';
  type t (line 39) | type t = Expect<Equal<typeof x, 'France' | 'USA'>>;
  type t (line 126) | type t = Expect<Equal<typeof x, typeof input>>;

FILE: tests/type-is-matching.test.ts
  type cases (line 8) | type cases = [
  type res1 (line 27) | type res1 = IsMatching<3, number>;
  type test1 (line 28) | type test1 = Expect<Equal<res1, true>>;
  type res2 (line 30) | type res2 = IsMatching<number, 3>;
  type test2 (line 31) | type test2 = Expect<Equal<res2, true>>;
  type res3 (line 33) | type res3 = IsMatching<'hello', string>;
  type test3 (line 34) | type test3 = Expect<Equal<res3, true>>;
  type res4 (line 36) | type res4 = IsMatching<string, 'hello'>;
  type test4 (line 37) | type test4 = Expect<Equal<res4, true>>;
  type res1 (line 41) | type res1 = IsMatching<3, string>;
  type test1 (line 42) | type test1 = Expect<Equal<res1, false>>;
  type res3 (line 44) | type res3 = IsMatching<'hello', number>;
  type test3 (line 45) | type test3 = Expect<Equal<res3, false>>;
  type res1 (line 49) | type res1 = IsMatching<string | number, string>;
  type test1 (line 50) | type test1 = Expect<Equal<res1, true>>;
  type res2 (line 52) | type res2 = IsMatching<string | number, boolean>;
  type test2 (line 53) | type test2 = Expect<Equal<res2, false>>;
  type res3 (line 55) | type res3 = IsMatching<string | number, unknown>;
  type test3 (line 56) | type test3 = Expect<Equal<res3, true>>;
  type res4 (line 59) | type res4 = IsMatching<string, number | string>;
  type test4 (line 60) | type test4 = Expect<Equal<res4, true>>;
  type cases (line 65) | type cases = [
  type State (line 212) | type State = {};
  type Msg (line 213) | type Msg = [type: 'Login'] | [type: 'UrlChange', url: string];
  type res1 (line 215) | type res1 = IsMatching<[State, Msg], [unknown, ['Login', unknown]]>;
  type test1 (line 216) | type test1 = Expect<Equal<res1, false>>;
  type res2 (line 218) | type res2 = IsMatching<['a'], []>;
  type test2 (line 219) | type test2 = Expect<Equal<res2, false>>;
  type cases (line 221) | type cases = [
  type cases (line 250) | type cases = [
  type res1 (line 260) | type res1 = IsMatching<('a' | 'b')[], [unknown, ...unknown[]]>;
  type test1 (line 261) | type test1 = Expect<Equal<res1, true>>;
  type res2 (line 263) | type res2 = IsMatching<[number], [unknown, ...unknown[]]>;
  type test2 (line 264) | type test2 = Expect<Equal<res2, true>>;
  type res3 (line 266) | type res3 = IsMatching<[number, number], [unknown, ...unknown[]]>;
  type test3 (line 267) | type test3 = Expect<Equal<res3, true>>;
  type res4 (line 269) | type res4 = IsMatching<[], [unknown, ...unknown[]]>;
  type test4 (line 270) | type test4 = Expect<Equal<res4, false>>;
  type res5 (line 272) | type res5 = IsMatching<[], [...unknown[], unknown]>;
  type test5 (line 273) | type test5 = Expect<Equal<res5, false>>;
  type res6 (line 275) | type res6 = IsMatching<[1, 2], [...unknown[], unknown]>;
  type test6 (line 276) | type test6 = Expect<Equal<res6, true>>;
  type res7 (line 278) | type res7 = IsMatching<[1, 2], [1, ...unknown[], 2]>;
  type test7 (line 279) | type test7 = Expect<Equal<res7, true>>;
  type res8 (line 281) | type res8 = IsMatching<[1, 3, 2], [1, ...unknown[], 2]>;
  type test8 (line 282) | type test8 = Expect<Equal<res8, true>>;
  type res9 (line 284) | type res9 = IsMatching<[1, 3, 2], [1, ...string[], 2]>;
  type test9 (line 285) | type test9 = Expect<Equal<res9, false>>;
  type res10 (line 287) | type res10 = IsMatching<[1, 3, 2], [1, ...number[], 2]>;
  type test10 (line 288) | type test10 = Expect<Equal<res10, true>>;
  type cases (line 292) | type cases = [
  type cases (line 306) | type cases = [
  type cases (line 341) | type cases = [

FILE: tests/types-catalog/definition.ts
  type RequestStyle (line 1) | interface RequestStyle {
  type AxisBound (line 5) | type AxisBound = string | number;
  type Aggregator (line 6) | type Aggregator = 'sum' | 'avg';
  type Axis (line 8) | interface Axis {
  type DistributionXAxis (line 17) | interface DistributionXAxis {
  type DistributionYAxis (line 24) | interface DistributionYAxis {
  type Marker (line 33) | interface Marker {
  type Event (line 49) | interface Event {
  type Markers (line 54) | type Markers = Marker[];
  type ConditionalFormat (line 56) | interface ConditionalFormat {
  type ContextMenuLink (line 67) | interface ContextMenuLink {
  type UserDefinedLink (line 72) | interface UserDefinedLink {
  type CustomLink (line 77) | type CustomLink = ContextMenuLink | UserDefinedLink;
  type OrderDir (line 79) | type OrderDir = 'a' | 'b';
  type EventCompute (line 81) | type EventCompute = {
  type GroupBy (line 87) | interface GroupBy {
  type EventQuery (line 98) | type EventQuery = {
  type MetricQuery (line 108) | type MetricQuery = string;
  type ProcessQuery (line 110) | type ProcessQuery = {
  type QueryTableColumnRequest (line 119) | interface QueryTableColumnRequest {
  type ApmStatsQuery (line 125) | interface ApmStatsQuery {
  type MetricRequest (line 133) | interface MetricRequest {
  type LogRequest (line 138) | interface LogRequest {
  type ApmRequest (line 141) | interface ApmRequest {
  type ApmStatsRequest (line 144) | interface ApmStatsRequest {
  type RumRequest (line 147) | interface RumRequest {
  type EventRequest (line 150) | interface EventRequest {
  type ProcessRequest (line 153) | interface ProcessRequest {
  type ComplianceFindingsRequest (line 157) | interface ComplianceFindingsRequest {
  type IssuesRequest (line 161) | interface IssuesRequest {
  type AuditRequest (line 164) | interface AuditRequest {
  type FormulaEventsDataSource (line 168) | type FormulaEventsDataSource =
  type FormulaMetricsQuery (line 185) | type FormulaMetricsQuery = {
  type EventsCompute (line 192) | type EventsCompute = {
  type EventsAggregator (line 198) | type EventsAggregator =
  type EventsGroupBy (line 212) | type EventsGroupBy = {
  type FormulaEventsQuery (line 223) | type FormulaEventsQuery = {
  type FormulaProcessQuery (line 234) | type FormulaProcessQuery = {
  type FormulaApmDependencyStatsQuery (line 247) | interface FormulaApmDependencyStatsQuery {
  type FormulaApmResourceStatsQuery (line 259) | interface FormulaApmResourceStatsQuery {
  type FormulaApmStatsQuery (line 271) | type FormulaApmStatsQuery =
  type FormulaIncidentsQuery (line 275) | type FormulaIncidentsQuery = {
  type FormulaQuery (line 286) | type FormulaQuery =
  type FormulaQueries (line 293) | type FormulaQueries = FormulaQuery[];
  type Formula (line 295) | type Formula = {
  type TimeseriesFormulaRequest (line 304) | interface TimeseriesFormulaRequest extends TimeseriesRequest {
  type ScalarFormulaRequest (line 310) | type ScalarFormulaRequest = {
  type SQLTimeseriesRequest (line 316) | type SQLTimeseriesRequest = {
  type SQLTableRequest (line 322) | type SQLTableRequest = {
  type EventPlatformRequest (line 328) | type EventPlatformRequest =
  type TimeseriesDataSourceRequest (line 337) | type TimeseriesDataSourceRequest =
  type TimeseriesRequestStyle (line 345) | interface TimeseriesRequestStyle {
  type Metadata (line 349) | interface Metadata {
  type DisplayType (line 353) | type DisplayType = 'line' | 'bar' | 'area';
  type TimeseriesRequest (line 355) | interface TimeseriesRequest {
  type TimeseriesDefinitionRequest (line 362) | type TimeseriesDefinitionRequest = TimeseriesDataSourceRequest &
  type TimeseriesDefinition (line 365) | interface TimeseriesDefinition {
  type TableFormula (line 375) | type TableFormula = Formula & {
  type TableFormulaRequest (line 379) | type TableFormulaRequest = {
  type QueryTableDataSourceRequest (line 385) | type QueryTableDataSourceRequest =
  type QueryTableRequest (line 392) | interface QueryTableRequest {
  type QueryTableDefinitionRequest (line 400) | type QueryTableDefinitionRequest = QueryTableDataSourceRequest &
  type HasSearchBar (line 403) | type HasSearchBar = 'always' | 'never' | 'auto';
  type QueryTableDefinition (line 405) | interface QueryTableDefinition {
  type HeatmapRequest (line 412) | interface HeatmapRequest {
  type HeatmapDefinitionRequest (line 416) | interface HeatmapDefinitionRequest extends MetricRequest, HeatmapRequest {}
  type HeatmapDefinition (line 418) | interface HeatmapDefinition {
  type ServiceMapDefinition (line 426) | interface ServiceMapDefinition {
  type TreemapProcessMemoryRequest (line 432) | type TreemapProcessMemoryRequest = { q: string };
  type TreemapDataSourceRequest (line 434) | type TreemapDataSourceRequest =
  type TreemapSizeBy (line 438) | type TreemapSizeBy = 'pct_cpu' | 'pct_mem';
  type TreemapColorBy (line 440) | type TreemapColorBy = 'user';
  type TreemapGroupBy (line 442) | type TreemapGroupBy = 'family' | 'process' | 'user';
  type TreemapDefinition (line 444) | interface TreemapDefinition {
  type TopListRequest (line 452) | interface TopListRequest {
  type TopListDataSourceRequest (line 456) | type TopListDataSourceRequest =
  type TopListDefinitionRequest (line 463) | type TopListDefinitionRequest = TopListDataSourceRequest & TopListRequest;
  type TopListDefinition (line 465) | interface TopListDefinition {
  type DistributionDataSourceRequest (line 471) | type DistributionDataSourceRequest =
  type DistributionRequest (line 477) | interface DistributionRequest {
  type DistributionDefinitionRequest (line 481) | type DistributionDefinitionRequest = DistributionDataSourceRequest &
  type DistributionDefinition (line 484) | interface DistributionDefinition {
  type ScatterPlotDimension (line 493) | type ScatterPlotDimension = 'x' | 'y' | 'radius' | 'color';
  type ScatterplotFormula (line 495) | type ScatterplotFormula = Formula & {
  type ScatterplotScalarFormulaRequest (line 499) | interface ScatterplotScalarFormulaRequest extends ScalarFormulaRequest {
  type ScatterplotDataSourceRequest (line 503) | type ScatterplotDataSourceRequest =
  type ScatterplotRequest (line 508) | interface ScatterplotRequest {
  type ScatterplotDefinitionRequest (line 512) | type ScatterplotDefinitionRequest = ScatterplotDataSourceRequest &
  type ScatterplotDefinition (line 515) | interface ScatterplotDefinition {
  type GeomapStyle (line 524) | interface GeomapStyle {
  type GeomapView (line 528) | interface GeomapView {
  type GeomapDefinitionRequest (line 532) | type GeomapDefinitionRequest =
  type GeomapDefinition (line 538) | interface GeomapDefinition {
  type PlotPaletteName (line 546) | type PlotPaletteName = 'red' | 'blue' | 'orange';
  type SunburstRequest (line 548) | type SunburstRequest = {
  type SunburstDefinitionRequest (line 554) | interface SunburstDefinitionRequest
  type SunburstKnownLegend (line 558) | type SunburstKnownLegend =
  type SunburstLegend (line 563) | type SunburstLegend =
  type SunburstDefinition (line 567) | type SunburstDefinition = {
  type WildcardDefinitionRequest (line 574) | type WildcardDefinitionRequest = SQLTableRequest | ScalarFormulaRequest;
  type WildcardDefinition (line 576) | type WildcardDefinition = {
  type Definition (line 585) | type Definition =

FILE: tests/types-catalog/utils.ts
  type Option (line 1) | type Option<a> = { kind: 'none' } | { kind: 'some'; value: a };
  type Blog (line 9) | type Blog = {
  type State (line 14) | type State =
  type Event (line 20) | type Event =
  type BigUnion (line 26) | type BigUnion =
  type AsyncResultStatus (line 54) | type AsyncResultStatus = 'idle' | 'loading' | 'error' | 'success';
  type BaseAsyncResult (line 56) | interface BaseAsyncResult<TData, TError = Error> {
  type AsyncResultIdleOrLoading (line 62) | interface AsyncResultIdleOrLoading<TData, TError = Error>
  type AsyncResultSuccess (line 67) | interface AsyncResultSuccess<TData, TError = Error>
  type AsyncResultError (line 73) | interface AsyncResultError<TData, TError = Error>
  type AsyncResult (line 78) | type AsyncResult<TData, TError = Error> =

FILE: tests/types.test.ts
  type Input (line 6) | type Input = [State, Event];
  type t (line 26) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 32) | type t = Expect<Equal<typeof state, State>>;
  type t (line 36) | type t = Expect<Equal<typeof event, Event>>;
  type t (line 50) | type t = Expect<Equal<typeof d, string>>;
  type t (line 70) | type t = Expect<Equal<typeof x, string>>;
  type t (line 78) | type t = Expect<Equal<typeof x, string>>;
  type t (line 87) | type t = Expect<Equal<typeof x, string>>;
  type t (line 93) | type t = Expect<Equal<typeof y, number>>;
  type t (line 100) | type t = Expect<Equal<typeof x, string | number>>;
  type Input (line 106) | type Input = { type: string; hello?: { yo: number } } | string;
  type t (line 109) | type t = Expect<Equal<typeof x, string>>;
  type t (line 114) | type t = Expect<Equal<typeof x, string>>;
  type t (line 121) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 128) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 132) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 137) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 141) | type t = Expect<
  type t (line 156) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 160) | type t = Expect<
  type t (line 174) | type t = Expect<
  type t (line 180) | type t = Expect<
  type t (line 188) | type t = Expect<
  type t (line 202) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 208) | type t = Expect<Equal<typeof x, Input>>;
  type t (line 215) | type t = Expect<Equal<typeof x, string>>;
  type t (line 220) | type t = Expect<Equal<typeof x, string>>;
  type t (line 224) | type t = Expect<Equal<typeof x, Input>>;
  type Input (line 230) | type Input =
  type t (line 240) | type t = Expect<Equal<typeof x, string>>;
  type t (line 244) | type t = Expect<Equal<typeof x, number>>;
  type t (line 248) | type t = Expect<Equal<typeof x, boolean>>;
  type t (line 252) | type t = Expect<Equal<typeof x, { type: string }>>;
  type t (line 256) | type t = Expect<Equal<typeof x, { type: string | number }>>;
  type t (line 260) | type t = Expect<Equal<typeof x, [string]>>;
  type t (line 264) | type t = Expect<Equal<typeof x, [number, number]>>;
  type Input (line 333) | type Input = { type: 'a'; data: string } | { type: 'b'; data: number };
  type Input (line 350) | type Input = { type: 'a'; data: string } | { type: 'b'; data: number };
  type test (line 377) | type test = Expect<Equal<typeof x, 'a' | 'b'>>;

FILE: tests/unions.test.ts
  type t (line 14) | type t = Expect<Equal<typeof o, { kind: 'some'; value: string }>>;
  type t (line 20) | type t = Expect<Equal<typeof res, string>>;
  type Post (line 26) | type Post = {
  type Video (line 31) | type Video = { type: 'video'; id: number; content: { src: string } };
  type Image (line 32) | type Image = { type: 'image'; id: number; content: { src: number } };
  type Input (line 34) | type Input = Post | Video | Image;
  type t (line 42) | type t = Expect<
  type t (line 57) | type t = Expect<Equal<typeof x, Post>>;
  type t (line 61) | type t = Expect<Equal<typeof x, Video>>;
  type t (line 65) | type t = Expect<Equal<typeof x, Image>>;
  type Text (line 74) | type Text = { type: 'text'; content: string };
  type Img (line 75) | type Img = { type: 'img'; src: string };
  type Video (line 76) | type Video = { type: 'video'; src: string };
  type Story (line 77) | type Story = {
  type Data (line 84) | type Data = Text | Img | Video | Story;
  type Ok (line 86) | type Ok<T> = { type: 'ok'; data: T };
  type ResError (line 87) | type ResError<T> = { type: 'error'; error: T };
  type Result (line 89) | type Result<TError, TOk> = Ok<TOk> | ResError<TError>;
  type t (line 98) | type t = Expect<Equal<typeof res, Ok<Text>>>;
  type t (line 102) | type t = Expect<Equal<typeof res, Ok<Img>>>;
  type t (line 106) | type t = Expect<
  type t (line 124) | type t = Expect<Equal<typeof res, ResError<Error>>>;
  type ServerError (line 133) | type ServerError = Error & {
  type ServerParseError (line 139) | type ServerParseError = Error & {
  type Input (line 145) | type Input = Error | ServerError | ServerParseError | undefined;

FILE: tests/variadic-tuples.test.ts
  type t (line 190) | type t = Expect<Equal<typeof xs, [unknown, ...unknown[]]>>;
  type t (line 199) | type t = Expect<Equal<typeof xs, [...unknown[], number]>>;
  type t (line 208) | type t = Expect<Equal<typeof xs, [42, ...number[]]>>;
  type t (line 217) | type t = Expect<Equal<typeof xs, [42, ...number[], '!']>>;
  type t (line 226) | type t = Expect<Equal<typeof xs, [1, 2, ...number[]]>>;
  type t (line 235) | type t = Expect<Equal<typeof xs, [...string[], 'a', 'b']>>;
  type t (line 248) | type t = Expect<
  type t (line 257) | type t = Expect<Equal<typeof xs, [...(string | number)[], 7]>>;
  type t (line 264) | type t = Expect<Equal<typeof xs, [42, ...number[]]>>;
  type t (line 271) | type t = Expect<Equal<typeof xs, [42, ...number[], 7]>>;
  type t (line 280) | type t = Expect<
  type t (line 290) | type t = Expect<
  type t (line 323) | type t = Expect<
  type t (line 358) | type t = Expect<Equal<typeof xs, [1, 2, ...number[]]>>;
  type t (line 365) | type t = Expect<Equal<typeof xs, [...string[], 'a', 'b']>>;
  type t (line 376) | type t = Expect<Equal<typeof xs, string | number>>;
  type t (line 383) | type t = Expect<Equal<typeof xs, (string | number)[]>>;
  type t (line 390) | type t = Expect<Equal<typeof xs, number[]>>;
  type t (line 399) | type t = Expect<Equal<typeof xs, { tail: number[]; head: 42 }>>;
  type t (line 407) | type t = Expect<Equal<typeof xs, number[]>>;
  type t (line 419) | type t = Expect<Equal<typeof xs, { c: number[]; a: 1; b: 2 }>>;
  type t (line 425) | type t = Expect<Equal<typeof xs, 2>>;
  type t (line 432) | type t = Expect<Equal<typeof xs, string[]>>;
  type t (line 440) | type t = Expect<Equal<typeof xs, { inits: string[]; last: 'a' }>>;
  type t (line 446) | type t = Expect<Equal<typeof xs, string | number>>;
  type t (line 453) | type t = Expect<Equal<typeof xs, string[]>>;
  type t (line 460) | type t = Expect<Equal<typeof xs, 2>>;
  type t (line 473) | type t = Expect<Equal<typeof xs, { a: string[]; b: 2; c: 'b' }>>;
  type t (line 481) | type t = Expect<Equal<typeof xs, number[]>>;
  type t (line 494) | type t = Expect<Equal<typeof xs, { b: number[]; a: 42; c: '!' }>>;
  type t (line 525) | type t = Expect<Equal<typeof res, 'branch 1' | 'branch 2'>>;
  type t (line 562) | type t = Expect<Equal<typeof res, 'branch 1' | 'branch 2' | 'branch 3'>>;
  type t (line 573) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 577) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 581) | type t = Expect<Equal<typeof rest, (number | string)[]>>;
  type t (line 596) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 600) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 604) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 608) | type t = Expect<Equal<typeof rest, number[]>>;
  type t (line 612) | type t = Expect<Equal<typeof rest, (number | number[] | string)[]>>;

FILE: tests/when.test.ts
  type t (line 34) | type t = Expect<Equal<typeof x, 13>>;
  type t (line 40) | type t = Expect<Equal<typeof res, boolean>>;
  type t (line 65) | type t = Expect<Equal<typeof res, Option<string>>>;
  type t (line 77) | type t = Expect<Equal<typeof x, number>>;
  type t (line 119) | type t = Expect<
  type t (line 129) | type t = Expect<Equal<typeof x, { data: string }>>;
  type t (line 138) | type t = Expect<Equal<typeof x, { data: string }>>;
  type t (line 163) | type t = Expect<Equal<typeof x, 2>>;
  type t (line 181) | type t = Expect<Equal<typeof x, number>>;
  type Option (line 194) | type Option<T> = { type: 'some'; value: T } | { type: 'none' };
  type t (line 218) | type t = Expect<Equal<typeof x, string>>;
  type t (line 226) | type t = Expect<
  type t (line 258) | type t = Expect<
  type t (line 279) | type t = Expect<Equal<typeof x, string[]>>;
  type Input (line 334) | type Input = string | { prop: string | number };
  type t (line 340) | type t = Expect<Equal<typeof x, { prop: string }>>;
  type Input (line 356) | type Input = { prop: string | number };
  type t (line 361) | type t = Expect<Equal<typeof x, { prop: number }>>;
  type Data (line 370) | type Data = { digit: number };
  type Input (line 372) | type Input = {
  type t (line 382) | type t = Expect<Equal<typeof data, Data | undefined>>;

FILE: tests/wildcards.test.ts
  type t (line 12) | type t = Expect<Equal<typeof x, string>>;
  type t (line 23) | type t = Expect<Equal<typeof x, number>>;
  type t (line 34) | type t = Expect<Equal<typeof x, boolean>>;
  type t (line 45) | type t = Expect<Equal<typeof x, null | undefined>>;
  type t (line 52) | type t = Expect<Equal<typeof x, null | undefined>>;
  type Input (line 63) | type Input = string | number | boolean | null | undefined;
  type t (line 66) | type t = Expect<Equal<typeof x, string | number | boolean>>;
  type t (line 73) | type t = Expect<Equal<typeof x, 0 | 1 | 2>>;
  type Input (line 84) | type Input =
  type X (line 97) | type X = InvertPattern<typeof pattern, Input>;
  type Y (line 98) | type Y = ExtractPreciseValue<Input, X>;
  type t (line 105) | type t = Expect<Equal<typeof fields, string[]>>;
  type t (line 121) | type t = Expect<Equal<typeof x, string | number>>;
  type t (line 130) | type t = Expect<Equal<typeof x, { nested: string | number }>>;
  type t (line 133) | type t = Expect<Equal<typeof x, { nested: null | undefined }>>;
  type t (line 164) | type t = Expect<Equal<typeof x, number | boolean>>;
  type t (line 175) | type t = Expect<Equal<typeof x, string | boolean>>;
  type t (line 186) | type t = Expect<Equal<typeof x, string | number>>;
  type Id (line 195) | type Id = { teamId: number } | { storeId: number };