file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
tests/unit-global/es.typed-array.fill.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.fill', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
f... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.filter.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.filter', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { f... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.find-index.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findIndex', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.find-last-index.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findLastIndex', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
co... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.find-last.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findLast', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const {... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.find.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.find', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { fin... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.for-each.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.forEach', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.from.js | JavaScript | import { DESCRIPTORS, NATIVE, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
if (DESCRIPTORS) QUnit.test('%TypedArray%.from', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (co... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.includes.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.includes', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const {... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.index-of.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.indexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.iterator.js | JavaScript | import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.keys', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.join.js | JavaScript | /* eslint-disable unicorn/require-array-join-separator -- required for testing */
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.join', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed arra... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.last-index-of.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.lastIndexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
cons... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.map.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.map', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { map ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.of.js | JavaScript | import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArray%.of', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
assert.isFunction(Typed... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.reduce-right.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduceRight', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
cons... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.reduce.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduce', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { r... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.reverse.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reverse', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.set.js | JavaScript | import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.set', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
cons... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.slice.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.slice', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { sl... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.some.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.some', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const { som... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.sort.js | JavaScript | import { DESCRIPTORS, STRICT, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.sort', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
con... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.subarray.js | JavaScript | import { DESCRIPTORS, NATIVE, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.subarray', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.to-locale-string.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toLocaleString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
c... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.to-reversed.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toReversed', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray, $ } of TYPED_ARR... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.to-sorted.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toSorted', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const {... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.to-string.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of TYPED_ARRAYS) {
const {... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed-array.with.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
import { DESCRIPTORS, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.with', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array co... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.float32.js | JavaScript | import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Float32 conversions', assert => {
const float32array = new Float32Array(1);
const uint8array = new Uint8Array(float32array.buffer);
const dataview = new DataView(float32array.buf... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.float64.js | JavaScript | import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Float64 conversions', assert => {
const float64array = new Float64Array(1);
const uint8array = new Uint8Array(float64array.buffer);
const dataview = new DataView(float64array.buf... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.int16.js | JavaScript | import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int16 conversions', assert => {
const int16array = new Int16Array(1);
const uint8array = new Uint8Array(int16array.buffer);
const dataview = new DataView(int16arr... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.int32.js | JavaScript | import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int32 conversions', assert => {
const int32array = new Int32Array(1);
const uint8array = new Uint8Array(int32array.buffer);
const dataview = new DataView(int32array.buffer);
f... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.int8.js | JavaScript | import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Int8 conversions', assert => {
const int8array = new Int8Array(1);
const uint8array = new Uint8Array(int8array.buffer);
const dataview = new DataView(int8array.bu... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.uint16.js | JavaScript | import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint16 conversions', assert => {
const uint16array = new Uint16Array(1);
const uint8array = new Uint8Array(uint16array.buffer);
const dataview = new DataView(uint... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.uint32.js | JavaScript | import { DESCRIPTORS, LITTLE_ENDIAN, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint32 conversions', assert => {
const uint32array = new Uint32Array(1);
const uint8array = new Uint8Array(uint32array.buffer);
const dataview = new DataView(uint32array.buffer);... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.uint8-clamped.js | JavaScript | import { DESCRIPTORS, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Clamped conversions', assert => {
const uint8clamped = new Uint8ClampedArray(1);
const uint8array = new Uint8Array(uint8clamped.buffer);
function toString(it) {
return it === 0 && 1 /... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.typed.conversions.uint8.js | JavaScript | import { DESCRIPTORS, GLOBAL, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NATIVE } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8 conversions', assert => {
const uint8array = new Uint8Array(1);
const dataview = new DataView(uint8array.buffer);
function viewFrom(it) {
return new DataView(new Uint... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.from-base64.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.fromBase64', assert => {
const { fromBase64 } = Uint8Array;
assert.isFunction(fromBase64);
assert.arity(fromBase64, 1);
assert.name(fromBase64, 'fromBase64');
assert.looksNative(fromBase64);
const array = new Ui... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.from-hex.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.fromHex', assert => {
const { fromHex } = Uint8Array;
assert.isFunction(fromHex);
assert.arity(fromHex, 1);
assert.name(fromHex, 'fromHex');
assert.looksNative(fromHex);
assert.true(fromHex('48656c6c6f20576f726c... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.set-from-base64.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.setFromBase64', assert => {
const { setFromBase64 } = Uint8Array.prototype;
assert.isFunction(setFromBase64);
assert.arity(setFromBase64, 1);
assert.name(setFromBase64, 'setFromBase64');
assert.looksNativ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.set-from-hex.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.setFromHex', assert => {
const { setFromHex } = Uint8Array.prototype;
assert.isFunction(setFromHex);
assert.arity(setFromHex, 1);
assert.name(setFromHex, 'setFromHex');
assert.looksNative(setFromHex);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.to-base64.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toBase64', assert => {
const { toBase64 } = Uint8Array.prototype;
assert.isFunction(toBase64);
assert.arity(toBase64, 0);
assert.name(toBase64, 'toBase64');
assert.looksNative(toBase64);
const array = ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.uint8-array.to-hex.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toHex', assert => {
const { toHex } = Uint8Array.prototype;
assert.isFunction(toHex);
assert.arity(toHex, 0);
assert.name(toHex, 'toHex');
assert.looksNative(toHex);
assert.same(new Uint8Array([72, 101... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.unescape.js | JavaScript | QUnit.test('unescape', assert => {
assert.isFunction(unescape);
assert.name(unescape, 'unescape');
assert.arity(unescape, 1);
assert.looksNative(unescape);
assert.same(unescape('%21q2%u0444'), '!q2ф');
assert.same(unescape('%u044q2%21'), '%u044q2!');
assert.same(unescape(null), 'null');
assert.same(unes... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.weak-map.get-or-insert-computed.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('WeakMap#getOrInsertComputed', assert => {
const { getOrInsertComputed } = WeakMap.prototype;
assert.isFunction(getOrInsertComputed);
assert.arity(getOrInsertComputed, 2);
assert.name(getOrInsertComputed, 'getOrInsertComputed');
assert.looksNative(... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.weak-map.get-or-insert.js | JavaScript | QUnit.test('WeakMap#getOrInsert', assert => {
const { getOrInsert } = WeakMap.prototype;
assert.isFunction(getOrInsert);
assert.arity(getOrInsert, 2);
assert.name(getOrInsert, 'getOrInsert');
assert.looksNative(getOrInsert);
assert.nonEnumerable(WeakMap.prototype, 'getOrInsert');
const a = {};
const b ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.weak-map.js | JavaScript | import { DESCRIPTORS, FREEZING, GLOBAL, NATIVE } from '../helpers/constants.js';
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const { freeze, isFrozen, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/es.weak-set.js | JavaScript | import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants.js';
import { createIterable, nativeSubclass } from '../helpers/helpers.js';
const Symbol = GLOBAL.Symbol || {};
const { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakSet'... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.filter-out.js | JavaScript | // TODO: Remove from `core-js@4`
import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#filterOut', assert => {
const { filterOut } = Array.prototype;
assert.isFunction(filterOut);
assert.arity(filterOut, 1);
assert.name(filterOut, 'filterOut');
assert.looksNative(filterOut);
assert.nonEnumera... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.filter-reject.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#filterReject', assert => {
const { filterReject } = Array.prototype;
assert.isFunction(filterReject);
assert.arity(filterReject, 1);
assert.name(filterReject, 'filterReject');
assert.looksNative(filterReject);
assert.nonEnumerable(Array.pr... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.group-by-to-map.js | JavaScript | import { STRICT } from '../helpers/constants.js';
const { from } = Array;
QUnit.test('Array#groupByToMap', assert => {
const { groupByToMap } = Array.prototype;
assert.isFunction(groupByToMap);
assert.arity(groupByToMap, 1);
assert.looksNative(groupByToMap);
assert.nonEnumerable(Array.prototype, 'groupByToM... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.group-by.js | JavaScript | import { STRICT } from '../helpers/constants.js';
const { getPrototypeOf } = Object;
QUnit.test('Array#groupBy', assert => {
const { groupBy } = Array.prototype;
assert.isFunction(groupBy);
assert.arity(groupBy, 1);
assert.name(groupBy, 'groupBy');
assert.looksNative(groupBy);
assert.nonEnumerable(Array.p... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.group-to-map.js | JavaScript | import { STRICT } from '../helpers/constants.js';
const { from } = Array;
QUnit.test('Array#groupToMap', assert => {
const { groupToMap } = Array.prototype;
assert.isFunction(groupToMap);
assert.arity(groupToMap, 1);
assert.name(groupToMap, 'groupToMap');
assert.looksNative(groupToMap);
assert.nonEnumerab... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.group.js | JavaScript | import { STRICT } from '../helpers/constants.js';
const { getPrototypeOf } = Object;
QUnit.test('Array#group', assert => {
const { group } = Array.prototype;
assert.isFunction(group);
assert.arity(group, 1);
assert.name(group, 'group');
assert.looksNative(group);
assert.nonEnumerable(Array.prototype, 'gro... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.is-template-object.js | JavaScript | QUnit.test('Array.isTemplateObject', assert => {
const { isTemplateObject } = Array;
const { freeze } = Object;
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.looksNative(isTemplateObject);
assert.nonEnumerable(Array, 'isT... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.last-index.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Array#lastIndex', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastIndex');
assert.isFunction(descriptor.get);
assert.false(descriptor.enumerable);
assert.true(descriptor.configurable);
ass... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.last-item.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('Array#lastItem', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastItem');
assert.isFunction(descriptor.get);
assert.isFunction(descriptor.set);
assert.false(descriptor.enumerable);
assert.t... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.array.unique-by.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('Array#uniqueBy', assert => {
const { uniqueBy } = Array.prototype;
assert.isFunction(uniqueBy);
assert.arity(uniqueBy, 1);
assert.name(uniqueBy, 'uniqueBy');
assert.looksNative(uniqueBy);
assert.nonEnumerable(Array.prototype, 'uniqueBy');
let... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.as-indexed-pairs.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
// assert.name(asIndexedPairs... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.constructor.js | JavaScript | import { nativeSubclass } from '../helpers/helpers.js';
const { getPrototypeOf } = Object;
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.name(AsyncIterator, 'AsyncIterator');
assert.looksNative(AsyncIterator);
const asyncGenerator = (() => ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.drop.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#drop', assert => {
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, 'drop');
assert.looksNative(drop);
assert.nonEn... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.every.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#every', assert => {
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(ev... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.filter.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#filter', assert => {
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNat... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.find.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#find', assert => {
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.flat-map.js | JavaScript | import { createIterator, createIterable } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
const { from } = AsyncIterator;
QUnit.test('AsyncIterator#flatMap', assert => {
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.for-each.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#forEach', assert => {
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.lo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.from.js | JavaScript | import ITERATOR from 'core-js-pure/es/symbol/iterator';
const { assign, create } = Object;
QUnit.test('AsyncIterator.from', assert => {
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(AsyncIterator, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.indexed.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#indexed', assert => {
const { indexed } = AsyncIterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.name(indexed, 'indexed');
assert.looksNative(ind... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.map.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#map', assert => {
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.reduce.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#reduce', assert => {
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNat... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.some.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { STRICT, STRICT_THIS } from '../helpers/constants.js';
QUnit.test('AsyncIterator#some', assert => {
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.take.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#take', assert => {
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, 'take');
assert.looksNative(take);
assert.nonEn... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.async-iterator.to-array.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('AsyncIterator#toArray', assert => {
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, 'toArray');
assert.looksNative(toA... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.bigint.range.js | JavaScript | /* eslint-disable es/no-bigint -- safe */
if (typeof BigInt == 'function') QUnit.test('BigInt.range', assert => {
const { range } = BigInt;
const { from } = Array;
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
assert.looksNative(range);
assert.nonEnumerable(BigInt, 'range'... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.composite-key.js | JavaScript |
import { FREEZING } from '../helpers/constants.js';
const { getPrototypeOf, isFrozen } = Object;
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
assert.name(compositeKey, 'compositeKey');
assert.looksNative(compositeKey);
const key = compositeKey({});
assert.same(typeof key, 'objec... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.composite-symbol.js | JavaScript |
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
assert.name(compositeSymbol, 'compositeSymbol');
assert.looksNative(compositeSymbol);
assert.true(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.same(compositeSymb... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.data-view.set-uint8-clamped.js | JavaScript | import { DESCRIPTORS, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from '../helpers/constants.js';
QUnit.test('DataView.prototype.{ getUint8Clamped, setUint8Clamped }', assert => {
const { getUint8Clamped, setUint8Clamped } = DataView.prototype;
assert.isFunction(getUint8Clamped);
assert.arity(getUint8Clamped, 1);
as... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.function.demethodize.js | JavaScript | QUnit.test('Function#demethodize', assert => {
const { demethodize } = Function.prototype;
assert.isFunction(demethodize);
assert.arity(demethodize, 0);
assert.name(demethodize, 'demethodize');
assert.looksNative(demethodize);
assert.nonEnumerable(Function.prototype, 'demethodize');
assert.same(function (... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.function.is-callable.js | JavaScript | import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isCallable', assert => {
const { isCallable } = Function;
assert.isFunction(isCallable);
assert.arity(isCallable, 1);
assert.name(isCallable, 'isCallable');
assert.looksNative(isCallable);
assert.nonEnumerable(Function, 'isCallable');... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.function.is-constructor.js | JavaScript | import { fromSource } from '../helpers/helpers.js';
QUnit.test('Function.isConstructor', assert => {
const { isConstructor } = Function;
assert.isFunction(isConstructor);
assert.arity(isConstructor, 1);
assert.name(isConstructor, 'isConstructor');
assert.looksNative(isConstructor);
assert.nonEnumerable(Fun... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.function.metadata.js | JavaScript | QUnit.test('Function#@@metadata', assert => {
assert.true(Symbol.metadata in Function.prototype);
assert.same(Function.prototype[Symbol.metadata], null, 'is null');
});
| zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.function.un-this.js | JavaScript | QUnit.test('Function#unThis', assert => {
const { unThis } = Function.prototype;
assert.isFunction(unThis);
assert.arity(unThis, 0);
// assert.name(unThis, 'unThis');
assert.looksNative(unThis);
assert.nonEnumerable(Function.prototype, 'unThis');
assert.same(function () { return 42; }.unThis()(), 42);
a... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.as-indexed-pairs.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
// assert.name(asIndexedPairs, 'asIndex... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.chunks.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#chunks', assert => {
const { chunks } = Iterator.prototype;
assert.isFunction(chunks);
assert.arity(chunks, 1);
assert.name(chunks, 'chunks');
assert.looksN... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.indexed.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator#indexed', assert => {
const { indexed } = Iterator.prototype;
assert.isFunction(indexed);
assert.arity(indexed, 0);
assert.name(indexed, 'indexed');
assert.looksNative(indexed);
a... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.range.js | JavaScript | import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
/* eslint-disable es/no-bigint -- safe */
QUnit.test('Iterator.range', assert => {
const { range } = Iterator;
const { from } = Array;
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
assert.looksNative(range);
asser... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.sliding.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#sliding', assert => {
const { sliding } = Iterator.prototype;
assert.isFunction(sliding);
assert.arity(sliding, 1);
assert.name(sliding, 'sliding');
assert.... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.to-async.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import ITERATOR from 'core-js-pure/es/symbol/iterator';
QUnit.test('Iterator#toAsync', assert => {
const { toAsync } = Iterator.prototype;
assert.isFunction(toAsync);
assert.arity(toAsync, 0);
assert.name(toAsync, 'toAsync');
assert.looksNative(toAsync);
a... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.windows.js | JavaScript | import { STRICT } from '../helpers/constants.js';
import { createIterator } from '../helpers/helpers.js';
const { from } = Array;
QUnit.test('Iterator#windows', assert => {
const { windows } = Iterator.prototype;
assert.isFunction(windows);
assert.arity(windows, 1);
assert.name(windows, 'windows');
assert.... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.zip-keyed.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
import { DESCRIPTORS } from '../helpers/constants.js';
function nullProto(obj) {
return Object.assign(Object.create(null), obj);
}
QUnit.test('Iterator.zipKeyed', assert => {
const { zipKeyed } = Iterator;
const { from } = Array;
const { defineProperty }... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.iterator.zip.js | JavaScript | import { createIterator } from '../helpers/helpers.js';
QUnit.test('Iterator.zip', assert => {
const { zip } = Iterator;
const { from } = Array;
assert.isFunction(zip);
assert.arity(zip, 1);
assert.name(zip, 'zip');
assert.looksNative(zip);
assert.nonEnumerable(Iterator, 'zip');
let result = zip([[1,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.delete-all.js | JavaScript | QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
const { from } = Array;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let set = new Map([[1, 2]... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.emplace.js | JavaScript | QUnit.test('Map#emplace', assert => {
const { emplace } = Map.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.looksNative(emplace);
assert.nonEnumerable(Map.prototype, 'emplace');
const map = new Map([['a', 2]]);
let handler = {
update(value,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.every.js | JavaScript | QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.filter.js | JavaScript | QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
const { from } = Array;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.find-key.js | JavaScript | QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.arity(findKey, 1);
assert.name(findKey, 'findKey');
assert.looksNative(findKey);
assert.nonEnumerable(Map.prototype, 'findKey');
const set = new Map([[1, 2]]);
const context = {};
set.findKey(... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.find.js | JavaScript | QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Map.prototype, 'find');
const set = new Map([[1, 2]]);
const context = {};
set.find(function (value, key, that)... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.from.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Map.from', assert => {
const { from } = Map;
const toArray = Array.from;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Map, 'from');
assert.true(from([]) insta... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.includes.js | JavaScript | QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.looksNative(includes);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.key-by.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
const toArray = Array.from;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.looksNative(keyBy);
assert.nonEnumerable(Map, 'keyBy');
assert.true(Map.... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.