From 18154fe11110e44084f1b6b26f3ed1b7d70c55fc Mon Sep 17 00:00:00 2001 From: e-cloud Date: Thu, 5 Jan 2017 11:08:28 +0800 Subject: [PATCH] test: add tests for this type in native-this-assignable methods --- .../thisTypeInNativeThisAssignableMethods.js | 710 ++++++ ...sTypeInNativeThisAssignableMethods.symbols | 1569 +++++++++++++ ...hisTypeInNativeThisAssignableMethods.types | 1932 +++++++++++++++++ .../thisTypeInNativeThisAssignableMethods.ts | 398 ++++ 4 files changed, 4609 insertions(+) create mode 100644 tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js create mode 100644 tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols create mode 100644 tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types create mode 100644 tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js new file mode 100644 index 00000000000..d9020c79e29 --- /dev/null +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js @@ -0,0 +1,710 @@ +//// [thisTypeInNativeThisAssignableMethods.ts] + +class A { + options: string[]; + + addOptions(options: string[]) { + if (!this.options) { + this.options = []; + } + options.forEach(function (item) { + this.options.push(item); + }, this); + return this; + } + + testUndefined(options: string[]) { + const undefinedArr: Array = [] + options.forEach(function () { + undefinedArr.push(this); + }); // case1 + options.forEach(function () { + undefinedArr.push(this); + }, undefined); // case2 + options.forEach(function () { + undefinedArr.push(this); + }, null); // case3 + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + } + + test(options: string[]) { + const thisObject = { + options: [] as string[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this.options[item].length + }, thisObject) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this.options[item].length + }, thisObject) + } + + test1(options: string[]) { + const thisObject = { + options: [] as ReadonlyArray + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test2(options: Int8Array[]) { + const thisObject = { + options: [] as Int8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test3(options: Uint8Array[]) { + const thisObject = { + options: [] as Uint8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test4(options: Float32Array[]) { + const thisObject = { + options: [] as Float32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test5(options: Uint8ClampedArray[]) { + const thisObject = { + options: [] as Uint8ClampedArray[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test6(options: Int16Array[]) { + const thisObject = { + options: [] as Int16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test7(options: Uint16Array[]) { + const thisObject = { + options: [] as Uint16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test8(options: Uint32Array[]) { + const thisObject = { + options: [] as Uint32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test9(options: Float64Array[]) { + const thisObject = { + options: [] as Float64Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } +} + + +//// [thisTypeInNativeThisAssignableMethods.js] +class A { + addOptions(options) { + if (!this.options) { + this.options = []; + } + options.forEach(function (item) { + this.options.push(item); + }, this); + return this; + } + testUndefined(options) { + const undefinedArr = []; + options.forEach(function () { + undefinedArr.push(this); + }); // case1 + options.forEach(function () { + undefinedArr.push(this); + }, undefined); // case2 + options.forEach(function () { + undefinedArr.push(this); + }, null); // case3 + const arrLike = {}; + Array.from(arrLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined); + const iterLike = []; + Array.from(iterLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined); + } + test(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + const arrLike = {}; + Array.from(arrLike, function (item) { + return this.options[item].length; + }, thisObject); + const iterLike = []; + Array.from(iterLike, function (item) { + return this.options[item].length; + }, thisObject); + } + test1(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test2(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test3(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test4(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test5(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test6(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test7(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test8(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + test9(options) { + const thisObject = { + options: [] + }; + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } +} diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols new file mode 100644 index 00000000000..2ff555baa54 --- /dev/null +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols @@ -0,0 +1,1569 @@ +=== tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts === + +class A { +>A : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) + + options: string[]; +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) + + addOptions(options: string[]) { +>addOptions : Symbol(A.addOptions, Decl(thisTypeInNativeThisAssignableMethods.ts, 2, 22)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 4, 15)) + + if (!this.options) { +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) + + this.options = []; +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) + } + options.forEach(function (item) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 4, 15)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 8, 34)) + + this.options.push(item); +>this.options.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 8, 34)) + + }, this); +>this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) + + return this; +>this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) + } + + testUndefined(options: string[]) { +>testUndefined : Symbol(A.testUndefined, Decl(thisTypeInNativeThisAssignableMethods.ts, 12, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) + + const undefinedArr: Array = [] +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) + + options.forEach(function () { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + undefinedArr.push(this); +>undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) + + }); // case1 + options.forEach(function () { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + undefinedArr.push(this); +>undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) + + }, undefined); // case2 +>undefined : Symbol(undefined) + + options.forEach(function () { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + undefinedArr.push(this); +>undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) + + }, null); // case3 + + const arrLike = {} as ArrayLike +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 26, 13)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --)) + + Array.from(arrLike, function (item) { +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 26, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 27, 38)) + + return this === undefined ? 2 : 1; +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>undefined : Symbol(undefined) + + }, undefined) +>undefined : Symbol(undefined) + + const iterLike = [] as Iterable +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 31, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + Array.from(iterLike, function (item) { +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 31, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 32, 39)) + + return this === undefined ? 2 : 1; +>this : Symbol(this, Decl(lib.es2015.iterable.d.ts, --, --)) +>undefined : Symbol(undefined) + + }, undefined) +>undefined : Symbol(undefined) + } + + test(options: string[]) { +>test : Symbol(A.test, Decl(thisTypeInNativeThisAssignableMethods.ts, 35, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options: [] as string[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + const arrLike = {} as ArrayLike +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 13)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --)) + + Array.from(arrLike, function (item) { +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 72, 38)) + + return this.options[item].length +>this.options[item].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 72, 38)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + }, thisObject) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + + const iterLike = [] as Iterable +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + Array.from(iterLike, function (item) { +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 77, 39)) + + return this.options[item].length +>this.options[item].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this : Symbol(this, Decl(lib.es2015.iterable.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 77, 39)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + }, thisObject) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) + } + + test1(options: string[]) { +>test1 : Symbol(A.test1, Decl(thisTypeInNativeThisAssignableMethods.ts, 80, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options: [] as ReadonlyArray +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 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, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) + } + + test2(options: Int8Array[]) { +>test2 : Symbol(A.test2, Decl(thisTypeInNativeThisAssignableMethods.ts, 115, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>Int8Array : Symbol(Int8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options: [] as Int8Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>Int8Array : Symbol(Int8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) + } + + test3(options: Uint8Array[]) { +>test3 : Symbol(A.test3, Decl(thisTypeInNativeThisAssignableMethods.ts, 150, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options: [] as Uint8Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) + } + + test4(options: Float32Array[]) { +>test4 : Symbol(A.test4, Decl(thisTypeInNativeThisAssignableMethods.ts, 185, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>Float32Array : Symbol(Float32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options: [] as Float32Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>Float32Array : Symbol(Float32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) + } + + test5(options: Uint8ClampedArray[]) { +>test5 : Symbol(A.test5, Decl(thisTypeInNativeThisAssignableMethods.ts, 220, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options: [] as Uint8ClampedArray[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) + } + + test6(options: Int16Array[]) { +>test6 : Symbol(A.test6, Decl(thisTypeInNativeThisAssignableMethods.ts, 255, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>Int16Array : Symbol(Int16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options: [] as Int16Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>Int16Array : Symbol(Int16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) + } + + test7(options: Uint16Array[]) { +>test7 : Symbol(A.test7, Decl(thisTypeInNativeThisAssignableMethods.ts, 290, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options: [] as Uint16Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) + } + + test8(options: Uint32Array[]) { +>test8 : Symbol(A.test8, Decl(thisTypeInNativeThisAssignableMethods.ts, 325, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options: [] as Uint32Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) + } + + test9(options: Float64Array[]) { +>test9 : Symbol(A.test9, Decl(thisTypeInNativeThisAssignableMethods.ts, 360, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>Float64Array : Symbol(Float64Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + const thisObject = { +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options: [] as Float64Array[] +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>Float64Array : Symbol(Float64Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + }; + + options.find(function (val, index) { +>options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.findIndex(function (val, index) { +>options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 40)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 40)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.forEach(function (val, index) { +>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 38)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 38)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.map(function (val, index) { +>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) + + if (val === this.options[index]) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) + + return this.options[index]; +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.some(function (val, index) { +>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 35)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 35)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.filter(function (val, index) { +>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 37)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 37)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + + options.every(function (val, index) { +>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 36)) + + return val === this.options[index]; +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this : Symbol(this, Decl(lib.es5.d.ts, --, --)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 36)) + + }, thisObject); +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) + } +} + diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types new file mode 100644 index 00000000000..e64918181ca --- /dev/null +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types @@ -0,0 +1,1932 @@ +=== tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts === + +class A { +>A : A + + options: string[]; +>options : string[] + + addOptions(options: string[]) { +>addOptions : (options: string[]) => this +>options : string[] + + if (!this.options) { +>!this.options : boolean +>this.options : string[] +>this : this +>options : string[] + + this.options = []; +>this.options = [] : undefined[] +>this.options : string[] +>this : this +>options : string[] +>[] : undefined[] + } + options.forEach(function (item) { +>options.forEach(function (item) { this.options.push(item); }, this) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function (item) { this.options.push(item); } : (this: this, item: string) => void +>item : string + + this.options.push(item); +>this.options.push(item) : number +>this.options.push : (...items: string[]) => number +>this.options : string[] +>this : this +>options : string[] +>push : (...items: string[]) => number +>item : string + + }, this); +>this : this + + return this; +>this : this + } + + testUndefined(options: string[]) { +>testUndefined : (options: string[]) => void +>options : string[] + + const undefinedArr: Array = [] +>undefinedArr : undefined[] +>Array : T[] +>[] : undefined[] + + options.forEach(function () { +>options.forEach(function () { undefinedArr.push(this); }) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function () { undefinedArr.push(this); } : (this: undefined) => void + + undefinedArr.push(this); +>undefinedArr.push(this) : number +>undefinedArr.push : (...items: undefined[]) => number +>undefinedArr : undefined[] +>push : (...items: undefined[]) => number +>this : undefined + + }); // case1 + options.forEach(function () { +>options.forEach(function () { undefinedArr.push(this); }, undefined) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function () { undefinedArr.push(this); } : (this: undefined) => void + + undefinedArr.push(this); +>undefinedArr.push(this) : number +>undefinedArr.push : (...items: undefined[]) => number +>undefinedArr : undefined[] +>push : (...items: undefined[]) => number +>this : undefined + + }, undefined); // case2 +>undefined : undefined + + options.forEach(function () { +>options.forEach(function () { undefinedArr.push(this); }, null) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function () { undefinedArr.push(this); } : (this: undefined) => void + + undefinedArr.push(this); +>undefinedArr.push(this) : number +>undefinedArr.push : (...items: undefined[]) => number +>undefinedArr : undefined[] +>push : (...items: undefined[]) => number +>this : undefined + + }, null); // case3 +>null : null + + const arrLike = {} as ArrayLike +>arrLike : ArrayLike +>{} as ArrayLike : ArrayLike +>{} : {} +>ArrayLike : ArrayLike + + Array.from(arrLike, function (item) { +>Array.from(arrLike, function (item) { return this === undefined ? 2 : 1; }, undefined) : (2 | 1)[] +>Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>arrLike : ArrayLike +>function (item) { return this === undefined ? 2 : 1; } : (this: undefined, item: number) => 2 | 1 +>item : number + + return this === undefined ? 2 : 1; +>this === undefined ? 2 : 1 : 2 | 1 +>this === undefined : boolean +>this : undefined +>undefined : undefined +>2 : 2 +>1 : 1 + + }, undefined) +>undefined : undefined + + const iterLike = [] as Iterable +>iterLike : Iterable +>[] as Iterable : Iterable +>[] : undefined[] +>Iterable : Iterable + + Array.from(iterLike, function (item) { +>Array.from(iterLike, function (item) { return this === undefined ? 2 : 1; }, undefined) : (2 | 1)[] +>Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>iterLike : Iterable +>function (item) { return this === undefined ? 2 : 1; } : (this: undefined, item: number) => 2 | 1 +>item : number + + return this === undefined ? 2 : 1; +>this === undefined ? 2 : 1 : 2 | 1 +>this === undefined : boolean +>this : undefined +>undefined : undefined +>2 : 2 +>1 : 1 + + }, undefined) +>undefined : undefined + } + + test(options: string[]) { +>test : (options: string[]) => void +>options : string[] + + const thisObject = { +>thisObject : { options: string[]; } +>{ options: [] as string[] } : { options: string[]; } + + options: [] as string[] +>options : string[] +>[] as string[] : string[] +>[] : undefined[] + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : string +>options.find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; } +>options : string[] +>find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; } +>options : string[] +>findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : string[] +>options.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>options : string[] +>map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => string +>val : string +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + return this.options[index]; +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>options : string[] +>some : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : string[] +>options.filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; } +>options : string[] +>filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>options : string[] +>every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: string[]; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>index : number + + }, thisObject); +>thisObject : { options: string[]; } + + const arrLike = {} as ArrayLike +>arrLike : ArrayLike +>{} as ArrayLike : ArrayLike +>{} : {} +>ArrayLike : ArrayLike + + Array.from(arrLike, function (item) { +>Array.from(arrLike, function (item) { return this.options[item].length }, thisObject) : number[] +>Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>arrLike : ArrayLike +>function (item) { return this.options[item].length } : (this: { options: string[]; }, item: number) => number +>item : number + + return this.options[item].length +>this.options[item].length : number +>this.options[item] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>item : number +>length : number + + }, thisObject) +>thisObject : { options: string[]; } + + const iterLike = [] as Iterable +>iterLike : Iterable +>[] as Iterable : Iterable +>[] : undefined[] +>Iterable : Iterable + + Array.from(iterLike, function (item) { +>Array.from(iterLike, function (item) { return this.options[item].length }, thisObject) : number[] +>Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>iterLike : Iterable +>function (item) { return this.options[item].length } : (this: { options: string[]; }, item: number) => number +>item : number + + return this.options[item].length +>this.options[item].length : number +>this.options[item] : string +>this.options : string[] +>this : { options: string[]; } +>options : string[] +>item : number +>length : number + + }, thisObject) +>thisObject : { options: string[]; } + } + + test1(options: string[]) { +>test1 : (options: string[]) => void +>options : string[] + + const thisObject = { +>thisObject : { options: ReadonlyArray; } +>{ options: [] as ReadonlyArray } : { options: ReadonlyArray; } + + options: [] as ReadonlyArray +>options : ReadonlyArray +>[] as ReadonlyArray : ReadonlyArray +>[] : undefined[] +>ReadonlyArray : ReadonlyArray + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : string +>options.find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; } +>options : string[] +>find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; } +>options : string[] +>findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>options : string[] +>forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : string[] +>options.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>options : string[] +>map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => string +>val : string +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + return this.options[index]; +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>options : string[] +>some : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : string[] +>options.filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; } +>options : string[] +>filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>options : string[] +>every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: ReadonlyArray; }, val: string, index: number) => boolean +>val : string +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : string +>this.options[index] : string +>this.options : ReadonlyArray +>this : { options: ReadonlyArray; } +>options : ReadonlyArray +>index : number + + }, thisObject); +>thisObject : { options: ReadonlyArray; } + } + + test2(options: Int8Array[]) { +>test2 : (options: Int8Array[]) => void +>options : Int8Array[] +>Int8Array : Int8Array + + const thisObject = { +>thisObject : { options: Int8Array[]; } +>{ options: [] as Int8Array[] } : { options: Int8Array[]; } + + options: [] as Int8Array[] +>options : Int8Array[] +>[] as Int8Array[] : Int8Array[] +>[] : undefined[] +>Int8Array : Int8Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Int8Array +>options.find : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; (predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; } +>options : Int8Array[] +>find : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; } +>options : Int8Array[] +>findIndex : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void): void; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: Z): void; } +>options : Int8Array[] +>forEach : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void): void; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean +>val : Int8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Int8Array[] +>options.map : { (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): U[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): U[]; } +>options : Int8Array[] +>map : { (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U]; (this: [Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): U[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => Int8Array +>val : Int8Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + return this.options[index]; +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; } +>options : Int8Array[] +>some : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean +>val : Int8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Int8Array[] +>options.filter : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any): Int8Array[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: undefined): Int8Array[]; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: Z): Int8Array[]; } +>options : Int8Array[] +>filter : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any): Int8Array[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: undefined): Int8Array[]; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: Z): Int8Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean +>val : Int8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; } +>options : Int8Array[] +>every : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean +>val : Int8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int8Array +>this.options[index] : Int8Array +>this.options : Int8Array[] +>this : { options: Int8Array[]; } +>options : Int8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int8Array[]; } + } + + test3(options: Uint8Array[]) { +>test3 : (options: Uint8Array[]) => void +>options : Uint8Array[] +>Uint8Array : Uint8Array + + const thisObject = { +>thisObject : { options: Uint8Array[]; } +>{ options: [] as Uint8Array[] } : { options: Uint8Array[]; } + + options: [] as Uint8Array[] +>options : Uint8Array[] +>[] as Uint8Array[] : Uint8Array[] +>[] : undefined[] +>Uint8Array : Uint8Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8Array +>options.find : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; (predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; } +>options : Uint8Array[] +>find : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; } +>options : Uint8Array[] +>findIndex : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void): void; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: Z): void; } +>options : Uint8Array[] +>forEach : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void): void; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean +>val : Uint8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Uint8Array[] +>options.map : { (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): U[]; } +>options : Uint8Array[] +>map : { (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => Uint8Array +>val : Uint8Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + return this.options[index]; +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint8Array[] +>some : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean +>val : Uint8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8Array[] +>options.filter : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any): Uint8Array[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: undefined): Uint8Array[]; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: Z): Uint8Array[]; } +>options : Uint8Array[] +>filter : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any): Uint8Array[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: undefined): Uint8Array[]; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: Z): Uint8Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean +>val : Uint8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint8Array[] +>every : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean +>val : Uint8Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8Array +>this.options[index] : Uint8Array +>this.options : Uint8Array[] +>this : { options: Uint8Array[]; } +>options : Uint8Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8Array[]; } + } + + test4(options: Float32Array[]) { +>test4 : (options: Float32Array[]) => void +>options : Float32Array[] +>Float32Array : Float32Array + + const thisObject = { +>thisObject : { options: Float32Array[]; } +>{ options: [] as Float32Array[] } : { options: Float32Array[]; } + + options: [] as Float32Array[] +>options : Float32Array[] +>[] as Float32Array[] : Float32Array[] +>[] : undefined[] +>Float32Array : Float32Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Float32Array +>options.find : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; (predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; } +>options : Float32Array[] +>find : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; } +>options : Float32Array[] +>findIndex : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void): void; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: Z): void; } +>options : Float32Array[] +>forEach : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void): void; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean +>val : Float32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Float32Array[] +>options.map : { (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): U[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): U[]; } +>options : Float32Array[] +>map : { (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U]; (this: [Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): U[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => Float32Array +>val : Float32Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + return this.options[index]; +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; } +>options : Float32Array[] +>some : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean +>val : Float32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Float32Array[] +>options.filter : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any): Float32Array[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: undefined): Float32Array[]; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: Z): Float32Array[]; } +>options : Float32Array[] +>filter : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any): Float32Array[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: undefined): Float32Array[]; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: Z): Float32Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean +>val : Float32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; } +>options : Float32Array[] +>every : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean +>val : Float32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float32Array +>this.options[index] : Float32Array +>this.options : Float32Array[] +>this : { options: Float32Array[]; } +>options : Float32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float32Array[]; } + } + + test5(options: Uint8ClampedArray[]) { +>test5 : (options: Uint8ClampedArray[]) => void +>options : Uint8ClampedArray[] +>Uint8ClampedArray : Uint8ClampedArray + + const thisObject = { +>thisObject : { options: Uint8ClampedArray[]; } +>{ options: [] as Uint8ClampedArray[] } : { options: Uint8ClampedArray[]; } + + options: [] as Uint8ClampedArray[] +>options : Uint8ClampedArray[] +>[] as Uint8ClampedArray[] : Uint8ClampedArray[] +>[] : undefined[] +>Uint8ClampedArray : Uint8ClampedArray + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8ClampedArray +>options.find : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; (predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; } +>options : Uint8ClampedArray[] +>find : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; } +>options : Uint8ClampedArray[] +>findIndex : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void): void; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: Z): void; } +>options : Uint8ClampedArray[] +>forEach : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void): void; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean +>val : Uint8ClampedArray +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Uint8ClampedArray[] +>options.map : { (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): U[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): U[]; } +>options : Uint8ClampedArray[] +>map : { (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U]; (this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): U[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => Uint8ClampedArray +>val : Uint8ClampedArray +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + return this.options[index]; +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; } +>options : Uint8ClampedArray[] +>some : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean +>val : Uint8ClampedArray +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Uint8ClampedArray[] +>options.filter : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any): Uint8ClampedArray[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: undefined): Uint8ClampedArray[]; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: Z): Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>filter : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any): Uint8ClampedArray[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: undefined): Uint8ClampedArray[]; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: Z): Uint8ClampedArray[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean +>val : Uint8ClampedArray +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; } +>options : Uint8ClampedArray[] +>every : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean +>val : Uint8ClampedArray +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint8ClampedArray +>this.options[index] : Uint8ClampedArray +>this.options : Uint8ClampedArray[] +>this : { options: Uint8ClampedArray[]; } +>options : Uint8ClampedArray[] +>index : number + + }, thisObject); +>thisObject : { options: Uint8ClampedArray[]; } + } + + test6(options: Int16Array[]) { +>test6 : (options: Int16Array[]) => void +>options : Int16Array[] +>Int16Array : Int16Array + + const thisObject = { +>thisObject : { options: Int16Array[]; } +>{ options: [] as Int16Array[] } : { options: Int16Array[]; } + + options: [] as Int16Array[] +>options : Int16Array[] +>[] as Int16Array[] : Int16Array[] +>[] : undefined[] +>Int16Array : Int16Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Int16Array +>options.find : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; (predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; } +>options : Int16Array[] +>find : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; } +>options : Int16Array[] +>findIndex : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void): void; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: Z): void; } +>options : Int16Array[] +>forEach : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void): void; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean +>val : Int16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Int16Array[] +>options.map : { (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): U[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): U[]; } +>options : Int16Array[] +>map : { (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U]; (this: [Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): U[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => Int16Array +>val : Int16Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + return this.options[index]; +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; } +>options : Int16Array[] +>some : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean +>val : Int16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Int16Array[] +>options.filter : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any): Int16Array[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: undefined): Int16Array[]; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: Z): Int16Array[]; } +>options : Int16Array[] +>filter : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any): Int16Array[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: undefined): Int16Array[]; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: Z): Int16Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean +>val : Int16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; } +>options : Int16Array[] +>every : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean +>val : Int16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Int16Array +>this.options[index] : Int16Array +>this.options : Int16Array[] +>this : { options: Int16Array[]; } +>options : Int16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Int16Array[]; } + } + + test7(options: Uint16Array[]) { +>test7 : (options: Uint16Array[]) => void +>options : Uint16Array[] +>Uint16Array : Uint16Array + + const thisObject = { +>thisObject : { options: Uint16Array[]; } +>{ options: [] as Uint16Array[] } : { options: Uint16Array[]; } + + options: [] as Uint16Array[] +>options : Uint16Array[] +>[] as Uint16Array[] : Uint16Array[] +>[] : undefined[] +>Uint16Array : Uint16Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint16Array +>options.find : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; (predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; } +>options : Uint16Array[] +>find : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; } +>options : Uint16Array[] +>findIndex : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void): void; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: Z): void; } +>options : Uint16Array[] +>forEach : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void): void; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean +>val : Uint16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Uint16Array[] +>options.map : { (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): U[]; } +>options : Uint16Array[] +>map : { (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => Uint16Array +>val : Uint16Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + return this.options[index]; +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint16Array[] +>some : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean +>val : Uint16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Uint16Array[] +>options.filter : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any): Uint16Array[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: undefined): Uint16Array[]; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: Z): Uint16Array[]; } +>options : Uint16Array[] +>filter : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any): Uint16Array[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: undefined): Uint16Array[]; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: Z): Uint16Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean +>val : Uint16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint16Array[] +>every : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean +>val : Uint16Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint16Array +>this.options[index] : Uint16Array +>this.options : Uint16Array[] +>this : { options: Uint16Array[]; } +>options : Uint16Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint16Array[]; } + } + + test8(options: Uint32Array[]) { +>test8 : (options: Uint32Array[]) => void +>options : Uint32Array[] +>Uint32Array : Uint32Array + + const thisObject = { +>thisObject : { options: Uint32Array[]; } +>{ options: [] as Uint32Array[] } : { options: Uint32Array[]; } + + options: [] as Uint32Array[] +>options : Uint32Array[] +>[] as Uint32Array[] : Uint32Array[] +>[] : undefined[] +>Uint32Array : Uint32Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Uint32Array +>options.find : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; (predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; } +>options : Uint32Array[] +>find : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; } +>options : Uint32Array[] +>findIndex : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void): void; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: Z): void; } +>options : Uint32Array[] +>forEach : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void): void; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean +>val : Uint32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Uint32Array[] +>options.map : { (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): U[]; } +>options : Uint32Array[] +>map : { (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U]; (this: [Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): U[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => Uint32Array +>val : Uint32Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + return this.options[index]; +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint32Array[] +>some : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean +>val : Uint32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Uint32Array[] +>options.filter : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any): Uint32Array[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: undefined): Uint32Array[]; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: Z): Uint32Array[]; } +>options : Uint32Array[] +>filter : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any): Uint32Array[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: undefined): Uint32Array[]; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: Z): Uint32Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean +>val : Uint32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; } +>options : Uint32Array[] +>every : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean +>val : Uint32Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Uint32Array +>this.options[index] : Uint32Array +>this.options : Uint32Array[] +>this : { options: Uint32Array[]; } +>options : Uint32Array[] +>index : number + + }, thisObject); +>thisObject : { options: Uint32Array[]; } + } + + test9(options: Float64Array[]) { +>test9 : (options: Float64Array[]) => void +>options : Float64Array[] +>Float64Array : Float64Array + + const thisObject = { +>thisObject : { options: Float64Array[]; } +>{ options: [] as Float64Array[] } : { options: Float64Array[]; } + + options: [] as Float64Array[] +>options : Float64Array[] +>[] as Float64Array[] : Float64Array[] +>[] : undefined[] +>Float64Array : Float64Array + + }; + + options.find(function (val, index) { +>options.find(function (val, index) { return val === this.options[index]; }, thisObject) : Float64Array +>options.find : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; (predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; } +>options : Float64Array[] +>find : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.findIndex(function (val, index) { +>options.findIndex(function (val, index) { return val === this.options[index]; }, thisObject) : number +>options.findIndex : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; (predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; } +>options : Float64Array[] +>findIndex : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; (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 + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.forEach(function (val, index) { +>options.forEach(function (val, index) { return val === this.options[index]; }, thisObject) : void +>options.forEach : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void): void; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: Z): void; } +>options : Float64Array[] +>forEach : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void): void; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: Z): void; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean +>val : Float64Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.map(function (val, index) { +>options.map(function (val, index) { if (val === this.options[index]) return this.options[index]; }, thisObject) : Float64Array[] +>options.map : { (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): U[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): U[]; } +>options : Float64Array[] +>map : { (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U]; (this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U]; (this: [Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): U[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): U[]; } +>function (val, index) { if (val === this.options[index]) return this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => Float64Array +>val : Float64Array +>index : number + + if (val === this.options[index]) +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + return this.options[index]; +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.some(function (val, index) { +>options.some(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.some : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; } +>options : Float64Array[] +>some : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean +>val : Float64Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.filter(function (val, index) { +>options.filter(function (val, index) { return val === this.options[index]; }, thisObject) : Float64Array[] +>options.filter : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any): Float64Array[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: undefined): Float64Array[]; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: Z): Float64Array[]; } +>options : Float64Array[] +>filter : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any): Float64Array[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: undefined): Float64Array[]; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: Z): Float64Array[]; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean +>val : Float64Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + + options.every(function (val, index) { +>options.every(function (val, index) { return val === this.options[index]; }, thisObject) : boolean +>options.every : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; } +>options : Float64Array[] +>every : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; } +>function (val, index) { return val === this.options[index]; } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean +>val : Float64Array +>index : number + + return val === this.options[index]; +>val === this.options[index] : boolean +>val : Float64Array +>this.options[index] : Float64Array +>this.options : Float64Array[] +>this : { options: Float64Array[]; } +>options : Float64Array[] +>index : number + + }, thisObject); +>thisObject : { options: Float64Array[]; } + } +} + diff --git a/tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts b/tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts new file mode 100644 index 00000000000..17ff41c70a7 --- /dev/null +++ b/tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts @@ -0,0 +1,398 @@ +// @target: ES2017 + +class A { + options: string[]; + + addOptions(options: string[]) { + if (!this.options) { + this.options = []; + } + options.forEach(function (item) { + this.options.push(item); + }, this); + return this; + } + + testUndefined(options: string[]) { + const undefinedArr: Array = [] + options.forEach(function () { + undefinedArr.push(this); + }); // case1 + options.forEach(function () { + undefinedArr.push(this); + }, undefined); // case2 + options.forEach(function () { + undefinedArr.push(this); + }, null); // case3 + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + } + + test(options: string[]) { + const thisObject = { + options: [] as string[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this.options[item].length + }, thisObject) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this.options[item].length + }, thisObject) + } + + test1(options: string[]) { + const thisObject = { + options: [] as ReadonlyArray + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test2(options: Int8Array[]) { + const thisObject = { + options: [] as Int8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test3(options: Uint8Array[]) { + const thisObject = { + options: [] as Uint8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test4(options: Float32Array[]) { + const thisObject = { + options: [] as Float32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test5(options: Uint8ClampedArray[]) { + const thisObject = { + options: [] as Uint8ClampedArray[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test6(options: Int16Array[]) { + const thisObject = { + options: [] as Int16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test7(options: Uint16Array[]) { + const thisObject = { + options: [] as Uint16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test8(options: Uint32Array[]) { + const thisObject = { + options: [] as Uint32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test9(options: Float64Array[]) { + const thisObject = { + options: [] as Float64Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } +}