microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-06-14 16:56:06 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Accept new baselines

Browse Source
This commit is contained in:
Anders Hejlsberg
2017-08-25 14:19:14 -07:00
parent dedce6dc33
commit e6275ff51b
16 changed files with 120 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
tests/baselines/reference/arrayConcat2.types
View File

@@ -5,17 +5,17 @@ var a: string[] = [];
a.concat("hello", 'world');
>a.concat("hello", 'world') : string[]
>a.concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>a.concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>a : string[]
>concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>"hello" : "hello"
>'world' : "world"
a.concat('Hello');
>a.concat('Hello') : string[]
>a.concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>a.concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>a : string[]
>concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>'Hello' : "Hello"
var b = new Array<string>();
@@ -25,8 +25,8 @@ var b = new Array<string>();
b.concat('hello');
>b.concat('hello') : string[]
>b.concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>b.concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>b : string[]
>concat : { (this: readonly, ...items: ReadonlyArray<string>[]): string[]; (this: readonly, ...items: (string | ReadonlyArray<string>)[]): string[]; }
>concat : { (this: readonly, ...items: (readonly string[])[]): string[]; (this: readonly, ...items: (string | readonly string[])[]): string[]; }
>'hello' : "hello"

4
tests/baselines/reference/arrayConcatMap.types
View File

@@ -4,9 +4,9 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
>[].concat([{ a: 1 }], [{ a: 2 }]) .map(b => b.a) : any[]
>[].concat([{ a: 1 }], [{ a: 2 }]) .map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
>[].concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>[].concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>[] : undefined[]
>concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>[{ a: 1 }] : { a: number; }[]
>{ a: 1 } : { a: number; }
>a : number

36
tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
View File

@@ -1,13 +1,12 @@
tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
Types of property 'concat' are incompatible.
Type '{ (this: readonly, ...items: ReadonlyArray<A>[]): A[]; (this: readonly, ...items: (A | ReadonlyArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ReadonlyArray<B>[]): B[]; (...items: (B | ReadonlyArray<B>)[]): B[]; }'.
Type 'A[]' is not assignable to type 'B[]'.
tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'readonly B[]'.
Type 'A[]' is not assignable to type 'B[]'.
Type 'A' is not assignable to type 'B'.
Property 'b' is missing in type 'A'.
tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
Type 'C<A>' is not assignable to type 'B[]'.
Types of property 'pop' are incompatible.
Type '() => A' is not assignable to type '() => B'.
Type 'A' is not assignable to type 'B'.
Property 'b' is missing in type 'A'.
tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
Types of property 'concat' are incompatible.
Type '{ (this: readonly, ...items: ReadonlyArray<A>[]): A[]; (this: readonly, ...items: (A | ReadonlyArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ReadonlyArray<B>[]): B[]; (...items: (B | ReadonlyArray<B>)[]): B[]; }'.
Type 'A[]' is not assignable to type 'B[]'.
==== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts (2 errors) ====
@@ -25,20 +24,19 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
rra = arb;
rrb = ara; // error: 'A' is not assignable to 'B'
~~~
!!! error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
!!! error TS2322: Types of property 'concat' are incompatible.
!!! error TS2322: Type '{ (this: readonly, ...items: ReadonlyArray<A>[]): A[]; (this: readonly, ...items: (A | ReadonlyArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ReadonlyArray<B>[]): B[]; (...items: (B | ReadonlyArray<B>)[]): B[]; }'.
!!! error TS2322: Type 'A[]' is not assignable to type 'B[]'.
!!! error TS2322: Type 'A' is not assignable to type 'B'.
!!! error TS2322: Property 'b' is missing in type 'A'.
!!! error TS2322: Type 'A[]' is not assignable to type 'readonly B[]'.
!!! error TS2322: Type 'A[]' is not assignable to type 'B[]'.
!!! error TS2322: Type 'A' is not assignable to type 'B'.
!!! error TS2322: Property 'b' is missing in type 'A'.
rra = cra;
rra = crb; // OK, C<B> is assignable to ReadonlyArray<A>
rrb = crb;
rrb = cra; // error: 'A' is not assignable to 'B'
~~~
!!! error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
!!! error TS2322: Types of property 'concat' are incompatible.
!!! error TS2322: Type '{ (this: readonly, ...items: ReadonlyArray<A>[]): A[]; (this: readonly, ...items: (A | ReadonlyArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ReadonlyArray<B>[]): B[]; (...items: (B | ReadonlyArray<B>)[]): B[]; }'.
!!! error TS2322: Type 'A[]' is not assignable to type 'B[]'.
!!! error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
!!! error TS2322: Type 'C<A>' is not assignable to type 'B[]'.
!!! error TS2322: Types of property 'pop' are incompatible.
!!! error TS2322: Type '() => A' is not assignable to type '() => B'.
!!! error TS2322: Type 'A' is not assignable to type 'B'.

8
tests/baselines/reference/circularContextualReturnType.types
View File

@@ -3,9 +3,9 @@
Object.freeze({
>Object.freeze({ foo() { return Object.freeze('a'); },}) : Readonly<{ foo(): string; }>
>Object.freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object.freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object : ObjectConstructor
>freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>{ foo() { return Object.freeze('a'); },} : { foo(): string; }
foo() {
@@ -13,9 +13,9 @@ Object.freeze({
return Object.freeze('a');
>Object.freeze('a') : string
>Object.freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object.freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object : ObjectConstructor
>freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>'a' : "a"
},

8
tests/baselines/reference/concatError.types
View File

@@ -15,9 +15,9 @@ fa = fa.concat([0]);
>fa = fa.concat([0]) : number[]
>fa : number[]
>fa.concat([0]) : number[]
>fa.concat : { (this: readonly, ...items: ReadonlyArray<number>[]): number[]; (this: readonly, ...items: (number | ReadonlyArray<number>)[]): number[]; }
>fa.concat : { (this: readonly, ...items: (readonly number[])[]): number[]; (this: readonly, ...items: (number | readonly number[])[]): number[]; }
>fa : number[]
>concat : { (this: readonly, ...items: ReadonlyArray<number>[]): number[]; (this: readonly, ...items: (number | ReadonlyArray<number>)[]): number[]; }
>concat : { (this: readonly, ...items: (readonly number[])[]): number[]; (this: readonly, ...items: (number | readonly number[])[]): number[]; }
>[0] : number[]
>0 : 0
@@ -25,9 +25,9 @@ fa = fa.concat(0);
>fa = fa.concat(0) : number[]
>fa : number[]
>fa.concat(0) : number[]
>fa.concat : { (this: readonly, ...items: ReadonlyArray<number>[]): number[]; (this: readonly, ...items: (number | ReadonlyArray<number>)[]): number[]; }
>fa.concat : { (this: readonly, ...items: (readonly number[])[]): number[]; (this: readonly, ...items: (number | readonly number[])[]): number[]; }
>fa : number[]
>concat : { (this: readonly, ...items: ReadonlyArray<number>[]): number[]; (this: readonly, ...items: (number | ReadonlyArray<number>)[]): number[]; }
>concat : { (this: readonly, ...items: (readonly number[])[]): number[]; (this: readonly, ...items: (number | readonly number[])[]): number[]; }
>0 : 0

4
tests/baselines/reference/concatTuples.types
View File

@@ -10,9 +10,9 @@ ijs = ijs.concat([[3, 4], [5, 6]]);
>ijs = ijs.concat([[3, 4], [5, 6]]) : [number, number][]
>ijs : [number, number][]
>ijs.concat([[3, 4], [5, 6]]) : [number, number][]
>ijs.concat : { (this: readonly, ...items: ReadonlyArray<[number, number]>[]): [number, number][]; (this: readonly, ...items: ([number, number] | ReadonlyArray<[number, number]>)[]): [number, number][]; }
>ijs.concat : { (this: readonly, ...items: (readonly [number, number][])[]): [number, number][]; (this: readonly, ...items: ([number, number] | readonly [number, number][])[]): [number, number][]; }
>ijs : [number, number][]
>concat : { (this: readonly, ...items: ReadonlyArray<[number, number]>[]): [number, number][]; (this: readonly, ...items: ([number, number] | ReadonlyArray<[number, number]>)[]): [number, number][]; }
>concat : { (this: readonly, ...items: (readonly [number, number][])[]): [number, number][]; (this: readonly, ...items: ([number, number] | readonly [number, number][])[]): [number, number][]; }
>[[3, 4], [5, 6]] : [number, number][]
>[3, 4] : [number, number]
>3 : 3

8
tests/baselines/reference/doNotInferUnrelatedTypes.types
View File

@@ -1,10 +1,10 @@
=== tests/cases/compiler/doNotInferUnrelatedTypes.ts ===
// #16709
declare function dearray<T>(ara: ReadonlyArray<T>): T;
>dearray : <T>(ara: ReadonlyArray<T>) => T
>dearray : <T>(ara: readonly T[]) => T
>T : T
>ara : ReadonlyArray<T>
>ReadonlyArray : ReadonlyArray<T>
>ara : readonly T[]
>ReadonlyArray : readonly T[]
>T : T
>T : T
@@ -20,6 +20,6 @@ let foo: LiteralType = dearray(alt);
>foo : LiteralType
>LiteralType : LiteralType
>dearray(alt) : LiteralType
>dearray : <T>(ara: ReadonlyArray<T>) => T
>dearray : <T>(ara: readonly T[]) => T
>alt : LiteralType[]

4
tests/baselines/reference/emitSkipsThisWithRestParameter.types
View File

@@ -18,10 +18,10 @@ function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any
>apply : (this: Function, thisArg: any, argArray?: any) => any
>this : any
>[ this ].concat(args) : any[]
>[ this ].concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>[ this ].concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>[ this ] : any[]
>this : any
>concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>args : any[]
};

4
tests/baselines/reference/for-of13.types
View File

@@ -5,8 +5,8 @@ var v: string;
for (v of [""].values()) { }
>v : string
>[""].values() : IterableIterator<string>
>[""].values : () => IterableIterator<string>
>[""].values : (this: readonly) => IterableIterator<string>
>[""] : string[]
>"" : ""
>values : () => IterableIterator<string>
>values : (this: readonly) => IterableIterator<string>

22
tests/baselines/reference/iteratorSpreadInArray6.errors.txt
View File

@@ -1,10 +1,7 @@
tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(15,14): error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number | ReadonlyArray<number>'.
Type 'symbol[]' is not assignable to type 'ReadonlyArray<number>'.
Types of property 'concat' are incompatible.
Type '{ (...items: ReadonlyArray<symbol>[]): symbol[]; (...items: (symbol | ReadonlyArray<symbol>)[]): symbol[]; }' is not assignable to type '{ (...items: ReadonlyArray<number>[]): number[]; (...items: (number | ReadonlyArray<number>)[]): number[]; }'.
Types of parameters 'items' and 'items' are incompatible.
Type 'ReadonlyArray<number>' is not assignable to type 'ReadonlyArray<symbol>'.
Type 'number' is not assignable to type 'symbol'.
tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(15,14): error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number | readonly number[]'.
Type 'symbol[]' is not assignable to type 'readonly number[]'.
Type 'symbol[]' is not assignable to type 'number[]'.
Type 'symbol' is not assignable to type 'number'.
==== tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts (1 errors) ====
@@ -24,10 +21,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(15,14): error TS234
var array: number[] = [0, 1];
array.concat([...new SymbolIterator]);
~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number | ReadonlyArray<number>'.
!!! error TS2345: Type 'symbol[]' is not assignable to type 'ReadonlyArray<number>'.
!!! error TS2345: Types of property 'concat' are incompatible.
!!! error TS2345: Type '{ (...items: ReadonlyArray<symbol>[]): symbol[]; (...items: (symbol | ReadonlyArray<symbol>)[]): symbol[]; }' is not assignable to type '{ (...items: ReadonlyArray<number>[]): number[]; (...items: (number | ReadonlyArray<number>)[]): number[]; }'.
!!! error TS2345: Types of parameters 'items' and 'items' are incompatible.
!!! error TS2345: Type 'ReadonlyArray<number>' is not assignable to type 'ReadonlyArray<symbol>'.
!!! error TS2345: Type 'number' is not assignable to type 'symbol'.
!!! error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number | readonly number[]'.
!!! error TS2345: Type 'symbol[]' is not assignable to type 'readonly number[]'.
!!! error TS2345: Type 'symbol[]' is not assignable to type 'number[]'.
!!! error TS2345: Type 'symbol' is not assignable to type 'number'.

4
tests/baselines/reference/iteratorSpreadInArray7.types
View File

@@ -35,9 +35,9 @@ var array: symbol[];
array.concat([...new SymbolIterator]);
>array.concat([...new SymbolIterator]) : symbol[]
>array.concat : { (this: readonly, ...items: ReadonlyArray<symbol>[]): symbol[]; (this: readonly, ...items: (symbol | ReadonlyArray<symbol>)[]): symbol[]; }
>array.concat : { (this: readonly, ...items: (readonly symbol[])[]): symbol[]; (this: readonly, ...items: (symbol | readonly symbol[])[]): symbol[]; }
>array : symbol[]
>concat : { (this: readonly, ...items: ReadonlyArray<symbol>[]): symbol[]; (this: readonly, ...items: (symbol | ReadonlyArray<symbol>)[]): symbol[]; }
>concat : { (this: readonly, ...items: (readonly symbol[])[]): symbol[]; (this: readonly, ...items: (symbol | readonly symbol[])[]): symbol[]; }
>[...new SymbolIterator] : symbol[]
>...new SymbolIterator : symbol
>new SymbolIterator : SymbolIterator

4
tests/baselines/reference/keyofAndIndexedAccess.types
View File

@@ -2224,9 +2224,9 @@ class SampleClass<P> {
>this : this
>props : Readonly<P>
>Object.freeze(props) : Readonly<P>
>Object.freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object.freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>Object : ObjectConstructor
>freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>freeze : { <T>(a: T[]): readonly T[]; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
>props : P
}
}

4
tests/baselines/reference/objectFreeze.errors.txt
View File

@@ -1,5 +1,5 @@
tests/cases/compiler/objectFreeze.ts(9,1): error TS2322: Type 'string' is not assignable to type 'number'.
tests/cases/compiler/objectFreeze.ts(9,1): error TS2542: Index signature in type 'ReadonlyArray<number>' only permits reading.
tests/cases/compiler/objectFreeze.ts(9,1): error TS2542: Index signature in type 'readonly number[]' only permits reading.
tests/cases/compiler/objectFreeze.ts(12,3): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property.
@@ -16,7 +16,7 @@ tests/cases/compiler/objectFreeze.ts(12,3): error TS2540: Cannot assign to 'b' b
~~~~
!!! error TS2322: Type 'string' is not assignable to type 'number'.
~~~~
!!! error TS2542: Index signature in type 'ReadonlyArray<number>' only permits reading.
!!! error TS2542: Index signature in type 'readonly number[]' only permits reading.
const o = Object.freeze({ a: 1, b: "string" });
o.b = o.a.toString();

4
tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
View File

@@ -348,9 +348,9 @@ class ListWrapper {
>a : any[]
>b : any[]
>a.concat(b) : any[]
>a.concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>a.concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>a : any[]
>concat : { (this: readonly, ...items: ReadonlyArray<any>[]): any[]; (this: readonly, ...items: any[]): any[]; }
>concat : { (this: readonly, ...items: (readonly any[])[]): any[]; (this: readonly, ...items: any[]): any[]; }
>b : any[]
static insert<T>(dit: typeof ListWrapper, list: T[], index: number, value: T) { list.splice(index, 0, value); }

2
tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols
View File

@@ -289,7 +289,7 @@ class A {
options: [] as ReadonlyArray<string>
>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --))
};

120
tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types
View File

@@ -174,9 +174,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : string
>options.find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>options.find : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>options : string[]
>find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>find : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean
>val : string
>index : number
@@ -195,9 +195,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>options : string[]
>findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean
>val : string
>index : number
@@ -386,23 +386,23 @@ class A {
>options : string[]
const thisObject = {
>thisObject : { options: ReadonlyArray<string>; }
>{ options: [] as ReadonlyArray<string> } : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
>{ options: [] as ReadonlyArray<string> } : { options: readonly string[]; }
options: [] as ReadonlyArray<string>
>options : ReadonlyArray<string>
>[] as ReadonlyArray<string> : ReadonlyArray<string>
>options : readonly string[]
>[] as ReadonlyArray<string> : readonly string[]
>[] : undefined[]
>ReadonlyArray : ReadonlyArray<T>
>ReadonlyArray : readonly T[]
};
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : string
>options.find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>options.find : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>options : string[]
>find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
>find : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
>function (val, index) { return val === this.options[index]; } : (this: { options: readonly string[]; }, val: string, index: number) => boolean
>val : string
>index : number
@@ -410,20 +410,20 @@ class A {
>val === this.options[index] : boolean
>val : string
>this.options[index] : string
>this.options : ReadonlyArray<string>
>this : { options: ReadonlyArray<string>; }
>options : ReadonlyArray<string>
>this.options : readonly string[]
>this : { options: readonly string[]; }
>options : readonly string[]
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>options : string[]
>findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
>findIndex : { (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (this: readonly, predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: readonly string[]; }, val: string, index: number) => boolean
>val : string
>index : number
@@ -431,13 +431,13 @@ class A {
>val === this.options[index] : boolean
>val : string
>this.options[index] : string
>this.options : ReadonlyArray<string>
>this : { options: ReadonlyArray<string>; }
>options : ReadonlyArray<string>
>this.options : readonly string[]
>this : { options: readonly string[]; }
>options : readonly string[]
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.forEach(function (val, index) {
>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void
@@ -458,7 +458,7 @@ class A {
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.map(function (val, index) {
>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : any[]
@@ -486,7 +486,7 @@ class A {
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.some(function (val, index) {
>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean
@@ -507,7 +507,7 @@ class A {
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.filter(function (val, index) {
>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : string[]
@@ -528,7 +528,7 @@ class A {
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
options.every(function (val, index) {
>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean
@@ -549,7 +549,7 @@ class A {
>index : number
}, thisObject);
>thisObject : { options: ReadonlyArray<string>; }
>thisObject : { options: readonly string[]; }
}
test2(options: Int8Array[]) {
@@ -571,9 +571,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Int8Array
>options.find : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(this: readonly, predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
>options : Int8Array[]
>find : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
>find : { (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(this: readonly, predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
>val : Int8Array
>index : number
@@ -592,9 +592,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
>options : Int8Array[]
>findIndex : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
>val : Int8Array
>index : number
@@ -743,9 +743,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8Array
>options.find : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(this: readonly, predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
>options : Uint8Array[]
>find : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
>find : { (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(this: readonly, predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
>val : Uint8Array
>index : number
@@ -764,9 +764,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
>options : Uint8Array[]
>findIndex : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
>val : Uint8Array
>index : number
@@ -915,9 +915,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Float32Array
>options.find : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(this: readonly, predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
>options : Float32Array[]
>find : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
>find : { (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(this: readonly, predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
>val : Float32Array
>index : number
@@ -936,9 +936,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
>options : Float32Array[]
>findIndex : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
>val : Float32Array
>index : number
@@ -1087,9 +1087,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8ClampedArray
>options.find : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
>options.find : { (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(this: readonly, predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
>options : Uint8ClampedArray[]
>find : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
>find : { (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(this: readonly, predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
>val : Uint8ClampedArray
>index : number
@@ -1108,9 +1108,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
>options : Uint8ClampedArray[]
>findIndex : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
>val : Uint8ClampedArray
>index : number
@@ -1259,9 +1259,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Int16Array
>options.find : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(this: readonly, predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
>options : Int16Array[]
>find : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
>find : { (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(this: readonly, predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
>val : Int16Array
>index : number
@@ -1280,9 +1280,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
>options : Int16Array[]
>findIndex : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
>val : Int16Array
>index : number
@@ -1431,9 +1431,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint16Array
>options.find : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(this: readonly, predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
>options : Uint16Array[]
>find : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
>find : { (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(this: readonly, predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
>val : Uint16Array
>index : number
@@ -1452,9 +1452,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
>options : Uint16Array[]
>findIndex : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
>val : Uint16Array
>index : number
@@ -1603,9 +1603,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint32Array
>options.find : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(this: readonly, predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
>options : Uint32Array[]
>find : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
>find : { (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(this: readonly, predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
>val : Uint32Array
>index : number
@@ -1624,9 +1624,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
>options : Uint32Array[]
>findIndex : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
>val : Uint32Array
>index : number
@@ -1775,9 +1775,9 @@ class A {
options.find(function (val, index) {
>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Float64Array
>options.find : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
>options.find : { (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(this: readonly, predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
>options : Float64Array[]
>find : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
>find : { (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(this: readonly, predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
>val : Float64Array
>index : number
@@ -1796,9 +1796,9 @@ class A {
options.findIndex(function (val, index) {
>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number
>options.findIndex : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
>options.findIndex : { (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
>options : Float64Array[]
>findIndex : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
>findIndex : { (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (this: readonly, predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(this: readonly, predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
>val : Float64Array
>index : number