core-js

Standard library

core-js

Modular compact standard library for JavaScript. Includes polyfills for ECMAScript 5, ECMAScript 6: symbols, collections, iterators, promises, ECMAScript 7 proposals; setImmediate, array generics. Some additional features such as dictionaries or extended partial application. You can require only standardized features polyfills, use features without global namespace pollution or create a custom build.

Example:

Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] 
'*'.repeat(10);                       // => '**********' 
Promise.resolve(32).then(log);        // => 32 
setImmediate(log, 42);                // => 42 

Without global namespace pollution:

var core = require('core-js/library'); // With a modular system, otherwise use global `core` 
core.Array.from(new core.Set([1, 2, 3, 2, 1])); // => [1, 2, 3] 
core.String.repeat('*', 10);                    // => '**********' 
core.Promise.resolve(32).then(core.log);        // => 32 
core.setImmediate(core.log, 42);                // => 42 
npm i core-js
bower install core.js
// Default 
require('core-js');
// Without global namespace pollution 
var core = require('core-js/library');
// Shim only 
require('core-js/shim');

If you need complete build for browser, use builds from core-js/client path: default, without global namespace pollution, shim only.

Warning: if you uses core-js with extension of native objects, require all needed core-js modules at the beginning of entry point of your application, otherwise maybe conflicts.

You can require only needed modules.

require('core-js/es5'); // if you need support IE8- 
require('core-js/fn/set');
require('core-js/fn/array/from');
require('core-js/fn/array/find-index');
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] 
[1, 2, NaN, 3, 4].findIndex(isNaN);   // => 2 
 
// or, w/o global namespace pollution: 
 
var core      = require('core-js/library/es5'); // if you need support IE8- 
var Set       = require('core-js/library/fn/set');
var from      = require('core-js/library/fn/array/from');
var findIndex = require('core-js/library/fn/array/find-index');
from(new Set([1, 2, 3, 2, 1]));      // => [1, 2, 3] 
findIndex([1, 2, NaN, 3, 4], isNaN); // => 2 

Available entry points for methods / constructors, as above examples, excluding features from es5 module (this module requires completely in ES3 environment before all other modules).

Available namespaces: for example, core-js/es6/array (core-js/library/es6/array) contains all ES6 Array features, core-js/es6 (core-js/library/es6) contains all ES6 features.

npm i core-js && cd node_modules/core-js && npm i
npm run grunt build:core.dict,es6 -- --blacklist=es6.promise,es6.math --library=on --path=custom uglify

Where core.dict and es6 are modules (namespaces) names, which will be added to the build, es6.promise and es6.math are modules (namespaces) names, which will be excluded from the build, --library=on is flag for build without global namespace pollution and custom is target file name.

Available namespaces: for example, es6.array contains ES6 Array features, es6 contains all modules whose names start with es6.

Available custom build from js code (required webpack):

require('core-js/build')({
  modules: ['es6', 'core.dict'], // modules / namespaces 
  blacklist: ['es6.reflect'],    // blacklist of modules / namespaces 
  library: false,                // flag for build without global namespace pollution 
}, function(errcode){          // callback 
  // ... 
});

Module es5, nothing new - without examples.

Object
  .create(proto | null, descriptors?) -> object
  .getPrototypeOf(object) -> proto | null
  .defineProperty(target, key, desc) -> target, cap for ie8-
  .defineProperties(target, descriptors) -> target, cap for ie8-
  .getOwnPropertyDescriptor(object, key) -> desc
  .getOwnPropertyNames(object) -> array
  .keys(object) -> array
Array
  .isArray(var) -> bool
  #slice(start?, end?) -> array, fix for ie7-
  #join(string = ',') -> string, fix for ie7-
  #indexOf(var, from?) -> int
  #lastIndexOf(var, from?) -> int
  #every(fn(val, index, @), that) -> bool
  #some(fn(val, index, @), that) -> bool
  #forEach(fn(val, index, @), that) -> void
  #map(fn(val, index, @), that) -> array
  #filter(fn(val, index, @), that) -> array
  #reduce(fn(memo, val, index, @), memo?) -> var
  #reduceRight(fn(memo, val, index, @), memo?) -> var
Function
  #bind(object, ...args) -> boundFn(...args)
Date
  .now() -> int
  #toISOString() -> string

Some features moved to another modules / namespaces, but available as part of es5 namespace too:

Object
  .seal(object) -> object, cap for ie8-
  .freeze(object) -> object, cap for ie8-
  .preventExtensions(object) -> object, cap for ie8-
  .isSealed(object) -> bool, cap for ie8-
  .isFrozen(object) -> bool, cap for ie8-
  .isExtensible(object) -> bool, cap for ie8-
String
  #trim() -> str

Modules es6.object.assign, es6.object.is, es6.object.set-prototype-of and es6.object.to-string.

Object
  .assign(target, ...src) -> target
  .is(a, b) -> bool
  .setPrototypeOf(target, proto | null) -> target (required __proto__ - IE11+)
  #toString() -> string, ES6 fix: @@toStringTag support

Example:

var foo = {q: 1, w: 2}
  , bar = {e: 3, r: 4}
  , baz = {t: 5, y: 6};
Object.assign(foo, bar, baz); // => foo = {q: 1, w: 2, e: 3, r: 4, t: 5, y: 6} 
 
Object.is(NaN, NaN); // => true 
Object.is(0, -0);    // => false 
Object.is(42, 42);   // => true 
Object.is(42, '42'); // => false 
 
function Parent(){}
function Child(){}
Object.setPrototypeOf(Child.prototype, Parent.prototype);
new Child instanceof Child;  // => true 
new Child instanceof Parent; // => true 
 
var O = {};
O[Symbol.toStringTag] = 'Foo';
'' + O; // => '[object Foo]' 

In ES6 most Object static methods should work with primitives. Modules es6.object.freeze, es6.object.seal, es6.object.prevent-extensions, es6.object.is-frozen, es6.object.is-sealed, es6.object.is-extensible, es6.object.get-own-property-descriptor, es6.object.get-prototype-of, es6.object.keys, es6.object.get-own-property-names.

Object
  .freeze(var) -> var
  .seal(var) -> var
  .preventExtensions(var) -> var
  .isFrozen(var) -> bool
  .isSealed(var) -> bool
  .isExtensible(var) -> bool
  .getOwnPropertyDescriptor(var, key) -> desc | undefined
  .getPrototypeOf(var) -> object | null
  .keys(var) -> array
  .getOwnPropertyNames(var) -> array

Example:

Object.keys('qwe'); // => ['0', '1', '2'] 
Object.getPrototypeOf('qwe') === String.prototype; // => true 

Modules es6.function.name and es6.function.has-instance.

Function
  #name -> string (IE9+)
  #@@hasInstance(var) -> bool

Example:

(function foo(){}).name // => 'foo' 

Modules es6.array.from, es6.array.of, es6.array.copy-within, es6.array.fill, es6.array.find and es6.array.find-index.

Array
  .from(iterable | array-like, mapFn(val, index)?, that) -> array
  .of(...args) -> array
  #copyWithin(target = 0, start = 0, end = @length) -> @
  #fill(val, start = 0, end = @length) -> @
  #find(fn(val, index, @), that) -> val
  #findIndex(fn(val, index, @), that) -> index
  #@@unscopables -> object (cap)

Example:

Array.from(new Set([1, 2, 3, 2, 1]));      // => [1, 2, 3] 
Array.from({0: 1, 1: 2, 2: 3, length: 3}); // => [1, 2, 3] 
Array.from('123', Number);                 // => [1, 2, 3] 
Array.from('123', function(it){
  return it * it;
});                                        // => [1, 4, 9] 
 
Array.of(1);       // => [1] 
Array.of(1, 2, 3); // => [1, 2, 3] 
 
function isOdd(val){
  return val % 2;
}
[4, 8, 15, 16, 23, 42].find(isOdd);      // => 15 
[4, 8, 15, 16, 23, 42].findIndex(isOdd); // => 2 
[4, 8, 15, 16, 23, 42].find(isNaN);      // => undefined 
[4, 8, 15, 16, 23, 42].findIndex(isNaN); // => -1 
 
Array(5).fill(42); // => [42, 42, 42, 42, 42] 
 
[1, 2, 3, 4, 5].copyWithin(0, 3); // => [4, 5, 3, 4, 5] 

Modules es6.string.from-code-point, es6.string.raw, es6.string.code-point-at, es6.string.ends-with, es6.string.includes, es6.string.repeat, es6.string.starts-with and es6.string.trim.

String
  .fromCodePoint(...codePoints) -> str
  .raw({raw}, ...substitutions) -> str
  #includes(str, from?) -> bool
  #startsWith(str, from?) -> bool
  #endsWith(str, from?) -> bool
  #repeat(num) -> str
  #codePointAt(pos) -> uint
  #trim() -> str, ES6 fix

Examples:

'foobarbaz'.includes('bar');      // => true 
'foobarbaz'.includes('bar', 4);   // => false 
'foobarbaz'.startsWith('foo');    // => true 
'foobarbaz'.startsWith('bar', 3); // => true 
'foobarbaz'.endsWith('baz');      // => true 
'foobarbaz'.endsWith('bar', 6);   // => true 
 
'string'.repeat(3); // => 'stringstringstring' 
 
'𠮷'.codePointAt(0)// =134071
String.fromCodePoint(97, 134071, 98); // => 'a𠮷b' 
 
var name = 'Bob';
String.raw`Hi\n${name}!`;           // => 'Hi\\nBob!' (ES6 template string syntax) 
String.raw({raw: 'test'}, 0, 1, 2); // => 't0e1s2t' 

Modules es6.regexp.constructor and es6.regexp.flags.

Support well-known symbols @@match, @@replace, @@search and @@split, modules es6.regexp.match, es6.regexp.replace, es6.regexp.search and es6.regexp.split.

String
  #match(tpl) -> var, ES6 fix for support @@match
  #replace(tpl, replacer) -> var, ES6 fix for support @@replace
  #search(tpl) -> var, ES6 fix for support @@search
  #split(tpl, limit) -> var, ES6 fix for support @@split
[new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+)
  #flags -> str (IE9+)
  #@@match(str) -> array | null
  #@@replace(str, replacer) -> string
  #@@search(str) -> index
  #@@split(str, limit) -> array

Examples:

RegExp(/./g, 'm'); // => /./m 
 
/foo/.flags;    // => '' 
/foo/gim.flags; // => 'gim' 
 
'foo'.match({[Symbol.match]: _ => 1});     // => 1 
'foo'.replace({[Symbol.replace]: _ => 2}); // => 2 
'foo'.search({[Symbol.search]: _ => 3});   // => 3 
'foo'.split({[Symbol.split]: _ => 4});     // => 4 

Module es6.number.constructor. Number constructor support binary and octal literals, example:

Number('0b1010101'); // => 85 
Number('0o7654321'); // => 2054353 

Number: modules es6.number.epsilon, es6.number.is-finite, es6.number.is-integer, es6.number.is-nan, es6.number.is-safe-integer, es6.number.max-safe-integer, es6.number.min-safe-integer, es6.number.parse-float, es6.number.parse-int.

[new] Number(var) -> number | number object
  .EPSILON -> num
  .isFinite(num) -> bool
  .isInteger(num) -> bool
  .isNaN(num) -> bool
  .isSafeInteger(num) -> bool
  .MAX_SAFE_INTEGER -> int
  .MIN_SAFE_INTEGER -> int
  .parseFloat(str) -> num
  .parseInt(str) -> int

Math: modules es6.math.acosh, es6.math.asinh, es6.math.atanh, es6.math.cbrt, es6.math.clz32, es6.math.cosh, es6.math.expm1, es6.math.fround, es6.math.hypot, es6.math.imul, es6.math.log10, es6.math.log1p, es6.math.log2, es6.math.sign, es6.math.sinh, es6.math.tanh, es6.math.trunc.

Math
  .acosh(num) -> num
  .asinh(num) -> num
  .atanh(num) -> num
  .cbrt(num) -> num
  .clz32(num) -> uint
  .cosh(num) -> num
  .expm1(num) -> num
  .fround(num) -> num
  .hypot(...args) -> num
  .imul(num, num) -> int
  .log1p(num) -> num
  .log10(num) -> num
  .log2(num) -> num
  .sign(num) -> 1 | -1 | 0 | -0 | NaN
  .sinh(num) -> num
  .tanh(num) -> num
  .trunc(num) -> num

Module es6.symbol.

Symbol(description?) -> symbol
  .hasInstance -> @@hasInstance
  .isConcatSpreadable -> @@isConcatSpreadable
  .iterator -> @@iterator
  .match -> @@match
  .replace -> @@replace
  .search -> @@search
  .species -> @@species
  .split -> @@split
  .toPrimitive -> @@toPrimitive
  .toStringTag -> @@toStringTag
  .unscopables -> @@unscopables
  .for(key) -> symbol
  .keyFor(symbol) -> key
  .useSimple() -> void
  .useSetter() -> void
Object
  .getOwnPropertySymbols(object) -> array

Also wrapped some Object methods for correct work with Symbol polyfill.

Object
  .create(proto | null, descriptors?) -> object
  .defineProperty(target, key, desc) -> target
  .defineProperties(target, descriptors) -> target
  .getOwnPropertyDescriptor(var, key) -> desc | undefined
  .getOwnPropertyNames(var) -> array
  #propertyIsEnumerable(key) -> bool

Basic example:

var Person = (function(){
  var NAME = Symbol('name');
  function Person(name){
    this[NAME] = name;
  }
  Person.prototype.getName = function(){
    return this[NAME];
  };
  return Person;
})();
 
var person = new Person('Vasya');
log(person.getName());          // => 'Vasya' 
log(person['name']);            // => undefined 
log(person[Symbol('name')]);    // => undefined, symbols are uniq 
for(var key in person)log(key); // => only 'getName', symbols are not enumerable 

Symbol.for & Symbol.keyFor example:

var symbol = Symbol.for('key');
symbol === Symbol.for('key'); // true 
Symbol.keyFor(symbol);        // 'key' 

Example with methods for getting own object keys:

var O = {a: 1};
Object.defineProperty(O, 'b', {value: 2});
O[Symbol('c')] = 3;
Object.keys(O);                  // => ['a'] 
Object.getOwnPropertyNames(O);   // => ['a', 'b'] 
Object.getOwnPropertySymbols(O); // => [Symbol(c)] 
Reflect.ownKeys(O);              // => ['a', 'b', Symbol(c)] 
  • We can't add new primitive type, Symbol returns object.
  • Symbol.for and Symbol.keyFor can't be shimmed cross-realm.
  • By default, to hide the keys, Symbol polyfill defines setter in Object.prototype. For this reason, uncontrolled creation of symbols can cause memory leak and the in operator is not working correctly with Symbol polyfill: Symbol() in {} // => true.

You can disable defining setters in Object.prototype. Example:

Symbol.useSimple();
var s1 = Symbol('s1')
  , o1 = {};
o1[s1] = true;
for(var key in o1)log(key); // => 'Symbol(s1)_t.qamkg9f3q', w/o native Symbol 
 
Symbol.useSetter();
var s2 = Symbol('s2')
  , o2 = {};
o2[s2] = true;
for(var key in o2)log(key); // nothing 
  • Currently, core-js not adds setters to Object.prototype for well-known symbols for correct work something like Symbol.iterator in foo. It can cause problems with their enumerability.

core-js uses native collections in most case, just fixes methods / constructor, if it's required, and in old environment uses fast polyfill (O(1) lookup).

Module es6.map. About iterators from this module here.

new Map(iterable (entries) ?) -> map
  #clear() -> void
  #delete(key) -> bool
  #forEach(fn(val, key, @), that) -> void
  #get(key) -> val
  #has(key) -> bool
  #set(key, val) -> @
  #size -> uint

Example:

var a = [1];
 
var map = new Map([['a', 1], [42, 2]]);
map.set(a, 3).set(true, 4);
 
log(map.size);        // => 4 
log(map.has(a));      // => true 
log(map.has([1]));    // => false 
log(map.get(a));      // => 3 
map.forEach(function(valkey){
  log(val);           // => 1, 2, 3, 4 
  log(key);           // => 'a', 42, [1], true 
});
map.delete(a);
log(map.size);        // => 3 
log(map.get(a));      // => undefined 
log(Array.from(map)); // => [['a', 1], [42, 2], [true, 4]] 

Module es6.set. About iterators from this module here.

new Set(iterable?) -> set
  #add(key) -> @
  #clear() -> void
  #delete(key) -> bool
  #forEach(fn(el, el, @), that) -> void
  #has(key) -> bool
  #size -> uint

Example:

var set = new Set(['a', 'b', 'a', 'c']);
set.add('d').add('b').add('e');
log(set.size);        // => 5 
log(set.has('b'));    // => true 
set.forEach(function(it){
  log(it);            // => 'a', 'b', 'c', 'd', 'e' 
});
set.delete('b');
log(set.size);        // => 4 
log(set.has('b'));    // => false 
log(Array.from(set)); // => ['a', 'c', 'd', 'e'] 

Module es6.weak-map.

new WeakMap(iterable (entries) ?) -> weakmap
  #delete(key) -> bool
  #get(key) -> val
  #has(key) -> bool
  #set(key, val) -> @

Example:

var a = [1]
  , b = [2]
  , c = [3];
 
var wmap = new WeakMap([[a, 1], [b, 2]]);
wmap.set(c, 3).set(b, 4);
log(wmap.has(a));   // => true 
log(wmap.has([1])); // => false 
log(wmap.get(a));   // => 1 
wmap.delete(a);
log(wmap.get(a));   // => undefined 
 
// Private properties store: 
var Person = (function(){
  var names = new WeakMap;
  function Person(name){
    names.set(this, name);
  }
  Person.prototype.getName = function(){
    return names.get(this);
  };
  return Person;
})();
 
var person = new Person('Vasya');
log(person.getName());          // => 'Vasya' 
for(var key in person)log(key); // => only 'getName' 

Module es6.weak-set.

new WeakSet(iterable?) -> weakset
  #add(key) -> @
  #delete(key) -> bool
  #has(key) -> bool

Example:

var a = [1]
  , b = [2]
  , c = [3];
 
var wset = new WeakSet([a, b, a]);
wset.add(c).add(b).add(c);
log(wset.has(b));   // => true 
log(wset.has([2])); // => false 
wset.delete(b);
log(wset.has(b));   // => false 
  • Frozen objects as collection keys are supported, but not recomended - it's slow (O(n) instead of O(1)) and, for weak-collections, leak.
  • Weak-collections polyfill stores values as hidden properties of keys. It works correct and not leak in most cases. However, it is desirable to store a collection longer than its keys.

Modules es6.string.iterator and es6.array.iterator:

String
  #@@iterator() -> iterator
Array
  #values() -> iterator
  #keys() -> iterator
  #entries() -> iterator (entries)
  #@@iterator() -> iterator
Arguments
  #@@iterator() -> iterator (available only in core-js methods)

Modules es6.map and es6.set:

Map
  #values() -> iterator
  #keys() -> iterator
  #entries() -> iterator (entries)
  #@@iterator() -> iterator (entries)
Set
  #values() -> iterator
  #keys() -> iterator
  #entries() -> iterator (entries)
  #@@iterator() -> iterator

Module web.dom.iterable:

NodeList
  #@@iterator() -> iterator

Example:

var string = 'a𠮷b';
 
for(var val of string)log(val);         // => 'a', '𠮷', 'b' 
 
var array = ['a', 'b', 'c'];
 
for(var val of array)log(val);          // => 'a', 'b', 'c' 
for(var val of array.values())log(val); // => 'a', 'b', 'c' 
for(var key of array.keys())log(key);   // => 0, 1, 2 
for(var [key, val] of array.entries()){
  log(key);                             // => 0, 1, 2 
  log(val);                             // => 'a', 'b', 'c' 
}
 
var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
 
for(var [key, val] of map){
  log(key);                             // => 'a', 'b', 'c' 
  log(val);                             // => 1, 2, 3 
}
for(var val of map.values())log(val);   // => 1, 2, 3 
for(var key of map.keys())log(key);     // => 'a', 'b', 'c' 
for(var [key, val] of map.entries()){
  log(key);                             // => 'a', 'b', 'c' 
  log(val);                             // => 1, 2, 3 
}
 
var set = new Set([1, 2, 3, 2, 1]);
 
for(var val of set)log(val);            // => 1, 2, 3 
for(var val of set.values())log(val);   // => 1, 2, 3 
for(var key of set.keys())log(key);     // => 1, 2, 3 
for(var [key, val] of set.entries()){
  log(key);                             // => 1, 2, 3 
  log(val);                             // => 1, 2, 3 
}
 
for(var x of document.querySelectorAll('*')){
  log(x.id);
}

Modules core.is-iterable, core.get-iterator, core.get-iterator-method - helpers for check iterable / get iterator in library version or, for example, for arguments object:

core
  .isIterable(var) -> bool
  .getIterator(iterable) -> iterator
  .getIteratorMethod(var) -> function | undefined

Example:

var list = (function(){
  return arguments;
})(1, 2, 3);
 
log(core.isIterable(list)); // true; 
 
var iter = core.getIterator(list);
log(iter.next().value); // 1 
log(iter.next().value); // 2 
log(iter.next().value); // 3 
log(iter.next().value); // undefined 
 
core.getIterator({});   // TypeError: [object Object] is not iterable! 
 
var iterFn = core.getIteratorMethod(list);
log(typeof iterFn);     // 'function' 
var iter = iterFn.call(list);
log(iter.next().value); // 1 
log(iter.next().value); // 2 
log(iter.next().value); // 3 
log(iter.next().value); // undefined 
 
log(core.getIteratorMethod({})); // undefined 

Module es6.promise.

new Promise(executor(resolve(var), reject(var))) -> promise
  #then(resolved(var), rejected(var)) -> promise
  #catch(rejected(var)) -> promise
  .resolve(var || promise) -> promise
  .reject(var) -> promise
  .all(iterable) -> promise
  .race(iterable) -> promise

Basic example:

function sleepRandom(time){
  return new Promise(function(resolvereject){
    setTimeout(resolve, time * 1e3, 0 | Math.random() * 1e3);
  });
}
 
log('Run');                    // => Run 
sleepRandom(5).then(function(result){
  log(result);                 // => 869, after 5 sec. 
  return sleepRandom(10);
}).then(function(result){
  log(result);                 // => 202, after 10 sec. 
}).then(function(){
  log('immediately after');    // => immediately after 
  throw Error('Irror!');
}).then(function(){
  log('will not be displayed');
}).catch(log);                 // => => Error: Irror! 

Promise.resolve and Promise.reject example:

Promise.resolve(42).then(log); // => 42 
Promise.reject(42).catch(log); // => 42 
 
Promise.resolve($.getJSON('/data.json')); // => ES6 promise 

Promise.all example:

Promise.all([
  'foo',
  sleepRandom(5),
  sleepRandom(15),
  sleepRandom(10)  // after 15 sec: 
]).then(log);      // => ['foo', 956, 85, 382] 

Promise.race example:

function timeLimit(promisetime){
  return Promise.race([promise, new Promise(function(resolvereject){
    setTimeout(reject, time * 1e3, Error('Await > ' + time + ' sec'));
  })]);
}
 
timeLimit(sleepRandom(5), 10).then(log);   // => 853, after 5 sec. 
timeLimit(sleepRandom(15), 10).catch(log); // Error: Await > 10 sec 

ECMAScript 7 async functions example:

var delay = time => new Promise(resolve => setTimeout(resolve, time))
 
async function sleepRandom(time){
  await delay(time * 1e3);
  return 0 | Math.random() * 1e3;
};
async function sleepError(timemsg){
  await delay(time * 1e3);
  throw Error(msg);
};
 
(async () => {
  try {
    log('Run');                // => Run 
    log(await sleepRandom(5)); // => 936, after 5 sec. 
    var [a, b, c] = await Promise.all([
      sleepRandom(5),
      sleepRandom(15),
      sleepRandom(10)
    ]);
    log(a, b, c);              // => 210 445 71, after 15 sec. 
    await sleepError(5, 'Irror!');
    log('Will not be displayed');
  } catch(e){
    log(e);                    // => Error: 'Irror!', after 5 sec. 
  }
})();

core-js Promise supports (but not adds to native implementations) unhandled rejection tracking. In browser you will see notify in console, in node.js / io.js you can use unhandledRejection event.

Modules es6.reflect.apply, es6.reflect.construct, es6.reflect.define-property, es6.reflect.delete-property, es6.reflect.enumerate, es6.reflect.get, es6.reflect.get-own-property-descriptor, es6.reflect.get-prototype-of, es6.reflect.has, es6.reflect.is-extensible, es6.reflect.own-keys, es6.reflect.prevent-extensions, es6.reflect.set, es6.reflect.set-prototype-of.

Reflect
  .apply(target, thisArgument, argumentsList) -> var
  .construct(target, argumentsList, newTarget?) -> object
  .defineProperty(target, propertyKey, attributes) -> bool
  .deleteProperty(target, propertyKey) -> bool
  .enumerate(target) -> iterator
  .get(target, propertyKey, receiver?) -> var
  .getOwnPropertyDescriptor(target, propertyKey) -> desc
  .getPrototypeOf(target) -> object | null
  .has(target, propertyKey) -> bool
  .isExtensible(target) -> bool
  .ownKeys(target) -> array
  .preventExtensions(target) -> bool
  .set(target, propertyKey, V, receiver?) -> bool
  .setPrototypeOf(target, proto) -> bool (required __proto__ - IE11+)

Example:

var O = {a: 1};
Object.defineProperty(O, 'b', {value: 2});
O[Symbol('c')] = 3;
Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)] 
 
function C(ab){
  this.= a + b;
}
 
var instance = Reflect.construct(C, [20, 22]);
instance.c; // => 42 
Array
  #includes(var, from?) -> bool
String
  #at(index) -> string
  #padLeft(length, fillStr = ' ') -> string
  #padRight(length, fillStr = ' ') -> string
  #trimLeft() -> string
  #trimRight() -> string
Object
  .values(object) -> array
  .entries(object) -> array
  .getOwnPropertyDescriptors(object) -> object
RegExp
  .escape(str) -> str
Map
  #toJSON() -> array
Set
  #toJSON() -> array

Examples:

[1, 2, 3].includes(2);        // => true 
[1, 2, 3].includes(4);        // => false 
[1, 2, 3].includes(2, 2);     // => false 
 
[NaN].indexOf(NaN);           // => -1 
[NaN].includes(NaN);          // => true 
Array(1).indexOf(undefined);  // => -1 
Array(1).includes(undefined); // => true 
 
'a𠮷b'.at(1);        // ='𠮷'
'a𠮷b'.at(1).length// =2
 
'hello'.padLeft(10);          // => '     hello' 
'hello'.padLeft(10, '1234');  // => '41234hello' 
'hello'.padRight(10);         // => 'hello     ' 
'hello'.padRight(10, '1234'); // => 'hello12341' 
 
'   hello   '.trimLeft();  // => 'hello   ' 
'   hello   '.trimRight(); // => '   hello' 
 
Object.values({a: 1, b: 2, c: 3});  // => [1, 2, 3] 
Object.entries({a: 1, b: 2, c: 3}); // => [['a', 1], ['b', 2], ['c', 3]] 
 
// Shallow object cloning with prototype and descriptors: 
var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O));
// Mixin: 
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
 
RegExp.escape('Hello, []{}()*+?.\\^$|!'); // => 'Hello, \[\]\{\}\(\)\*\+\?\.\\\^\$\|!' 
 
JSON.stringify(new Map([['a', 'b'], ['c', 'd']])); // => '[["a","b"],["c","d"]]' 
JSON.stringify(new Set([1, 2, 3, 2, 1]));          // => '[1,2,3]' 

Module js.array.statics.

Array
  .{...ArrayPrototype methods}
Array.slice(arguments, 1);
 
Array.join('abcdef', '+'); // => 'a+b+c+d+e+f' 
 
var form = document.getElementsByClassName('form__input');
Array.reduce(form, function(memoit){
  memo[it.name] = it.value;
  return memo;
}, {}); // => {name: 'Vasya', age: '42', sex: 'yes, please'} 

Module web.timers. Additional arguments fix for IE9-.

setTimeout(fn(...args), time, ...args) -> id
setInterval(fn(...args), time, ...args) -> id
// Before: 
setTimeout(log.bind(null, 42), 1000);
// After: 
setTimeout(log, 1000, 42);

Module web.immediate. setImmediate polyfill.

setImmediate(fn(...args), ...args) -> id
clearImmediate(id) -> void

Example:

setImmediate(function(arg1arg2){
  log(arg1, arg2); // => Message will be displayed with minimum delay 
}, 'Message will be displayed', 'with minimum delay');
 
clearImmediate(setImmediate(function(){
  log('Message will not be displayed');
}));

Module core.log. Console cap for old browsers and some additional functionality. In IE, Node.js / IO.js and Firebug console methods not require call from console object, but in Chromium and V8 this throws error. For some reason, we can't replace console methods by their bound versions. Add log object with bound console methods. Some more sugar: log is shortcut for log.log, we can disable output.

log ==== log.log
  .{...console API}
  .enable() -> void
  .disable() -> void
// Before: 
if(window.console && console.warn)console.warn(42);
// After: 
log.warn(42);
 
// Before: 
setTimeout(console.warn.bind(console, 42), 1000);
[1, 2, 3].forEach(console.warn, console);
// After: 
setTimeout(log.warn, 1000, 42);
[1, 2, 3].forEach(log.warn);
 
// log is shortcut for log.log 
setImmediate(log, 42); // => 42 
 
log.disable();
log.warn('Console is disabled, you will not see this message.');
log.enable();
log.warn('Console is enabled again.');

Modules core.object.is-object, core.object.classof, core.object.define, core.object.make.

Object
  .isObject(var) -> bool
  .classof(var) -> string 
  .define(target, mixin) -> target
  .make(proto | null, mixin?) -> object

Object classify examples:

Object.isObject({});    // => true 
Object.isObject(isNaN); // => true 
Object.isObject(null);  // => false 
 
var classof = Object.classof;
 
classof(null);                 // => 'Null' 
classof(undefined);            // => 'Undefined' 
classof(1);                    // => 'Number' 
classof(true);                 // => 'Boolean' 
classof('string');             // => 'String' 
classof(Symbol());             // => 'Symbol' 
 
classof(new Number(1));        // => 'Number' 
classof(new Boolean(true));    // => 'Boolean' 
classof(new String('string')); // => 'String' 
 
var fn   = function(){}
  , list = (function(){return arguments})(1, 2, 3);
 
classof({});                   // => 'Object' 
classof(fn);                   // => 'Function' 
classof([]);                   // => 'Array' 
classof(list);                 // => 'Arguments' 
classof(/./);                  // => 'RegExp' 
classof(new TypeError);        // => 'Error' 
 
classof(new Set);              // => 'Set' 
classof(new Map);              // => 'Map' 
classof(new WeakSet);          // => 'WeakSet' 
classof(new WeakMap);          // => 'WeakMap' 
classof(new Promise(fn));      // => 'Promise' 
 
classof([].values());          // => 'Array Iterator' 
classof(new Set().values());   // => 'Set Iterator' 
classof(new Map().values());   // => 'Map Iterator' 
 
classof(Math);                 // => 'Math' 
classof(JSON);                 // => 'JSON' 
 
function Example(){}
Example.prototype[Symbol.toStringTag] = 'Example';
 
classof(new Example);          // => 'Example' 

Object.define and Object.make examples:

// Before: 
Object.defineProperty(target, 'c', {
  enumerable: true,
  configurable: true,
  getfunction(){
    return this.+ this.b;
  }
});
 
// After: 
Object.define(target, {
  get c(){
    return this.+ this.b;
  }
});
 
// Shallow object cloning with prototype and descriptors: 
var copy = Object.make(Object.getPrototypeOf(src), src);
 
// Simple inheritance: 
function Vector2D(xy){
  this.x = x;
  this.y = y;
}
Object.define(Vector2D.prototype, {
  get xy(){
    return Math.hypot(this.x, this.y);
  }
});
function Vector3D(xyz){
  Vector2D.apply(this, arguments);
  this.= z;
}
Vector3D.prototype = Object.make(Vector2D.prototype, {
  constructor: Vector3D,
  get xyz(){
    return Math.hypot(this.x, this.y, this.z);
  }
});
 
var vector = new Vector3D(9, 12, 20);
log(vector.xy);  // => 15 
log(vector.xyz); // => 25 
vector.y++;
log(vector.xy);  // => 15.811388300841896 
log(vector.xyz); // => 25.495097567963924 

Module core.dict. Based on TC39 discuss / strawman.

[new] Dict(iterable (entries) | object ?) -> dict
  .isDict(var) -> bool
  .values(object) -> iterator
  .keys(object) -> iterator
  .entries(object) -> iterator (entries)
  .has(object, key) -> bool
  .get(object, key) -> val
  .set(object, key, value) -> object
  .forEach(object, fn(val, key, @), that) -> void
  .map(object, fn(val, key, @), that) -> new @
  .mapPairs(object, fn(val, key, @), that) -> new @
  .filter(object, fn(val, key, @), that) -> new @
  .some(object, fn(val, key, @), that) -> bool
  .every(object, fn(val, key, @), that) -> bool
  .find(object, fn(val, key, @), that) -> val
  .findKey(object, fn(val, key, @), that) -> key
  .keyOf(object, var) -> key
  .includes(object, var) -> bool
  .reduce(object, fn(memo, val, key, @), memo?) -> var

Dict create object without prototype from iterable or simple object. Example:

var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
 
Dict();                    // => {__proto__: null} 
Dict({a: 1, b: 2, c: 3});  // => {__proto__: null, a: 1, b: 2, c: 3} 
Dict(map);                 // => {__proto__: null, a: 1, b: 2, c: 3} 
Dict([1, 2, 3].entries()); // => {__proto__: null, 0: 1, 1: 2, 2: 3} 
 
var dict = Dict({a: 42});
dict instanceof Object;   // => false 
dict.a;                   // => 42 
dict.toString;            // => undefined 
'a' in dict;              // => true 
'hasOwnProperty' in dict; // => false 
 
Dict.isDict({});     // => false 
Dict.isDict(Dict()); // => true 

Dict.keys, Dict.values and Dict.entries returns iterators for objects, examples:

var dict = {a: 1, b: 2, c: 3};
 
for(var key of Dict.keys(dict))log(key); // => 'a', 'b', 'c' 
 
for(var val of Dict.values(dict))log(val); // => 1, 2, 3 
 
for(var [key, val] of Dict.entries(dict)){
  log(key); // => 'a', 'b', 'c' 
  log(val); // => 1, 2, 3 
}
 
new Map(Dict.entries(dict)); // => Map {a: 1, b: 2, c: 3} 
 
new Map((for([k, v] of Dict.entries(dict))if(% 2)[+ k, v * v])); // =>  Map {aa: 1, cc: 9} 

Basic dict operations for objects with prototype example:

'q' in {q: 1};            // => true 
'toString' in {};         // => true 
 
Dict.has({q: 1}, 'q');    // => true 
Dict.has({}, 'toString'); // => false 
 
({q: 1})['q'];            // => 1 
({}).toString;            // => function toString(){ [native code] } 
 
Dict.get({q: 1}, 'q');    // => 1 
Dict.get({}, 'toString'); // => undefined 
 
var O = {};
O['q'] = 1;
O['q'];         // => 1 
O['__proto__'] = {w: 2};
O['__proto__']; // => {w: 2} 
O['w'];         // => 2 
 
var O = {};
Dict.set(O, 'q', 1);
O['q'];         // => 1 
Dict.set(O, '__proto__', {w: 2});
O['__proto__']; // => {w: 2} 
O['w'];         // => undefined 

Other methods of Dict module are static equialents of Array.prototype methods for dictionaries, examples:

var dict = {a: 1, b: 2, c: 3};
 
Dict.forEach(dict, console.log, console);
// => 1, 'a', {a: 1, b: 2, c: 3} 
// => 2, 'b', {a: 1, b: 2, c: 3} 
// => 3, 'c', {a: 1, b: 2, c: 3} 
 
Dict.map(dict, function(it){
  return it * it;
}); // => {a: 1, b: 4, c: 9} 
 
Dict.mapPairs(dict, function(valkey){
  if(key != 'b')return [key + key, val * val];
}); // => {aa: 1, cc: 9} 
 
Dict.filter(dict, function(it){
  return it % 2;
}); // => {a: 1, c: 3} 
 
Dict.some(dict, function(it){
  return it === 2;
}); // => true 
 
Dict.every(dict, function(it){
  return it === 2;
}); // => false 
 
Dict.find(dict, function(it){
  return it > 2;
}); // => 3 
Dict.find(dict, function(it){
  return it > 4;
}); // => undefined 
 
Dict.findKey(dict, function(it){
  return it > 2;
}); // => 'c' 
Dict.findKey(dict, function(it){
  return it > 4;
}); // => undefined 
 
Dict.keyOf(dict, 2);    // => 'b' 
Dict.keyOf(dict, 4);    // => undefined 
 
Dict.includes(dict, 2); // => true 
Dict.includes(dict, 4); // => false 
 
Dict.reduce(dict, function(memoit){
  return memo + it;
});     // => 6 
Dict.reduce(dict, function(memoit){
  return memo + it;
}, ''); // => '123' 

Module core.function.part.

Function
  #part(...args | _) -> fn(...args)

Function#part partial apply function without this binding. Uses global variable _ (core._ for builds without global namespace pollution) as placeholder and not conflict with Underscore / LoDash. Examples:

var fn1 = log.part(1, 2);
fn1(3, 4);    // => 1, 2, 3, 4 
 
var fn2 = log.part(_, 2, _, 4);
fn2(1, 3);    // => 1, 2, 3, 4 
 
var fn3 = log.part(1, _, _, 4);
fn3(2, 3);    // => 1, 2, 3, 4 
 
fn2(1, 3, 5); // => 1, 2, 3, 4, 5 
fn2(1);       // => 1, 2, undefined, 4 

Modules core.number.iterator.

Number
  #@@iterator() -> iterator

Examples:

for(var i of 3)log(i); // => 0, 1, 2 
 
Array.from(10, Math.random); // => [0.9817775336559862, 0.02720663254149258, ...] 
 
Array.from(10); // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
 
Array.from(10, function(it){
  return this + it * it;
}, .42); // => [0.42, 1.42, 4.42, 9.42, 16.42, 25.42, 36.42, 49.42, 64.42, 81.42] 
 
// Comprehensions: 
[for(i of 10)if(% 2)* i]; // => [1, 9, 25, 49, 81] 
 
Dict((for(i of 3)['key' + i, !(% 2)])); // => {key0: true, key1: false, key2: true} 

Modules core.string.escape-html and core.string.unescape-html.

String
  #escapeHTML() -> str
  #unescapeHTML() -> str

Examples:

'<script>doSomething();</script>'.escapeHTML(); // => '&lt;script&gt;doSomething();&lt;/script&gt;' 
'&lt;script&gt;doSomething();&lt;/script&gt;'.unescapeHTML(); // => '<script>doSomething();</script>' 

Module core.delay. Promise-returning delay function, esdiscuss. Example:

delay(1e3).then(() => log('after 1 sec'));
 
(async () => {
  await delay(3e3);
  log('after 3 sec');
  
  while(await delay(3e3))log('each 3 sec');
})();
  • ES5 JSON is missing now only in IE7- and never it will be added to core-js, if you need it in these old browsers available many implementations, for example, json3.
  • ES6 Typed Arrays can be polyfilled without serious problems, but it will be slow - getter / setter for each element and they are missing completely only in IE9-. You can use this polyfill. Possible, it will be added to core-js in the future, completely or only missing methods of existing arrays.
  • ES6 String#normalize is not very usefull feature, but this polyfill will be very large. If you need it, you can use unorm.
  • ES6 Proxy can't be polyfilled, but for Node.js / Chromium with additional flags you can try harmony-reflect for adapt old style Proxy API to final ES6 version.
  • ES7 Object.observe can be polyfilled with many limitations, but it will be very slow - dirty checking on each tick. In nearest future it will not be added to core-js - it will cause serious slowdown in applications which uses Object.observe and fallback if it's missing. Possible it will be added as optional feature then most actual browsers will have this feature. Now you can use this polyfill.
  • ES7 SIMD. core-js doesn't adds polyfill of this feature because of large size and some other reasons. You can use this polyfill.
  • window.fetch is not crossplatform feature, in some environments it make no sense. For this reason I don't think it should be in core-js. Looking at the large number of requests it maybe added in the future. Now you can use, for example, this polyfill.
  • added toJSON method to Symbol polyfill and to MS Edge implementation for expected JSON.stringify result w/o patching this method
  • replaced Reflect.construct implementations w/o correct support third argument
  • fixed global detection with changed document.domain in ~IE8, #100
  • added more correct microtask implementation for Promise
  • some fixes for final MS Edge, replaced broken native Reflect.defineProperty
  • some minor fixes and optimizations
  • changed compression client/*.min.js options for safe Function#name and Function#length, should be fixed #92
  • collections from library version return wrapped native instances
  • fixed collections prototype methods in library version
  • optimized Math.hypot
  • different instances core-js should use / recognize the same symbols
  • some fixes
  • simplified custom build
    • add custom build js api
    • added grunt-cli to devDependencies for npm run grunt
  • some fixes
  • wrapped Function#toString for correct work wrapped methods / constructors with methods similar to the lodash isNative
  • added proto versions of methods to export object in default version for consistency with library version
  • added cap for Function#@@hasInstance
  • some fixes and optimizations
  • fixed RegExp constructor
  • some fixes and optimizations
  • more correct Promise unhandled rejection tracking and resolving / rejection priority
  • fixed __proto__-based Promise subclassing in some environments
  • added correct symbols descriptors
    • fixed behavior Object.{assign, create, defineProperty, defineProperties, getOwnPropertyDescriptor, getOwnPropertyDescriptors} with symbols
    • added single entry points for Object.{create, defineProperty, defineProperties}
  • added Map#toJSON
  • removed non-standard methods Object#[_] and Function#only - they solves syntax problems, but now in compilers available arrows and in near future will be available available bind syntax
  • removed non-standard undocumented methods Symbol.{pure, set}
  • some fixes and internal changes
  • uses webpack instead of browserify for browser builds - more compression-friendly result
  • fixed Array statics with single entry points
  • fixed Symbol.keyFor
  • some fixes
  • some fixes
  • added support safe closing iteration - calling iterator.return on abort iteration, if it exists
  • added basic support Promise unhandled rejection tracking in shim
  • added Object.getOwnPropertyDescriptors
  • removed console cap - creates too many problems - you can use core.log module as that
  • restructuring namespaces
  • some fixes
  • some fixes
  • some fixes
  • some fixes
  • systematization of modules
  • splitted es6 module
  • splitted console module: web.console - only cap for missing methods, core.log - bound methods & additional features
  • added delay method
  • some fixes
  • FF20-24 fix