Have ideas to improve npm?Join in the discussion! ¬Ľ

    This version has been deprecated

    Author message:

    [email protected]<3.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Please, upgrade your dependencies to the actual version of core-js.

    core-js
    DefinitelyTyped icon, indicating that this package has TypeScript declarations provided by the separate @types/core-js package

    2.6.9¬†‚Äʬ†Public¬†‚Äʬ†Published

    core-js

    Sponsors on Open Collective Backers on Open Collective Gitter version npm downloads Build Status devDependency status

    As advertising: the author is looking for a good job :)

    core-js@3, babel and a look into the future

    Raising funds

    core-js isn't backed by a company, so the future of this project depends on you. Become a sponsor or a backer on Open Collective or on Patreon if you are interested in core-js.




    It's documentation for obsolete core-js@2. If you looking documentation for actual core-js version, please, check this branch.

    Modular standard library for JavaScript. Includes polyfills for ECMAScript 5, ECMAScript 6: promises, symbols, collections, iterators, typed arrays, ECMAScript 7+ proposals, setImmediate, etc. Some additional features such as dictionaries or extended partial application. You can require only needed features or use it without global namespace pollution.

    Example:

    Array.from(new Set([1, 2, 3, 2, 1]));          // => [1, 2, 3]
    '*'.repeat(10);                                // => '**********'
    Promise.resolve(32).then(x => console.log(x)); // => 32
    setImmediate(x => console.log(x), 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(x => console.log(x)); // => 32
    core.setImmediate(x => console.log(x), 42);         // => 42

    Index

    Usage

    Basic

    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:

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

    CommonJS

    You can require only needed modules.

    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 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, and 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.

    Caveats when using CommonJS API:
    • modules path is internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and / or if you know what are you doing.
    • core-js is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up core-js instead of usage loader for each file, otherwise, you will have hundreds of requests.

    CommonJS and prototype methods without global namespace pollution

    In the library version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed to static methods like in examples above. babel runtime transformer also can't transform them. But with transpilers we can use one more trick - bind operator and virtual methods. Special for that, available /virtual/ entry points. Example:

    import fill from 'core-js/library/fn/array/virtual/fill';
    import findIndex from 'core-js/library/fn/array/virtual/find-index';
     
    Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
     
    // or
     
    import {fill, findIndex} from 'core-js/library/fn/array/virtual';
     
    Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
     

    Custom build (from the command-line)

    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.

    Custom build (from external scripts)

    core-js-builder package exports a function that takes the same parameters as the build target from the previous section. This will conditionally include or exclude certain parts of core-js:

    require('core-js-builder')({
      modules: ['es6', 'core.dict'], // modules / namespaces
      blacklist: ['es6.reflect'],    // blacklist of modules / namespaces, by default - empty list
      library: false,                // flag for build without global namespace pollution, by default - false
      umd: true                      // use UMD wrapper for export `core` object, by default - true
    }).then(code => {
      // ...
    }).catch(error => {
      // ...
    });

    Supported engines

    Tested in:

    • Chrome 26+
    • Firefox 4+
    • Safari 5+
    • Opera 12+
    • Internet Explorer 6+ (sure, IE8- with ES3 limitations)
    • Edge
    • Android Browser 2.3+
    • iOS Safari 5.1+
    • PhantomJS 1.9 / 2.1
    • NodeJS 0.8+

    ...and it doesn't mean core-js will not work in other engines, they just have not been tested.

    Features:

    CommonJS entry points:

    core-js(/library)       <- all features
    core-js(/library)/shim  <- only polyfills
    

    ECMAScript 5

    All features moved to the es6 namespace, here just a list of features:

    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
      .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-
    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
      #sort(fn?)                                   -> @, fixes for some engines
    Function
      #bind(object, ...args) -> boundFn(...args)
    String
      #split(separator, limit) -> array
      #trim()                  -> str
    RegExp
      #toString() -> str
    Number
      #toFixed(digits)        -> string
      #toPrecision(precision) -> string
    parseInt(str, radix) -> int
    parseFloat(str)      -> num
    Date
      .now()         -> int
      #toISOString() -> string
      #toJSON()      -> string

    CommonJS entry points:

    core-js(/library)/es5
    

    ECMAScript 6

    CommonJS entry points:

    core-js(/library)/es6
    

    ECMAScript 6: Object

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

    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 and es6.object.get-own-property-names.

    Just ES5 features: es6.object.create, es6.object.define-property and es6.object.define-properties.

    Object
      .assign(target, ...src)                -> target
      .is(a, b)                              -> bool
      .setPrototypeOf(target, proto | null)  -> target (required __proto__ - IE11+)
      .create(object | null, descriptors?)   -> object
      .getPrototypeOf(var)                   -> object | null
      .defineProperty(object, key, desc)     -> target
      .defineProperties(object, descriptors) -> target
      .getOwnPropertyDescriptor(var, key)    -> desc | undefined
      .keys(var)                             -> array
      .getOwnPropertyNames(var)              -> array
      .freeze(var)                           -> var
      .seal(var)                             -> var
      .preventExtensions(var)                -> var
      .isFrozen(var)                         -> bool
      .isSealed(var)                         -> bool
      .isExtensible(var)                     -> bool
      #toString()                            -> string, ES6 fix: @@toStringTag support

    CommonJS entry points:

    core-js(/library)/es6/object
    core-js(/library)/fn/object/assign
    core-js(/library)/fn/object/is
    core-js(/library)/fn/object/set-prototype-of
    core-js(/library)/fn/object/get-prototype-of
    core-js(/library)/fn/object/create
    core-js(/library)/fn/object/define-property
    core-js(/library)/fn/object/define-properties
    core-js(/library)/fn/object/get-own-property-descriptor
    core-js(/library)/fn/object/keys
    core-js(/library)/fn/object/get-own-property-names
    core-js(/library)/fn/object/freeze
    core-js(/library)/fn/object/seal
    core-js(/library)/fn/object/prevent-extensions
    core-js(/library)/fn/object/is-frozen
    core-js(/library)/fn/object/is-sealed
    core-js(/library)/fn/object/is-extensible
    core-js/fn/object/to-string
    

    Examples:

    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]'
     
    Object.keys('qwe'); // => ['0', '1', '2']
    Object.getPrototypeOf('qwe') === String.prototype; // => true

    ECMAScript 6: Function

    Modules es6.function.name, es6.function.has-instance. Just ES5: es6.function.bind.

    Function
      #bind(object, ...args) -> boundFn(...args)
      #name                  -> string (IE9+)
      #@@hasInstance(var)    -> bool

    CommonJS entry points:

    core-js/es6/function
    core-js/fn/function/name
    core-js/fn/function/has-instance
    core-js/fn/function/bind
    core-js/fn/function/virtual/bind
    

    Example:

    (function foo(){}).name // => 'foo'
     
    console.log.bind(console, 42)(43); // => 42 43

    ECMAScript 6: Array

    Modules es6.array.from, es6.array.of, es6.array.copy-within, es6.array.fill, es6.array.find, es6.array.find-index, es6.array.iterator. ES5 features with fixes: es6.array.is-array, es6.array.slice, es6.array.join, es6.array.index-of, es6.array.last-index-of, es6.array.every, es6.array.some, es6.array.for-each, es6.array.map, es6.array.filter, es6.array.reduce, es6.array.reduce-right, es6.array.sort.

    Array
      .from(iterable | array-like, mapFn(val, index)?, that) -> array
      .of(...args)                                           -> array
      .isArray(var)                                          -> bool
      #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 | -1
      #values()                                              -> iterator
      #keys()                                                -> iterator
      #entries()                                             -> iterator
      #join(string = ',')                                    -> string, fix for ie7-
      #slice(start?, end?)                                   -> array, fix for ie7-
      #indexOf(var, from?)                                   -> index | -1
      #lastIndexOf(var, from?)                               -> index | -1
      #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
      #sort(fn?)                                             -> @, invalid arguments fix
      #@@iterator()                                          -> iterator (values)
      #@@unscopables                                         -> object (cap)
    Arguments
      #@@iterator() -> iterator (values, available only in core-js methods)

    CommonJS entry points:

    core-js(/library)/es6/array
    core-js(/library)/fn/array/from
    core-js(/library)/fn/array/of
    core-js(/library)/fn/array/is-array
    core-js(/library)/fn/array/iterator
    core-js(/library)/fn/array/copy-within
    core-js(/library)/fn/array/fill
    core-js(/library)/fn/array/find
    core-js(/library)/fn/array/find-index
    core-js(/library)/fn/array/values
    core-js(/library)/fn/array/keys
    core-js(/library)/fn/array/entries
    core-js(/library)/fn/array/slice
    core-js(/library)/fn/array/join
    core-js(/library)/fn/array/index-of
    core-js(/library)/fn/array/last-index-of
    core-js(/library)/fn/array/every
    core-js(/library)/fn/array/some
    core-js(/library)/fn/array/for-each
    core-js(/library)/fn/array/map
    core-js(/library)/fn/array/filter
    core-js(/library)/fn/array/reduce
    core-js(/library)/fn/array/reduce-right
    core-js(/library)/fn/array/sort
    core-js(/library)/fn/array/virtual/iterator
    core-js(/library)/fn/array/virtual/copy-within
    core-js(/library)/fn/array/virtual/fill
    core-js(/library)/fn/array/virtual/find
    core-js(/library)/fn/array/virtual/find-index
    core-js(/library)/fn/array/virtual/values
    core-js(/library)/fn/array/virtual/keys
    core-js(/library)/fn/array/virtual/entries
    core-js(/library)/fn/array/virtual/slice
    core-js(/library)/fn/array/virtual/join
    core-js(/library)/fn/array/virtual/index-of
    core-js(/library)/fn/array/virtual/last-index-of
    core-js(/library)/fn/array/virtual/every
    core-js(/library)/fn/array/virtual/some
    core-js(/library)/fn/array/virtual/for-each
    core-js(/library)/fn/array/virtual/map
    core-js(/library)/fn/array/virtual/filter
    core-js(/library)/fn/array/virtual/reduce
    core-js(/library)/fn/array/virtual/reduce-right
    core-js(/library)/fn/array/virtual/sort
    

    Examples:

    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]
     
    var array = ['a', 'b', 'c'];
     
    for(var val of array)console.log(val);          // => 'a', 'b', 'c'
    for(var val of array.values())console.log(val); // => 'a', 'b', 'c'
    for(var key of array.keys())console.log(key);   // => 0, 1, 2
    for(var [key, val] of array.entries()){
      console.log(key);                             // => 0, 1, 2
      console.log(val);                             // => 'a', 'b', 'c'
    }
     
    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]

    ECMAScript 6: String

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

    Annex B HTML methods. Ugly, but it's also the part of the spec. Modules es6.string.anchor, es6.string.big, es6.string.blink, es6.string.bold, es6.string.fixed, es6.string.fontcolor, es6.string.fontsize, es6.string.italics, es6.string.link, es6.string.small, es6.string.strike, es6.string.sub and es6.string.sup.

    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
      #anchor(name)     -> str
      #big()            -> str
      #blink()          -> str
      #bold()           -> str
      #fixed()          -> str
      #fontcolor(color) -> str
      #fontsize(size)   -> str
      #italics()        -> str
      #link(url)        -> str
      #small()          -> str
      #strike()         -> str
      #sub()            -> str
      #sup()            -> str
      #@@iterator() -> iterator (code points)

    CommonJS entry points:

    core-js(/library)/es6/string
    core-js(/library)/fn/string/from-code-point
    core-js(/library)/fn/string/raw
    core-js(/library)/fn/string/includes
    core-js(/library)/fn/string/starts-with
    core-js(/library)/fn/string/ends-with
    core-js(/library)/fn/string/repeat
    core-js(/library)/fn/string/code-point-at
    core-js(/library)/fn/string/trim
    core-js(/library)/fn/string/anchor
    core-js(/library)/fn/string/big
    core-js(/library)/fn/string/blink
    core-js(/library)/fn/string/bold
    core-js(/library)/fn/string/fixed
    core-js(/library)/fn/string/fontcolor
    core-js(/library)/fn/string/fontsize
    core-js(/library)/fn/string/italics
    core-js(/library)/fn/string/link
    core-js(/library)/fn/string/small
    core-js(/library)/fn/string/strike
    core-js(/library)/fn/string/sub
    core-js(/library)/fn/string/sup
    core-js(/library)/fn/string/iterator
    core-js(/library)/fn/string/virtual/includes
    core-js(/library)/fn/string/virtual/starts-with
    core-js(/library)/fn/string/virtual/ends-with
    core-js(/library)/fn/string/virtual/repeat
    core-js(/library)/fn/string/virtual/code-point-at
    core-js(/library)/fn/string/virtual/trim
    core-js(/library)/fn/string/virtual/anchor
    core-js(/library)/fn/string/virtual/big
    core-js(/library)/fn/string/virtual/blink
    core-js(/library)/fn/string/virtual/bold
    core-js(/library)/fn/string/virtual/fixed
    core-js(/library)/fn/string/virtual/fontcolor
    core-js(/library)/fn/string/virtual/fontsize
    core-js(/library)/fn/string/virtual/italics
    core-js(/library)/fn/string/virtual/link
    core-js(/library)/fn/string/virtual/small
    core-js(/library)/fn/string/virtual/strike
    core-js(/library)/fn/string/virtual/sub
    core-js(/library)/fn/string/virtual/sup
    core-js(/library)/fn/string/virtual/iterator
    

    Examples:

    for(var¬†val¬†of¬†'aū†ģ∑b'){
    ¬†¬†console.log(val);¬†//¬†=>¬†'a',¬†'ū†ģ∑',¬†'b'
    }
     
    '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'
     
    'foo'.bold();                     // => '<b>foo</b>'
    'bar'.anchor('a"b');              // => '<a name="a&quot;b">bar</a>'
    'baz'.link('http://example.com'); // => '<a href="http://example.com">baz</a>'

    ECMAScript 6: RegExp

    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.

    [new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+)
      #flags -> str (IE9+)
      #toString() -> str, ES6 fixes
      #@@match(str)             -> array | null
      #@@replace(str, replacer) -> string
      #@@search(str)            -> index
      #@@split(str, limit)      -> array
    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, some fixes for old engines
    

    CommonJS entry points:

    core-js/es6/regexp
    core-js/fn/regexp/constructor
    core-js(/library)/fn/regexp/flags
    core-js/fn/regexp/to-string
    core-js/fn/regexp/match
    core-js/fn/regexp/replace
    core-js/fn/regexp/search
    core-js/fn/regexp/split
    

    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
     
    RegExp.prototype.toString.call({source: 'foo', flags: 'bar'}); // => '/foo/bar'

    ECMAScript 6: Number

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

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

    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, es6.number.to-fixed, es6.number.to-precision, es6.parse-int, es6.parse-float.

    [new] Number(var)         -> number | number object
      .isFinite(num)          -> bool
      .isNaN(num)             -> bool
      .isInteger(num)         -> bool
      .isSafeInteger(num)     -> bool
      .parseFloat(str)        -> num
      .parseInt(str)          -> int
      .EPSILON                -> num
      .MAX_SAFE_INTEGER       -> int
      .MIN_SAFE_INTEGER       -> int
      #toFixed(digits)        -> string, fixes
      #toPrecision(precision) -> string, fixes
    parseFloat(str)           -> num, fixes
    parseInt(str)             -> int, fixes

    CommonJS entry points:

    core-js(/library)/es6/number
    core-js/es6/number/constructor
    core-js(/library)/fn/number/is-finite
    core-js(/library)/fn/number/is-nan
    core-js(/library)/fn/number/is-integer
    core-js(/library)/fn/number/is-safe-integer
    core-js(/library)/fn/number/parse-float
    core-js(/library)/fn/number/parse-int
    core-js(/library)/fn/number/epsilon
    core-js(/library)/fn/number/max-safe-integer
    core-js(/library)/fn/number/min-safe-integer
    core-js(/library)/fn/number/to-fixed
    core-js(/library)/fn/number/to-precision
    core-js(/library)/fn/parse-float
    core-js(/library)/fn/parse-int
    

    ECMAScript 6: 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

    CommonJS entry points:

    core-js(/library)/es6/math
    core-js(/library)/fn/math/acosh
    core-js(/library)/fn/math/asinh
    core-js(/library)/fn/math/atanh
    core-js(/library)/fn/math/cbrt
    core-js(/library)/fn/math/clz32
    core-js(/library)/fn/math/cosh
    core-js(/library)/fn/math/expm1
    core-js(/library)/fn/math/fround
    core-js(/library)/fn/math/hypot
    core-js(/library)/fn/math/imul
    core-js(/library)/fn/math/log1p
    core-js(/library)/fn/math/log10
    core-js(/library)/fn/math/log2
    core-js(/library)/fn/math/sign
    core-js(/library)/fn/math/sinh
    core-js(/library)/fn/math/tanh
    core-js(/library)/fn/math/trunc
    

    ECMAScript 6: Date

    Modules es6.date.to-string, ES5 features with fixes: es6.date.now, es6.date.to-iso-string, es6.date.to-json and es6.date.to-primitive.

    Date
      .now()               -> int
      #toISOString()       -> string
      #toJSON()            -> string
      #toString()          -> string
      #@@toPrimitive(hint) -> primitive

    CommonJS entry points:

    core-js/es6/date
    core-js/fn/date/to-string
    core-js(/library)/fn/date/now
    core-js(/library)/fn/date/to-iso-string
    core-js(/library)/fn/date/to-json
    core-js(/library)/fn/date/to-primitive
    

    Example:

    new Date(NaN).toString(); // => 'Invalid Date'

    ECMAScript 6: Promise

    Module es6.promise.

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

    CommonJS entry points:

    core-js(/library)/es6/promise
    core-js(/library)/fn/promise
    

    Basic example:

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

    Promise.resolve and Promise.reject example:

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

    Promise.all example:

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

    Promise.race example:

    function timeLimit(promise, time){
      return Promise.race([promise, new Promise(function(resolve, reject){
        setTimeout(reject, time * 1e3, Error('Await > ' + time + ' sec'));
      })]);
    }
     
    timeLimit(sleepRandom(5), 10).then(x => console.log(x));   // => 853, after 5 sec.
    timeLimit(sleepRandom(15), 10).catch(x => console.log(x)); // 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(time, msg){
      await delay(time * 1e3);
      throw Error(msg);
    };
     
    (async () => {
      try {
        console.log('Run');                // => Run
        console.log(await sleepRandom(5)); // => 936, after 5 sec.
        var [a, b, c] = await Promise.all([
          sleepRandom(5),
          sleepRandom(15),
          sleepRandom(10)
        ]);
        console.log(a, b, c);              // => 210 445 71, after 15 sec.
        await sleepError(5, 'Irror!');
        console.log('Will not be displayed');
      } catch(e){
        console.log(e);                    // => Error: 'Irror!', after 5 sec.
      }
    })();
    Unhandled rejection tracking

    In Node.js, like in native implementation, available events unhandledRejection and rejectionHandled:

    process.on('unhandledRejection', (reason, promise) => console.log('unhandled', reason, promise));
    process.on('rejectionHandled', (promise) => console.log('handled', promise));
     
    var p = Promise.reject(42);
    // unhandled 42 [object Promise]
     
    setTimeout(() => p.catch(_ => _), 1e3);
    // handled [object Promise]

    In a browser on rejection, by default, you will see notify in the console, or you can add a custom handler and a handler on handling unhandled, example:

    window.onunhandledrejection = e => console.log('unhandled', e.reason, e.promise);
    window.onrejectionhandled = e => console.log('handled', e.reason, e.promise);
     
    var p = Promise.reject(42);
    // unhandled 42 [object Promise]
     
    setTimeout(() => p.catch(_ => _), 1e3);
    // handled 42 [object Promise]

    ECMAScript 6: Symbol

    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 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
    JSON
      .stringify(target, replacer?, space?) -> string | undefined

    CommonJS entry points:

    core-js(/library)/es6/symbol
    core-js(/library)/fn/symbol
    core-js(/library)/fn/symbol/has-instance
    core-js(/library)/fn/symbol/is-concat-spreadable
    core-js(/library)/fn/symbol/iterator
    core-js(/library)/fn/symbol/match
    core-js(/library)/fn/symbol/replace
    core-js(/library)/fn/symbol/search
    core-js(/library)/fn/symbol/species
    core-js(/library)/fn/symbol/split
    core-js(/library)/fn/symbol/to-primitive
    core-js(/library)/fn/symbol/to-string-tag
    core-js(/library)/fn/symbol/unscopables
    core-js(/library)/fn/symbol/for
    core-js(/library)/fn/symbol/key-for
    

    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');
    console.log(person.getName());          // => 'Vasya'
    console.log(person['name']);            // => undefined
    console.log(person[Symbol('name')]);    // => undefined, symbols are uniq
    for(var key in person)console.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)]
    Caveats when using Symbol polyfill:
    • 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)console.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)console.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.
    • Some problems possible with environment exotic objects (for example, IE localStorage).

    ECMAScript 6: Collections

    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).

    Map

    Module es6.map.

    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
      #values()                       -> iterator
      #keys()                         -> iterator
      #entries()                      -> iterator
      #@@iterator()                   -> iterator (entries)

    CommonJS entry points:

    core-js(/library)/es6/map
    core-js(/library)/fn/map
    

    Examples:

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

    Set

    Module es6.set.

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

    CommonJS entry points:

    core-js(/library)/es6/set
    core-js(/library)/fn/set
    

    Examples:

    var set = new Set(['a', 'b', 'a', 'c']);
    set.add('d').add('b').add('e');
    console.log(set.size);        // => 5
    console.log(set.has('b'));    // => true
    set.forEach(function(it){
      console.log(it);            // => 'a', 'b', 'c', 'd', 'e'
    });
    set.delete('b');
    console.log(set.size);        // => 4
    console.log(set.has('b'));    // => false
    console.log(Array.from(set)); // => ['a', 'c', 'd', 'e']
     
    var set = new Set([1, 2, 3, 2, 1]);
     
    for(var val of set)console.log(val);          // => 1, 2, 3
    for(var val of set.values())console.log(val); // => 1, 2, 3
    for(var key of set.keys())console.log(key);   // => 1, 2, 3
    for(var [key, val] of set.entries()){
      console.log(key);                           // => 1, 2, 3
      console.log(val);                           // => 1, 2, 3
    }

    WeakMap

    Module es6.weak-map.

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

    CommonJS entry points:

    core-js(/library)/es6/weak-map
    core-js(/library)/fn/weak-map
    

    Examples:

    var a = [1]
      , b = [2]
      , c = [3];
     
    var wmap = new WeakMap([[a, 1], [b, 2]]);
    wmap.set(c, 3).set(b, 4);
    console.log(wmap.has(a));   // => true
    console.log(wmap.has([1])); // => false
    console.log(wmap.get(a));   // => 1
    wmap.delete(a);
    console.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');
    console.log(person.getName());          // => 'Vasya'
    for(var key in person)console.log(key); // => only 'getName'

    WeakSet

    Module es6.weak-set.

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

    CommonJS entry points:

    core-js(/library)/es6/weak-set
    core-js(/library)/fn/weak-set
    

    Examples:

    var a = [1]
      , b = [2]
      , c = [3];
     
    var wset = new WeakSet([a, b, a]);
    wset.add(c).add(b).add(c);
    console.log(wset.has(b));   // => true
    console.log(wset.has([2])); // => false
    wset.delete(b);
    console.log(wset.has(b));   // => false
    Caveats when using collections polyfill:
    • 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.

    ECMAScript 6: Typed Arrays

    Implementations and fixes ArrayBuffer, DataView, typed arrays constructors, static and prototype methods. Typed Arrays work only in environments with support descriptors (IE9+), ArrayBuffer and DataView should work anywhere.

    Modules es6.typed.array-buffer, es6.typed.data-view, es6.typed.int8-array, es6.typed.uint8-array, es6.typed.uint8-clamped-array, es6.typed.int16-array, es6.typed.uint16-array, es6.typed.int32-array, es6.typed.uint32-array, es6.typed.float32-array and es6.typed.float64-array.

    new ArrayBuffer(length) -> buffer
      .isView(var) -> bool
      #slice(start = 0, end = @length) -> buffer
      #byteLength -> uint
     
    new DataView(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) -> view
      #getInt8(offset)                          -> int8
      #getUint8(offset)                         -> uint8
      #getInt16(offset, littleEndian = false)   -> int16
      #getUint16(offset, littleEndian = false)  -> uint16
      #getInt32(offset, littleEndian = false)   -> int32
      #getUint32(offset, littleEndian = false)  -> uint32
      #getFloat32(offset, littleEndian = false) -> float32
      #getFloat64(offset, littleEndian = false) -> float64
      #setInt8(offset, value)                          -> void
      #setUint8(offset, value)                         -> void
      #setInt16(offset, value, littleEndian = false)   -> void
      #setUint16(offset, value, littleEndian = false)  -> void
      #setInt32(offset, value, littleEndian = false)   -> void
      #setUint32(offset, value, littleEndian = false)  -> void
      #setFloat32(offset, value, littleEndian = false) -> void
      #setFloat64(offset, value, littleEndian = false) -> void
      #buffer     -> buffer
      #byteLength -> uint
      #byteOffset -> uint
     
    {
      Int8Array,
      Uint8Array,
      Uint8ClampedArray,
      Int16Array,
      Uint16Array,
      Int32Array,
      Uint32Array,
      Float32Array,
      Float64Array
    }
      new %TypedArray%(length)    -> typed
      new %TypedArray%(typed)     -> typed
      new %TypedArray%(arrayLike) -> typed
      new %TypedArray%(iterable)  -> typed
      new %TypedArray%(buffer, byteOffset = 0, length = (buffer.byteLength - byteOffset) / @BYTES_PER_ELEMENT) -> typed
      .BYTES_PER_ELEMENT -> uint
      .from(arrayLike | iterable, mapFn(val, index)?, that) -> typed
      .of(...args) -> typed
      #BYTES_PER_ELEMENT -> uint
      #copyWithin(target = 0, start = 0, end = @length) -> @
      #every(fn(val, index, @), that) -> bool
      #fill(val, start = 0, end = @length) -> @
      #filter(fn(val, index, @), that) -> typed
      #find(fn(val, index, @), that) -> val
      #findIndex(fn(val, index, @), that) -> index
      #forEach(fn(val, index, @), that) -> void
      #indexOf(var, from?) -> int
      #join(string = ',') -> string
      #lastIndexOf(var, from?) -> int
      #map(fn(val, index, @), that) -> typed
      #reduce(fn(memo, val, index, @), memo?) -> var
      #reduceRight(fn(memo, val, index, @), memo?) -> var
      #reverse() -> @
      #set(arrayLike, offset = 0) -> void
      #slice(start = 0, end = @length) -> typed
      #some(fn(val, index, @), that) -> bool
      #sort(fn(a, b)?) -> @
      #subarray(start = 0, end = @length) -> typed
      #toString() -> string
      #toLocaleString() -> string
      #values()     -> iterator
      #keys()       -> iterator
      #entries()    -> iterator
      #@@iterator() -> iterator (values)
      #buffer     -> buffer
      #byteLength -> uint
      #byteOffset -> uint
      #length     -> uint

    CommonJS entry points:

    core-js(/library)/es6/typed
    core-js(/library)/fn/typed
    core-js(/library)/fn/typed/array-buffer
    core-js(/library)/fn/typed/data-view
    core-js(/library)/fn/typed/int8-array
    core-js(/library)/fn/typed/uint8-array
    core-js(/library)/fn/typed/uint8-clamped-array
    core-js(/library)/fn/typed/int16-array
    core-js(/library)/fn/typed/uint16-array
    core-js(/library)/fn/typed/int32-array
    core-js(/library)/fn/typed/uint32-array
    core-js(/library)/fn/typed/float32-array
    core-js(/library)/fn/typed/float64-array
    

    Examples:

    new Int32Array(4);                          // => [0, 0, 0, 0]
    new Uint8ClampedArray([1, 2, 3, 666]);      // => [1, 2, 3, 255]
    new Float32Array(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
     
    var buffer = new ArrayBuffer(8);
    var view   = new DataView(buffer);
    view.setFloat64(0, 123.456, true);
    new Uint8Array(buffer.slice(4)); // => [47, 221, 94, 64]
     
    Int8Array.of(1, 1.5, 5.7, 745);      // => [1, 1, 5, -23]
    Uint8Array.from([1, 1.5, 5.7, 745]); // => [1, 1, 5, 233]
     
    var typed = new Uint8Array([1, 2, 3]);
     
    var a = typed.slice(1);    // => [2, 3]
    typed.buffer === a.buffer; // => false
    var b = typed.subarray(1); // => [2, 3]
    typed.buffer === b.buffer; // => true
     
    typed.filter(it => it % 2); // => [1, 3]
    typed.map(it => it * 1.5);  // => [1, 3, 4]
     
    for(var val of typed)console.log(val);          // => 1, 2, 3
    for(var val of typed.values())console.log(val); // => 1, 2, 3
    for(var key of typed.keys())console.log(key);   // => 0, 1, 2
    for(var [key, val] of typed.entries()){
      console.log(key);                             // => 0, 1, 2
      console.log(val);                             // => 1, 2, 3
    }
    Caveats when using typed arrays:
    • Typed Arrays polyfills works completely how should work by the spec, but because of internal use getter / setters on each instance, is slow and consumes significant memory. However, typed arrays polyfills required mainly for IE9 (and for Uint8ClampedArray in IE10 and early IE11), all modern engines have native typed arrays and requires only constructors fixes and methods.
    • The current version hasn't special entry points for methods, they can be added only with constructors. It can be added in the future.
    • In the library version we can't pollute native prototypes, so prototype methods available as constructors static.

    ECMAScript 6: Reflect

    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 (removed from the spec and will be removed from core-js@3)
      .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+)

    CommonJS entry points:

    core-js(/library)/es6/reflect
    core-js(/library)/fn/reflect
    core-js(/library)/fn/reflect/apply
    core-js(/library)/fn/reflect/construct
    core-js(/library)/fn/reflect/define-property
    core-js(/library)/fn/reflect/delete-property
    core-js(/library)/fn/reflect/enumerate (deprecated and will be removed from the next major release)
    core-js(/library)/fn/reflect/get
    core-js(/library)/fn/reflect/get-own-property-descriptor
    core-js(/library)/fn/reflect/get-prototype-of
    core-js(/library)/fn/reflect/has
    core-js(/library)/fn/reflect/is-extensible
    core-js(/library)/fn/reflect/own-keys
    core-js(/library)/fn/reflect/prevent-extensions
    core-js(/library)/fn/reflect/set
    core-js(/library)/fn/reflect/set-prototype-of
    

    Examples:

    var O = {a: 1};
    Object.defineProperty(O, 'b', {value: 2});
    O[Symbol('c')] = 3;
    Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)]
     
    function C(a, b){
      this.c = a + b;
    }
     
    var instance = Reflect.construct(C, [20, 22]);
    instance.c; // => 42

    ECMAScript 7+ proposals

    The TC39 process.

    CommonJS entry points:

    core-js(/library)/es7
    core-js(/library)/es7/array
    core-js(/library)/es7/global
    core-js(/library)/es7/string
    core-js(/library)/es7/map
    core-js(/library)/es7/set
    core-js(/library)/es7/error
    core-js(/library)/es7/math
    core-js(/library)/es7/system
    core-js(/library)/es7/symbol
    core-js(/library)/es7/reflect
    core-js(/library)/es7/observable
    

    core-js/stage/4 entry point contains only stage 4 proposals, core-js/stage/3 - stage 3 and stage 4, etc.

    Stage 4 proposals

    CommonJS entry points:

    core-js(/library)/stage/4
    Array
      #includes(var, from?) -> bool
    {
      Int8Array,
      Uint8Array,
      Uint8ClampedArray,
      Int16Array,
      Uint16Array,
      Int32Array,
      Uint32Array,
      Float32Array,
      Float64Array
    }
      #includes(var, from?) -> bool

    CommonJS entry points:

    core-js(/library)/fn/array/includes

    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
    Object
      .values(object) -> array
      .entries(object) -> array

    CommonJS entry points:

    core-js(/library)/fn/object/values
    core-js(/library)/fn/object/entries

    Examples:

    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]]
     
    for(let [key, value] of Object.entries({a: 1, b: 2, c: 3})){
      console.log(key);   // => 'a', 'b', 'c'
      console.log(value); // => 1, 2, 3
    }
    Object
      .getOwnPropertyDescriptors(object) -> object

    CommonJS entry points:

    core-js(/library)/fn/object/get-own-property-descriptors

    Examples:

    // Shallow object cloning with prototype and descriptors:
    var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O));
    // Mixin:
    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    String
      #padStart(length, fillStr = ' ') -> string
      #padEnd(length, fillStr = ' ') -> string

    CommonJS entry points:

    core-js(/library)/fn/string/pad-start
    core-js(/library)/fn/string/pad-end
    core-js(/library)/fn/string/virtual/pad-start
    core-js(/library)/fn/string/virtual/pad-end

    Examples:

    'hello'.padStart(10);         // => '     hello'
    'hello'.padStart(10, '1234'); // => '12341hello'
    'hello'.padEnd(10);           // => 'hello     '
    'hello'.padEnd(10, '1234');   // => 'hello12341'
    Object
      #__defineSetter__(key, fn) -> void
      #__defineGetter__(key, fn) -> void
      #__lookupSetter__(key) -> fn | void
      #__lookupGetter__(key) -> fn | void

    CommonJS entry points:

    core-js(/library)/fn/object/define-getter
    core-js(/library)/fn/object/define-setter
    core-js(/library)/fn/object/lookup-getter
    core-js(/library)/fn/object/lookup-setter

    Stage 3 proposals

    CommonJS entry points:

    core-js(/library)/stage/3
    global -> object
    System
      .global -> object (obsolete)

    CommonJS entry points:

    core-js(/library)/fn/global
    core-js(/library)/fn/system/global (obsolete)

    Examples:

    global.Array === Array; // => true
    Promise
      #finally(onFinally()) -> promise

    CommonJS entry points:

    core-js(/library)/fn/promise/finally

    Examples:

    Promise.resolve(42).finally(() => console.log('You will see it anyway'));
     
    Promise.reject(42).finally(() => console.log('You will see it anyway'));
     
    #### Stage 2 proposals
    [*CommonJS entry points:*](#commonjs)
    ```js
    core-js(/library)/stage/2
    String
      #trimLeft()  -> string
      #trimRight() -> string
      #trimStart() -> string
      #trimEnd()   -> string

    CommonJS entry points:

    core-js(/library)/fn/string/trim-start
    core-js(/library)/fn/string/trim-end
    core-js(/library)/fn/string/trim-left
    core-js(/library)/fn/string/trim-right
    core-js(/library)/fn/string/virtual/trim-start
    core-js(/library)/fn/string/virtual/trim-end
    core-js(/library)/fn/string/virtual/trim-left
    core-js(/library)/fn/string/virtual/trim-right

    Examples:

    '   hello   '.trimLeft();  // => 'hello   '
    '   hello   '.trimRight(); // => '   hello'
    * `Symbol.asyncIterator` for [async iteration proposal](https://github.com/tc39/proposal-async-iteration) - module [`es7.symbol.async-iterator`](https://github.com/zloirock/core-js/blob/v2.6.9/modules/es7.symbol.async-iterator.js)
    ```js
    Symbol
      .asyncIterator -> @@asyncIterator
    

    CommonJS entry points:

    core-js(/library)/fn/symbol/async-iterator

    Stage 1 proposals

    CommonJS entry points:

    core-js(/library)/stage/1
    Promise
      .try(function()) -> promise

    CommonJS entry points:

    core-js(/library)/fn/promise/try

    Examples:

    Promise.try(() => 42).then(it => console.log(`Promise, resolved as ${it}`));
     
    Promise.try(() => { throw 42; }).catch(it => console.log(`Promise, rejected as ${it}`));
    Array
      #flatten(depthArg = 1) -> array
      #flatMap(fn(val, key, @), that) -> array

    CommonJS entry points:

    core-js(/library)/fn/array/flatten
    core-js(/library)/fn/array/flat-map
    core-js(/library)/fn/array/virtual/flatten
    core-js(/library)/fn/array/virtual/flat-map

    Examples:

    [1, [2, 3], [4, 5]].flatten();    // => [1, 2, 3, 4, 5]
    [1, [2, [3, [4]]], 5].flatten();  // => [1, 2, [3, [4]], 5]
    [1, [2, [3, [4]]], 5].flatten(3); // => [1, 2, 3, 4, 5]
     
    [{a: 1, b: 2}, {a: 3, b: 4}, {a: 5, b: 6}].flatMap(it => [it.a, it.b]); // => [1, 2, 3, 4, 5, 6]
    Set
      .of(...args) -> set
      .from(iterable, mapFn(val, index)?, that?) -> set
    Map
      .of(...args) -> map
      .from(iterable, mapFn(val, index)?, that?) -> map
    WeakSet
      .of(...args) -> weakset
      .from(iterable, mapFn(val, index)?, that?) -> weakset
    WeakMap
      .of(...args) -> weakmap
      .from(iterable, mapFn(val, index)?, that?) -> weakmap

    CommonJS entry points:

    core-js(/library)/fn/set/of
    core-js(/library)/fn/set/from
    core-js(/library)/fn/map/of
    core-js(/library)/fn/map/from
    core-js(/library)/fn/weak-set/of
    core-js(/library)/fn/weak-set/from
    core-js(/library)/fn/weak-map/of
    core-js(/library)/fn/weak-map/from

    Examples:

    Set.of(1, 2, 3, 2, 1); // => Set {1, 2, 3}
     
    Map.from([[1, 2], [3, 4]], ([key, val]) => [key ** 2, val ** 2]); // => Map {1: 4, 9: 16}
    String
      #matchAll(regexp) -> iterator

    CommonJS entry points:

    core-js(/library)/fn/string/match-all
    core-js(/library)/fn/string/virtual/match-all

    Examples:

    for(let [_, d, D] of '1111a2b3cccc'.matchAll(/(\d)(\D)/)){
      console.log(d, D); // => 1 a, 2 b, 3 c
    }
    new Observable(fn)             -> observable
      #subscribe(observer)         -> subscription
      #forEach(fn)                 -> promise
      #@@observable()              -> @
      .of(...items)                -> observable
      .from(observable | iterable) -> observable
      .@@species                   -> @
    Symbol
      .observable                  -> @@observable

    CommonJS entry points:

    core-js(/library)/fn/observable
    core-js(/library)/fn/symbol/observable

    Examples:

    new Observable(observer => {
      observer.next('hello');
      observer.next('world');
      observer.complete();
    }).forEach(it => console.log(it))
      .then(_ => console.log('!'));
    Math
      .DEG_PER_RAD -> number
      .RAD_PER_DEG -> number
      .clamp(x, lower, upper) -> number
      .degrees(radians) -> number
      .fscale(x, inLow, inHigh, outLow, outHigh) -> number
      .radians(degrees) -> number
      .scale(x, inLow, inHigh, outLow, outHigh) -> number

    CommonJS entry points:

    core-js(/library)/fn/math/clamp
    core-js(/library)/fn/math/deg-per-rad
    core-js(/library)/fn/math/degrees
    core-js(/library)/fn/math/fscale
    core-js(/library)/fn/math/rad-per-deg
    core-js(/library)/fn/math/radians
    core-js(/library)/fn/math/scale
    Math
      .signbit(x) -> bool

    CommonJS entry points:

    core-js(/library)/fn/math/signbit

    Examples:

    Math.signbit(NaN); // => NaN
    Math.signbit(1);   // => true
    Math.signbit(-1);  // => false
    Math.signbit(0);   // => true
    Math.signbit(-0);  // => false

    Stage 0 proposals

    CommonJS entry points:

    core-js(/library)/stage/0
    String
      #at(index) -> string

    CommonJS entry points:

    core-js(/library)/fn/string/at
    core-js(/library)/fn/string/virtual/at

    Examples:

    'aū†ģ∑b'.at(1);¬†¬†¬†¬†¬†¬†¬†¬†//¬†=>¬†'ū†ģ∑'
    'aū†ģ∑b'.at(1).length;¬†//¬†=>¬†2
    Map
      #toJSON() -> array (rejected and will be removed from core-js@3)
    Set
      #toJSON() -> array (rejected and will be removed from core-js@3)

    CommonJS entry points:

    core-js(/library)/fn/map
    core-js(/library)/fn/set
    Error
      .isError(it) -> bool (withdrawn and will be removed from core-js@3)

    CommonJS entry points:

    core-js(/library)/fn/error/is-error
    Math
      .iaddh(lo0, hi0, lo1, hi1) -> int32
      .isubh(lo0, hi0, lo1, hi1) -> int32
      .imulh(a, b) -> int32
      .umulh(a, b) -> uint32

    CommonJS entry points:

    core-js(/library)/fn/math/iaddh
    core-js(/library)/fn/math/isubh
    core-js(/library)/fn/math/imulh
    core-js(/library)/fn/math/umulh
    asap(fn) -> void

    CommonJS entry points:

    core-js(/library)/fn/asap

    Examples:

    asap(() => console.log('called as microtask'));

    Pre-stage 0 proposals

    CommonJS entry points:

    core-js(/library)/stage/pre
    Reflect
      .defineMetadata(metadataKey, metadataValue, target, propertyKey?) -> void
      .getMetadata(metadataKey, target, propertyKey?) -> var
      .getOwnMetadata(metadataKey, target, propertyKey?) -> var
      .hasMetadata(metadataKey, target, propertyKey?) -> bool
      .hasOwnMetadata(metadataKey, target, propertyKey?) -> bool
      .deleteMetadata(metadataKey, target, propertyKey?) -> bool
      .getMetadataKeys(target, propertyKey?) -> array
      .getOwnMetadataKeys(target, propertyKey?) -> array
      .metadata(metadataKey, metadataValue) -> decorator(target, targetKey?) -> void

    CommonJS entry points:

    core-js(/library)/fn/reflect/define-metadata
    core-js(/library)/fn/reflect/delete-metadata
    core-js(/library)/fn/reflect/get-metadata
    core-js(/library)/fn/reflect/get-metadata-keys
    core-js(/library)/fn/reflect/get-own-metadata
    core-js(/library)/fn/reflect/get-own-metadata-keys
    core-js(/library)/fn/reflect/has-metadata
    core-js(/library)/fn/reflect/has-own-metadata
    core-js(/library)/fn/reflect/metadata

    Examples:

    var O = {};
    Reflect.defineMetadata('foo', 'bar', O);
    Reflect.ownKeys(O);               // => []
    Reflect.getOwnMetadataKeys(O);    // => ['foo']
    Reflect.getOwnMetadata('foo', O); // => 'bar'

    Web standards

    CommonJS entry points:

    core-js(/library)/web

    setTimeout / setInterval

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

    setTimeout(fn(...args), time, ...args) -> id
    setInterval(fn(...args), time, ...args) -> id

    CommonJS entry points:

    core-js(/library)/web/timers
    core-js(/library)/fn/set-timeout
    core-js(/library)/fn/set-interval
    // Before:
    setTimeout(log.bind(null, 42), 1000);
    // After:
    setTimeout(log, 1000, 42);

    setImmediate

    Module web.immediate. setImmediate proposal polyfill.

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

    CommonJS entry points:

    core-js(/library)/web/immediate
    core-js(/library)/fn/set-immediate
    core-js(/library)/fn/clear-immediate

    Examples:

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

    Iterable DOM collections

    Some DOM collections should have iterable interface or should be inherited from Array. That mean they should have keys, values, entries and @@iterator methods for iteration. So add them. Module web.dom.iterable:

    {
      CSSRuleList,
      CSSStyleDeclaration,
      CSSValueList,
      ClientRectList,
      DOMRectList,
      DOMStringList,
      DOMTokenList,
      DataTransferItemList,
      FileList,
      HTMLAllCollection,
      HTMLCollection,
      HTMLFormElement,
      HTMLSelectElement,
      MediaList,
      MimeTypeArray,
      NamedNodeMap,
      NodeList,
      PaintRequestList,
      Plugin,
      PluginArray,
      SVGLengthList,
      SVGNumberList,
      SVGPathSegList,
      SVGPointList,
      SVGStringList,
      SVGTransformList,
      SourceBufferList,
      StyleSheetList,
      TextTrackCueList,
      TextTrackList,
      TouchList
    }
      #@@iterator() -> iterator (values)
     
    {
      DOMTokenList,
      NodeList
    }
      #values()  -> iterator
      #keys()    -> iterator
      #entries() -> iterator

    CommonJS entry points:

    core-js(/library)/web/dom-collections
    core-js(/library)/fn/dom-collections/iterator

    Examples:

    for(var {id} of document.querySelectorAll('*')){
      if(id)console.log(id);
    }
     
    for(var [index, {id}] of document.querySelectorAll('*').entries()){
      if(id)console.log(index, id);
    }

    Non-standard

    CommonJS entry points:

    core-js(/library)/core

    Object

    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

    CommonJS entry points:

    core-js(/library)/core/object
    core-js(/library)/fn/object/is-object
    core-js(/library)/fn/object/define
    core-js(/library)/fn/object/make

    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,
      get: function(){
        return this.a + this.b;
      }
    });
     
    // After:
    Object.define(target, {
      get c(){
        return this.a + this.b;
      }
    });
     
    // Shallow object cloning with prototype and descriptors:
    var copy = Object.make(Object.getPrototypeOf(src), src);
     
    // Simple inheritance:
    function Vector2D(x, y){
      this.x = x;
      this.y = y;
    }
    Object.define(Vector2D.prototype, {
      get xy(){
        return Math.hypot(this.x, this.y);
      }
    });
    function Vector3D(x, y, z){
      Vector2D.apply(this, arguments);
      this.z = 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);
    console.log(vector.xy);  // => 15
    console.log(vector.xyz); // => 25
    vector.y++;
    console.log(vector.xy);  // => 15.811388300841896
    console.log(vector.xyz); // => 25.495097567963924

    Dict

    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

    CommonJS entry points:

    core-js(/library)/core/dict
    core-js(/library)/fn/dict

    Dict create object without prototype from iterable or simple object.

    Examples:

    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))console.log(key); // => 'a', 'b', 'c'
     
    for(var val of Dict.values(dict))console.log(val); // => 1, 2, 3
     
    for(var [key, val] of Dict.entries(dict)){
      console.log(key); // => 'a', 'b', 'c'
      console.log(val); // => 1, 2, 3
    }
     
    new Map(Dict.entries(dict)); // => Map {a: 1, b: 2, c: 3}

    Basic dict operations for objects with prototype examples:

    '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 equivalents 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(val, key){
      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(memo, it){
      return memo + it;
    });     // => 6
    Dict.reduce(dict, function(memo, it){
      return memo + it;
    }, ''); // => '123'

    Partial application

    Module core.function.part.

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

    CommonJS entry points:

    core-js/core/function
    core-js(/library)/fn/function/part
    core-js(/library)/fn/function/virtual/part
    core-js(/library)/fn/_

    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

    Number Iterator

    Module core.number.iterator.

    Number
      #@@iterator() -> iterator

    CommonJS entry points:

    core-js(/library)/core/number
    core-js(/library)/fn/number/iterator
    core-js(/library)/fn/number/virtual/iterator

    Examples:

    for(var i of 3)console.log(i); // => 0, 1, 2
     
    [...10]; // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     
    Array.from(10, Math.random); // => [0.9817775336559862, 0.02720663254149258, ...]
     
    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]

    Escaping strings

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

    RegExp
      .escape(str) -> str
    String
      #escapeHTML() -> str
      #unescapeHTML() -> str

    CommonJS entry points:

    core-js(/library)/core/regexp
    core-js(/library)/core/string
    core-js(/library)/fn/regexp/escape
    core-js(/library)/fn/string/escape-html
    core-js(/library)/fn/string/unescape-html
    core-js(/library)/fn/string/virtual/escape-html
    core-js(/library)/fn/string/virtual/unescape-html

    Examples:

    RegExp.escape('Hello, []{}()*+?.\\^$|!'); // => 'Hello, \[\]\{\}\(\)\*\+\?\.\\\^\$\|!'
     
    '<script>doSomething();</script>'.escapeHTML(); // => '&lt;script&gt;doSomething();&lt;/script&gt;'
    '&lt;script&gt;doSomething();&lt;/script&gt;'.unescapeHTML(); // => '<script>doSomething();</script>'

    delay

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

    delay(ms) -> promise

    CommonJS entry points:

    core-js(/library)/core/delay
    core-js(/library)/fn/delay

    Examples: