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/esnext.map.key-of.js | JavaScript | QUnit.test('Map#keyOf', assert => {
const { keyOf } = Map.prototype;
assert.isFunction(keyOf);
assert.name(keyOf, 'keyOf');
assert.arity(keyOf, 1);
assert.looksNative(keyOf);
assert.nonEnumerable(Map.prototype, 'keyOf');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, objec... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.map-keys.js | JavaScript | QUnit.test('Map#mapKeys', assert => {
const { mapKeys } = Map.prototype;
const { from } = Array;
assert.isFunction(mapKeys);
assert.arity(mapKeys, 1);
assert.name(mapKeys, 'mapKeys');
assert.looksNative(mapKeys);
assert.nonEnumerable(Map.prototype, 'mapKeys');
const map = new Map([[1, 2]]);
const co... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.map-values.js | JavaScript | QUnit.test('Map#mapValues', assert => {
const { mapValues } = Map.prototype;
const { from } = Array;
assert.isFunction(mapValues);
assert.arity(mapValues, 1);
assert.name(mapValues, 'mapValues');
assert.looksNative(mapValues);
assert.nonEnumerable(Map.prototype, 'mapValues');
const map = new Map([[1, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.merge.js | JavaScript | QUnit.test('Map#merge', assert => {
const { merge } = Map.prototype;
const { from } = Array;
assert.isFunction(merge);
assert.arity(merge, 1);
assert.name(merge, 'merge');
assert.looksNative(merge);
assert.nonEnumerable(Map.prototype, 'merge');
const map = new Map([[1, 2]]);
const result = map.merge... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.of.js | JavaScript | QUnit.test('Map.of', assert => {
const { of } = Map;
const toArray = Array.from;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(Map, 'of');
assert.true(of() instanceof Map);
assert.deepEqual(toArray(of([1, 2])), [[1, 2]]);
assert.deepE... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.reduce.js | JavaScript | QUnit.test('Map#reduce', assert => {
const { reduce } = Map.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Map.prototype, 'reduce');
const set = new Map([['a', 1]]);
const accumulator = {};
set.reduce(fun... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.some.js | JavaScript | QUnit.test('Map#some', assert => {
const { some } = Map.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Map.prototype, 'some');
let map = new Map([[9, 1]]);
const context = {};
map.some(function (value, key, that) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.update-or-insert.js | JavaScript | QUnit.test('Map#updateOrInsert', assert => {
const { updateOrInsert } = Map.prototype;
assert.isFunction(updateOrInsert);
assert.arity(updateOrInsert, 2);
assert.looksNative(updateOrInsert);
assert.nonEnumerable(Map.prototype, 'updateOrInsert');
const map = new Map([['a', 2]]);
assert.same(map.updateOrIn... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.update.js | JavaScript | QUnit.test('Map#update', assert => {
const { update } = Map.prototype;
assert.isFunction(update);
assert.arity(update, 2);
assert.name(update, 'update');
assert.looksNative(update);
assert.nonEnumerable(Map.prototype, 'update');
let map = new Map([[9, 2]]);
assert.same(map.update(9, function (value, ke... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.map.upsert.js | JavaScript | QUnit.test('Map#upsert', assert => {
const { upsert } = Map.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.looksNative(upsert);
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.upsert('a', function (value) {
assert.same(arguments.l... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.clamp.js | JavaScript | QUnit.test('Math.clamp', assert => {
const { clamp } = Math;
assert.isFunction(clamp);
assert.name(clamp, 'clamp');
assert.arity(clamp, 3);
assert.looksNative(clamp);
assert.nonEnumerable(Math, 'clamp');
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.deg-per-rad.js | JavaScript | QUnit.test('Math.DEG_PER_RAD', assert => {
const { DEG_PER_RAD, PI } = Math;
assert.true('DEG_PER_RAD' in Math, 'DEG_PER_RAD in Math');
assert.nonEnumerable(Math, 'DEG_PER_RAD');
assert.nonConfigurable(Number, 'DEG_PER_RAD');
assert.nonWritable(Number, 'DEG_PER_RAD');
assert.same(DEG_PER_RAD, PI / 180, 'Is ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.degrees.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.degrees', assert => {
const { degrees, PI } = Math;
assert.isFunction(degrees);
assert.name(degrees, 'degrees');
assert.arity(degrees, 1);
assert.looksNative(degrees);
assert.nonEnumerable(Math, 'degrees');
assert.same(degr... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.fscale.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.fscale', assert => {
const { fscale, fround, PI } = Math;
assert.isFunction(fscale);
assert.name(fscale, 'fscale');
assert.arity(fscale, 5);
assert.looksNative(fscale);
assert.nonEnumerable(Math, 'fscale');
assert.same(fsca... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.iaddh.js | JavaScript | QUnit.test('Math.iaddh', assert => {
const { iaddh } = Math;
assert.isFunction(iaddh);
assert.name(iaddh, 'iaddh');
assert.arity(iaddh, 4);
assert.looksNative(iaddh);
assert.nonEnumerable(Math, 'iaddh');
assert.same(iaddh(0, 2, 1, 0), 2);
assert.same(iaddh(0, 4, 1, 1), 5);
assert.same(iaddh(2, 4, 1, 1... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.imulh.js | JavaScript | QUnit.test('Math.imulh', assert => {
const { imulh } = Math;
assert.isFunction(imulh);
assert.name(imulh, 'imulh');
assert.arity(imulh, 2);
assert.looksNative(imulh);
assert.nonEnumerable(Math, 'imulh');
assert.same(imulh(0xFFFFFFFF, 7), -1);
assert.same(imulh(0xFFFFFFF, 77), 4);
assert.same(imulh(1, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.isubh.js | JavaScript | QUnit.test('Math.isubh', assert => {
const { isubh } = Math;
assert.isFunction(isubh);
assert.name(isubh, 'isubh');
assert.arity(isubh, 4);
assert.looksNative(isubh);
assert.nonEnumerable(Math, 'isubh');
assert.same(isubh(0, 2, 1, 0), 1);
assert.same(isubh(0, 4, 1, 1), 2);
assert.same(isubh(2, 4, 1, 1... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.rad-per-deg.js | JavaScript | QUnit.test('Math.RAD_PER_DEG', assert => {
const { RAD_PER_DEG, PI } = Math;
assert.true('RAD_PER_DEG' in Math, 'RAD_PER_DEG in Math');
assert.nonEnumerable(Math, 'RAD_PER_DEG');
assert.nonConfigurable(Number, 'RAD_PER_DEG');
assert.nonWritable(Number, 'RAD_PER_DEG');
assert.same(RAD_PER_DEG, 180 / PI, 'Is ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.radians.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.radians', assert => {
const { radians, PI } = Math;
assert.isFunction(radians);
assert.name(radians, 'radians');
assert.arity(radians, 1);
assert.looksNative(radians);
assert.nonEnumerable(Math, 'radians');
assert.same(radi... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.scale.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.scale', assert => {
const { scale } = Math;
assert.isFunction(scale);
assert.name(scale, 'scale');
assert.arity(scale, 5);
assert.looksNative(scale);
assert.nonEnumerable(Math, 'scale');
assert.same(scale(3, 1, 2, 1, 2), 3)... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.seeded-prng.js | JavaScript | QUnit.test('Math.seededPRNG', assert => {
const { seededPRNG } = Math;
assert.isFunction(seededPRNG);
assert.name(seededPRNG, 'seededPRNG');
assert.arity(seededPRNG, 1);
assert.looksNative(seededPRNG);
assert.nonEnumerable(Math, 'seededPRNG');
for (const gen of [seededPRNG({ seed: 42 }), seededPRNG({ see... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.signbit.js | JavaScript | import { createConversionChecker } from '../helpers/helpers.js';
QUnit.test('Math.signbit', assert => {
const { signbit } = Math;
assert.isFunction(signbit);
assert.name(signbit, 'signbit');
assert.arity(signbit, 1);
assert.looksNative(signbit);
assert.nonEnumerable(Math, 'signbit');
assert.false(signbit... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.math.umulh.js | JavaScript | QUnit.test('Math.umulh', assert => {
const { umulh } = Math;
assert.isFunction(umulh);
assert.name(umulh, 'umulh');
assert.arity(umulh, 2);
assert.looksNative(umulh);
assert.nonEnumerable(Math, 'umulh');
assert.same(umulh(0xFFFFFFFF, 7), 6);
assert.same(umulh(0xFFFFFFF, 77), 4);
assert.same(umulh(1, 7... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.number.clamp.js | JavaScript | QUnit.test('Number#clamp', assert => {
const { clamp } = Number.prototype;
assert.isFunction(clamp);
assert.name(clamp, 'clamp');
assert.arity(clamp, 2);
assert.looksNative(clamp);
assert.nonEnumerable(Number.prototype, 'clamp');
assert.same(clamp.call(2, 4, 6), 4);
assert.same(clamp.call(4, 2, 6), 4);... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.number.from-string.js | JavaScript | QUnit.test('Number.fromString', assert => {
const { fromString } = Number;
assert.isFunction(fromString);
assert.name(fromString, 'fromString');
assert.arity(fromString, 2);
assert.looksNative(fromString);
assert.nonEnumerable(Number, 'fromString');
assert.throws(() => fromString(undefined), TypeError, 'T... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.number.range.js | JavaScript | import { MAX_SAFE_INTEGER } from '../helpers/constants.js';
QUnit.test('Number.range', assert => {
const { range } = Number;
const { from } = Array;
assert.isFunction(range);
assert.name(range, 'range');
assert.arity(range, 3);
assert.looksNative(range);
assert.nonEnumerable(Number, 'range');
let iter... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.object.iterate-entries.js | JavaScript | QUnit.test('Object.iterateEntries', assert => {
const { iterateEntries } = Object;
assert.isFunction(iterateEntries);
assert.name(iterateEntries, 'iterateEntries');
assert.arity(iterateEntries, 1);
assert.looksNative(iterateEntries);
assert.nonEnumerable(Object, 'iterateEntries');
const object = {
q:... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.object.iterate-keys.js | JavaScript | QUnit.test('Object.iterateKeys', assert => {
const { iterateKeys } = Object;
assert.isFunction(iterateKeys);
assert.name(iterateKeys, 'iterateKeys');
assert.arity(iterateKeys, 1);
assert.looksNative(iterateKeys);
assert.nonEnumerable(Object, 'iterateKeys');
const object = {
q: 1,
w: 2,
e: 3,
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.object.iterate-values.js | JavaScript | QUnit.test('Object.iterateValues', assert => {
const { iterateValues } = Object;
assert.isFunction(iterateValues);
assert.name(iterateValues, 'iterateValues');
assert.arity(iterateValues, 1);
assert.looksNative(iterateValues);
assert.nonEnumerable(Object, 'iterateValues');
const object = {
q: 1,
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.observable.constructor.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('Observable', assert => {
assert.isFunction(Observable);
assert.arity(Observable, 1);
assert.name(Observable, 'Observable');
assert.looksNative(Observable);
assert.throws(() => Observable(() => { /* empty */ }), 'throws w/o `new`');
const observa... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.observable.from.js | JavaScript | QUnit.test('Observable.from', assert => {
assert.isFunction(Observable.from);
assert.arity(Observable.from, 1);
assert.name(Observable.from, 'from');
assert.looksNative(Observable.from);
const results1 = [];
Observable.from([1, 2, 3]).subscribe({ next: v => results1.push(v) });
assert.deepEqual(results1,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.observable.of.js | JavaScript | QUnit.test('Observable.of', assert => {
assert.isFunction(Observable.of);
assert.arity(Observable.of, 0);
assert.name(Observable.of, 'of');
assert.looksNative(Observable.of);
});
| zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.define-metadata.js | JavaScript | QUnit.test('Reflect.defineMetadata', assert => {
const { defineMetadata } = Reflect;
assert.isFunction(defineMetadata);
assert.arity(defineMetadata, 3);
assert.name(defineMetadata, 'defineMetadata');
assert.looksNative(defineMetadata);
assert.nonEnumerable(Reflect, 'defineMetadata');
assert.throws(() => d... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.delete-metadata.js | JavaScript | QUnit.test('Reflect.deleteMetadata', assert => {
const { defineMetadata, hasOwnMetadata, deleteMetadata } = Reflect;
const { create } = Object;
assert.isFunction(deleteMetadata);
assert.arity(deleteMetadata, 2);
assert.name(deleteMetadata, 'deleteMetadata');
assert.looksNative(deleteMetadata);
assert.nonE... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.get-metadata-keys.js | JavaScript | QUnit.test('Reflect.getMetadataKeys', assert => {
const { defineMetadata, getMetadataKeys } = Reflect;
const { create } = Object;
assert.isFunction(getMetadataKeys);
assert.arity(getMetadataKeys, 1);
assert.name(getMetadataKeys, 'getMetadataKeys');
assert.looksNative(getMetadataKeys);
assert.nonEnumerable... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.get-metadata.js | JavaScript | QUnit.test('Reflect.getMetadata', assert => {
const { defineMetadata, getMetadata } = Reflect;
const { create } = Object;
assert.isFunction(getMetadata);
assert.arity(getMetadata, 2);
assert.name(getMetadata, 'getMetadata');
assert.looksNative(getMetadata);
assert.nonEnumerable(Reflect, 'getMetadata');
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.get-own-metadata-keys.js | JavaScript | QUnit.test('Reflect.getOwnMetadataKeys', assert => {
const { defineMetadata, getOwnMetadataKeys } = Reflect;
const { create } = Object;
assert.isFunction(getOwnMetadataKeys);
assert.arity(getOwnMetadataKeys, 1);
assert.name(getOwnMetadataKeys, 'getOwnMetadataKeys');
assert.looksNative(getOwnMetadataKeys);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.get-own-metadata.js | JavaScript | QUnit.test('Reflect.getOwnMetadata', assert => {
const { defineMetadata, getOwnMetadata } = Reflect;
const { create } = Object;
assert.isFunction(getOwnMetadata);
assert.arity(getOwnMetadata, 2);
assert.name(getOwnMetadata, 'getOwnMetadata');
assert.looksNative(getOwnMetadata);
assert.nonEnumerable(Reflec... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.has-metadata.js | JavaScript | QUnit.test('Reflect.hasMetadata', assert => {
const { defineMetadata, hasMetadata } = Reflect;
const { create } = Object;
assert.isFunction(hasMetadata);
assert.arity(hasMetadata, 2);
assert.name(hasMetadata, 'hasMetadata');
assert.looksNative(hasMetadata);
assert.nonEnumerable(Reflect, 'hasMetadata');
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.has-own-metadata.js | JavaScript | QUnit.test('Reflect.hasOwnMetadata', assert => {
const { defineMetadata, hasOwnMetadata } = Reflect;
const { create } = Object;
assert.isFunction(hasOwnMetadata);
assert.arity(hasOwnMetadata, 2);
assert.name(hasOwnMetadata, 'hasOwnMetadata');
assert.looksNative(hasOwnMetadata);
assert.nonEnumerable(Reflec... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.reflect.metadata.js | JavaScript | QUnit.test('Reflect.metadata', assert => {
const { metadata, hasOwnMetadata } = Reflect;
assert.isFunction(metadata);
assert.arity(metadata, 2);
assert.name(metadata, 'metadata');
assert.looksNative(metadata);
assert.isFunction(metadata('key', 'value'));
assert.nonEnumerable(Reflect, 'metadata');
const ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.add-all.js | JavaScript | QUnit.test('Set#addAll', assert => {
const { addAll } = Set.prototype;
const { from } = Array;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.looksNative(addAll);
assert.nonEnumerable(Set.prototype, 'addAll');
const set = new Set([1]);
assert.same(set.addAl... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.delete-all.js | JavaScript | QUnit.test('Set#deleteAll', assert => {
const { deleteAll } = Set.prototype;
const { from } = Array;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(Set.prototype, 'deleteAll');
let set = new Set([1, 2, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.every.js | JavaScript | QUnit.test('Set#every', assert => {
const { every } = Set.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Set.prototype, 'every');
const set = new Set([1]);
const context = {};
set.every(function (value, key, t... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.filter.js | JavaScript | QUnit.test('Set#filter', assert => {
const { filter } = Set.prototype;
const { from } = Array;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Set.prototype, 'filter');
const set = new Set([1]);
const context = {};
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.find.js | JavaScript | QUnit.test('Set#find', assert => {
const { find } = Set.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Set.prototype, 'find');
const set = new Set([1]);
const context = {};
set.find(function (value, key, that) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.from.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('Set.from', assert => {
const { from } = Set;
const toArray = Array.from;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Set, 'from');
assert.true(from([]) insta... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.join.js | JavaScript | /* eslint-disable unicorn/require-array-join-separator -- required for testing */
QUnit.test('Set#join', assert => {
const { join } = Set.prototype;
assert.isFunction(join);
assert.arity(join, 1);
assert.name(join, 'join');
assert.looksNative(join);
assert.nonEnumerable(Set.prototype, 'join');
assert.sa... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.map.js | JavaScript | QUnit.test('Set#map', assert => {
const { map } = Set.prototype;
const { from } = Array;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(Set.prototype, 'map');
const set = new Set([1]);
const context = {};
set.map(function (value... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.of.js | JavaScript | QUnit.test('Set.of', assert => {
const { of } = Set;
const toArray = Array.from;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(Set, 'of');
assert.true(of() instanceof Set);
assert.deepEqual(toArray(of(1)), [1]);
assert.deepEqual(toArr... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.reduce.js | JavaScript | QUnit.test('Set#reduce', assert => {
const { reduce } = Set.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Set.prototype, 'reduce');
const set = new Set([1]);
const accumulator = {};
set.reduce(function (... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.set.some.js | JavaScript | QUnit.test('Set#some', assert => {
const { some } = Set.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Set.prototype, 'some');
const set = new Set([1]);
const context = {};
set.some(function (value, key, that) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.string.at.js | JavaScript | import { STRICT } from '../helpers/constants.js';
QUnit.test('String#at', assert => {
const { at } = String.prototype;
assert.isFunction(at);
assert.arity(at, 1);
assert.name(at, 'at');
assert.looksNative(at);
assert.nonEnumerable(String.prototype, 'at');
// String that starts with a BMP symbol
// asse... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.string.code-points.js | JavaScript | import { GLOBAL } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#codePoints', assert => {
const { codePoints } = String.prototype;
assert.isFunction(codePoints);
assert.arity(codePoints, 0);
assert.name(codePoints, 'codePoints');
assert.looksNative(codePoints);
asse... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.string.cooked.js | JavaScript | QUnit.test('String.cooked', assert => {
const { cooked } = String;
assert.isFunction(cooked);
assert.arity(cooked, 1);
assert.name(cooked, 'cooked');
assert.looksNative(cooked);
assert.nonEnumerable(String, 'cooked');
assert.same(cooked(['Hi\\n', '!'], 'Bob'), 'Hi\\nBob!', 'template is an array');
asser... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.string.dedent.js | JavaScript | const freeze = Object.freeze || Object;
QUnit.test('String.dedent', assert => {
const { cooked, dedent } = String;
assert.isFunction(dedent);
assert.arity(dedent, 1);
assert.name(dedent, 'dedent');
assert.looksNative(dedent);
assert.nonEnumerable(String, 'dedent');
assert.same(dedent`
qwe
asd
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.custom-matcher.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.customMatcher', assert => {
assert.true('customMatcher' in Symbol, 'Symbol.customMatcher available');
assert.nonEnumerable(Symbol, 'customMatcher');
assert.true(Object(Symbol.customMatcher) instanceof Symbol, 'Symbol.customMatcher is symbo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.is-registered-symbol.js | JavaScript | QUnit.test('Symbol.isRegisteredSymbol', assert => {
const { isRegisteredSymbol } = Symbol;
assert.isFunction(isRegisteredSymbol, 'Symbol.isRegisteredSymbol is function');
assert.nonEnumerable(Symbol, 'isRegisteredSymbol');
assert.arity(isRegisteredSymbol, 1, 'Symbol.isRegisteredSymbol arity is 1');
assert.nam... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.is-registered.js | JavaScript | QUnit.test('Symbol.isRegistered', assert => {
const { isRegistered } = Symbol;
assert.isFunction(isRegistered, 'Symbol.isRegistered is function');
assert.nonEnumerable(Symbol, 'isRegistered');
assert.arity(isRegistered, 1, 'Symbol.isRegistered arity is 1');
assert.name(isRegistered, 'isRegisteredSymbol', 'Sym... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.is-well-known-symbol.js | JavaScript | QUnit.test('Symbol.isWellKnownSymbol', assert => {
const { isWellKnownSymbol } = Symbol;
assert.isFunction(isWellKnownSymbol, 'Symbol.isWellKnownSymbol is function');
assert.nonEnumerable(Symbol, 'isWellKnownSymbol');
assert.arity(isWellKnownSymbol, 1, 'Symbol.isWellKnownSymbol arity is 1');
assert.name(isWel... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.is-well-known.js | JavaScript | QUnit.test('Symbol.isWellKnown', assert => {
const { isWellKnown } = Symbol;
assert.isFunction(isWellKnown, 'Symbol.isWellKnown is function');
assert.nonEnumerable(Symbol, 'isWellKnown');
assert.arity(isWellKnown, 1, 'Symbol.isWellKnown arity is 1');
assert.name(isWellKnown, 'isWellKnownSymbol', 'Symbol.isWel... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.matcher.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.matcher', assert => {
assert.true('matcher' in Symbol, 'Symbol.matcher available');
assert.nonEnumerable(Symbol, 'matcher');
assert.true(Object(Symbol.matcher) instanceof Symbol, 'Symbol.matcher is symbol');
if (DESCRIPTORS) {
const ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.metadata-key.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.metadataKey', assert => {
assert.true('metadataKey' in Symbol, 'Symbol.metadataKey available');
assert.nonEnumerable(Symbol, 'metadataKey');
assert.true(Object(Symbol.metadataKey) instanceof Symbol, 'Symbol.metadataKey is symbol');
if (D... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.metadata.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.metadata', assert => {
assert.true('metadata' in Symbol, 'Symbol.metadata available');
assert.nonEnumerable(Symbol, 'metadata');
assert.true(Object(Symbol.metadata) instanceof Symbol, 'Symbol.metadata is symbol');
if (DESCRIPTORS) {
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.observable.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.observable', assert => {
assert.true('observable' in Symbol, 'Symbol.observable available');
assert.nonEnumerable(Symbol, 'observable');
assert.true(Object(Symbol.observable) instanceof Symbol, 'Symbol.observable is symbol');
if (DESCRIP... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.pattern-match.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.patternMatch', assert => {
assert.true('patternMatch' in Symbol, 'Symbol.patternMatch available');
assert.nonEnumerable(Symbol, 'patternMatch');
assert.true(Object(Symbol.patternMatch) instanceof Symbol, 'Symbol.patternMatch is symbol');
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.symbol.replace-all.js | JavaScript | import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('Symbol.replaceAll', assert => {
assert.true('replaceAll' in Symbol, 'Symbol.replaceAll is available');
assert.nonEnumerable(Symbol, 'replaceAll');
assert.true(Object(Symbol.replaceAll) instanceof Symbol, 'Symbol.replaceAll is symbol');
if (DESC... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.typed-array.filter-out.js | JavaScript | // TODO: Remove from `core-js@4`
import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.filterOut', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArra... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.typed-array.filter-reject.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.filterReject', 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/esnext.typed-array.from-async.js | JavaScript | import { createAsyncIterable, createIterable } from '../helpers/helpers.js';
import { DESCRIPTORS, STRICT_THIS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArray } of T... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.typed-array.group-by.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
const { getPrototypeOf } = Object;
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.groupBy', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { name, TypedArr... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.typed-array.to-spliced.js | JavaScript | // TODO: Remove from `core-js@4`
import { DESCRIPTORS, TYPED_ARRAYS_WITH_BIG_INT } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toSpliced', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const { na... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.typed-array.unique-by.js | JavaScript | import { DESCRIPTORS, TYPED_ARRAYS } from '../helpers/constants.js';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.uniqueBy', 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/esnext.weak-map.delete-all.js | JavaScript | QUnit.test('WeakMap#deleteAll', assert => {
const { deleteAll } = WeakMap.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(WeakMap.prototype, 'deleteAll');
const a = [];
const b = [];
const c... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-map.emplace.js | JavaScript | QUnit.test('WeakMap#emplace', assert => {
const { emplace } = WeakMap.prototype;
assert.isFunction(emplace);
assert.arity(emplace, 2);
assert.name(emplace, 'emplace');
assert.looksNative(emplace);
assert.nonEnumerable(WeakMap.prototype, 'emplace');
const a = {};
const b = {};
const map = new WeakMap... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-map.from.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('WeakMap.from', assert => {
const { from } = WeakMap;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(WeakMap, 'from');
assert.true(from([]) instanceof WeakMap);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-map.of.js | JavaScript | QUnit.test('WeakMap.of', assert => {
const { of } = WeakMap;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(WeakMap, 'of');
const array = [];
assert.true(of() instanceof WeakMap);
assert.same(of([array, 2]).get(array), 2);
});
| zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-map.upsert.js | JavaScript | QUnit.test('WeakMap#upsert', assert => {
const { upsert } = WeakMap.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.looksNative(upsert);
assert.nonEnumerable(WeakMap.prototype, 'upsert');
const a = {};
const b = {};
const map = new WeakMap([[a, 2]]);
assert.same(map.upsert(a, f... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-set.add-all.js | JavaScript | QUnit.test('WeakSet#addAll', assert => {
const { addAll } = WeakSet.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.looksNative(addAll);
assert.nonEnumerable(WeakSet.prototype, 'addAll');
const a = [];
const b = [];
const c = [];
let set = new ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-set.delete-all.js | JavaScript | QUnit.test('WeakSet#deleteAll', assert => {
const { deleteAll } = WeakSet.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(WeakSet.prototype, 'deleteAll');
const a = [];
const b = [];
const c... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-set.from.js | JavaScript | import { createIterable } from '../helpers/helpers.js';
QUnit.test('WeakSet.from', assert => {
const { from } = WeakSet;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(WeakSet, 'from');
assert.true(from([]) instanceof WeakSet);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/esnext.weak-set.of.js | JavaScript | QUnit.test('WeakSet.of', assert => {
const { of } = WeakSet;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(WeakSet, 'of');
const array = [];
assert.true(of() instanceof WeakSet);
assert.true(of(array).has(array));
});
| zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.atob.js | JavaScript | // based on https://github.com/davidchambers/Base64.js/blob/master/test/base64.js
import { NODE } from '../helpers/constants.js';
QUnit.test('atob', assert => {
assert.isFunction(atob);
assert.arity(atob, 1);
assert.name(atob, 'atob');
if (!NODE) assert.looksNative(atob);
assert.same(atob(''), '');
assert... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.btoa.js | JavaScript | // based on https://github.com/davidchambers/Base64.js/blob/master/test/base64.js
import { NODE } from '../helpers/constants.js';
QUnit.test('btoa', assert => {
assert.isFunction(btoa);
assert.arity(btoa, 1);
assert.name(btoa, 'btoa');
if (!NODE) assert.looksNative(btoa);
assert.same(btoa(''), '');
assert... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.dom-collections.for-each.js | JavaScript | import { GLOBAL } from '../helpers/constants.js';
QUnit.test('forEach method on iterable DOM collections', assert => {
let absent = true;
const collections = [
'NodeList',
'DOMTokenList',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
absent = fal... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.dom-collections.iterator.js | JavaScript | import { GLOBAL } from '../helpers/constants.js';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('Iterable DOM collections', assert => {
let absent = true;
let collections = [
'CSSRuleList',
'CSSStyleDeclaration',
'CSSValueList',
'ClientRectList',
'DOMRectList',
'DOMStringList',
'DOMTo... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.dom-exception.constructor.js | JavaScript | import { DESCRIPTORS, NODE } from '../helpers/constants.js';
const errors = {
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4,... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.queue-microtask.js | JavaScript | import { NODE } from '../helpers/constants.js';
import { timeLimitedPromise } from '../helpers/helpers.js';
QUnit.test('queueMicrotask', assert => {
assert.isFunction(queueMicrotask);
assert.arity(queueMicrotask, 1);
assert.name(queueMicrotask, 'queueMicrotask');
if (!NODE) assert.looksNative(queueMicrotask);
... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.self.js | JavaScript | /* eslint-disable no-restricted-globals, unicorn/prefer-global-this -- safe */
import { DESCRIPTORS } from '../helpers/constants.js';
QUnit.test('self', assert => {
assert.same(self, Object(self), 'is object');
assert.same(self.Math, Math, 'contains globals');
if (DESCRIPTORS) {
const descriptor = Object.get... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.set-immediate.js | JavaScript | import { timeLimitedPromise } from '../helpers/helpers.js';
QUnit.test('setImmediate / clearImmediate', assert => {
assert.isFunction(setImmediate, 'setImmediate is function');
assert.isFunction(clearImmediate, 'clearImmediate is function');
assert.name(setImmediate, 'setImmediate');
assert.name(clearImmediate... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.set-interval.js | JavaScript | import { timeLimitedPromise } from '../helpers/helpers.js';
QUnit.test('setInterval / clearInterval', assert => {
assert.isFunction(setInterval, 'setInterval is function');
assert.isFunction(clearInterval, 'clearInterval is function');
assert.name(setInterval, 'setInterval');
assert.name(clearInterval, 'clearI... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.set-timeout.js | JavaScript | import { timeLimitedPromise } from '../helpers/helpers.js';
QUnit.test('setTimeout / clearTimeout', assert => {
assert.isFunction(setTimeout, 'setTimeout is function');
assert.isFunction(clearTimeout, 'clearTimeout is function');
assert.name(setTimeout, 'setTimeout');
assert.name(clearTimeout, 'clearTimeout');... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.structured-clone.js | JavaScript | // Originally from: https://github.com/web-platform-tests/wpt/blob/4b35e758e2fc4225368304b02bcec9133965fd1a/IndexedDB/structured-clone.any.js
// Copyright © web-platform-tests contributors. Available under the 3-Clause BSD License.
import { GLOBAL, NODE, BUN } from '../helpers/constants.js';
import { bufferToArray, fro... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.url-search-params.js | JavaScript | import { DESCRIPTORS, NODE, BUN } from '../helpers/constants.js';
import { createIterable } from '../helpers/helpers.js';
const { getPrototypeOf, getOwnPropertyDescriptor } = Object;
QUnit.test('URLSearchParams', assert => {
assert.isFunction(URLSearchParams);
assert.arity(URLSearchParams, 0);
assert.name(URLSe... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.url.can-parse.js | JavaScript | import { NODE } from '../helpers/constants.js';
QUnit.test('URL.canParse', assert => {
const { canParse } = URL;
assert.isFunction(canParse);
assert.arity(canParse, 1);
assert.name(canParse, 'canParse');
if (!NODE) assert.looksNative(canParse);
assert.false(canParse(undefined), 'undefined');
assert.fal... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.url.js | JavaScript | /* eslint-disable unicorn/relative-url-style -- required for testing */
import { DESCRIPTORS, NODE } from '../helpers/constants.js';
import urlTestData from '../wpt-url-resources/urltestdata.js';
import settersTestData from '../wpt-url-resources/setters.js';
import toASCIITestData from '../wpt-url-resources/toascii.js'... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-global/web.url.parse.js | JavaScript | import { NODE } from '../helpers/constants.js';
QUnit.test('URL.parse', assert => {
const { parse } = URL;
assert.isFunction(parse);
assert.arity(parse, 1);
assert.name(parse, 'parse');
if (!NODE) assert.looksNative(parse);
assert.same(parse(undefined), null, 'undefined');
assert.same(parse(undefined, ... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-karma/karma.conf.js | JavaScript | 'use strict';
const { chromium, firefox, webkit } = require('playwright');
const { sync: which } = require('which');
Object.assign(process.env, {
CHROMIUM_BIN: chromium.executablePath(),
FIREFOX_BIN: firefox.executablePath(),
WEBKIT_BIN: webkit.executablePath(),
});
const customLaunchers = {
IE_NFM: {
bas... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-karma/runner.mjs | JavaScript | if (process.env.CI) await $`playwright install-deps`;
$.quote = it => `'${ it }'`;
await Promise.all([
['packages/core-js-bundle/index', 'tests/bundles/unit-global'],
['packages/core-js-bundle/minified', 'tests/bundles/unit-global'],
['tests/bundles/unit-pure'],
].map(files => $`karma start -f=${ files.map(file... | zloirock/core-js | 25,418 | Standard Library | JavaScript | zloirock | Denis Pushkarev | |
tests/unit-node/runner.mjs | JavaScript | await Promise.all([
['packages/core-js/index', 'tests/bundles/unit-global'],
['packages/core-js/index', 'packages/core-js-bundle/index', 'tests/bundles/unit-global'],
['tests/bundles/unit-pure'],
].map(files => $`qunit ${ files.map(file => `${ file }.js`) }`));
| 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.