core-js-pure

What is core-js-pure?

The core-js-pure package is a version of core-js that doesn't pollute the global namespace. It provides polyfills for ECMAScript features, including promises, symbols, collections, iterators, typed arrays, and many other features that are part of the ECMAScript specification but may not be available in all JavaScript environments.

What are core-js-pure's main functionalities?

Polyfilling Promises

This code sample demonstrates how to polyfill Promises using core-js-pure. It allows you to use Promises in environments where they are not natively supported.

import 'core-js-pure/stable/promise';

const promise = Promise.resolve(42);
promise.then(value => console.log(value));

Polyfilling Array methods

This code sample shows how to polyfill Array.prototype.find method. It enables the use of this method in environments where it is not part of the Array prototype.

import 'core-js-pure/stable/array/find';

const array = [1, 2, 3];
const found = array.find(item => item > 1);
console.log(found); // 2

Polyfilling Object static methods

This code sample illustrates how to polyfill Object.assign method. It allows the merging of multiple source objects into a target object in environments that do not support this method natively.

import 'core-js-pure/stable/object/assign';

const target = { a: 1 };
const source = { b: 2 };
const returnedTarget = Object.assign(target, source);

console.log(returnedTarget); // { a: 1, b: 2 }

Polyfilling String methods

This code sample demonstrates how to polyfill String.prototype.includes method. It provides a way to check if one string may be found within another string, returning true or false as appropriate.

import 'core-js-pure/stable/string/includes';

const string = 'hello world';
const includesHello = string.includes('hello');
console.log(includesHello); // true

Other packages similar to core-js-pure

babel-polyfill

Babel-polyfill is a package that includes core-js and a custom regenerator runtime to emulate a full ES2015+ environment. It's similar to core-js-pure but is more tightly coupled with Babel's transpilation process.

es6-shim

The es6-shim package provides polyfills for many new JavaScript features introduced in ES5 and ES6. It is similar to core-js-pure but does not offer as modular an approach, and it may include shims for features that are not strictly polyfills.

polyfill-service

The polyfill-service (also known as polyfill.io) is a service that provides polyfills based on the user's browser user-agent. Unlike core-js-pure, it is a service rather than a package you include in your code, and it dynamically serves only the polyfills needed by the browser.

README

core-js-pure

Modular standard library for JavaScript. Includes polyfills for ECMAScript up to 2019: promises, symbols, collections, iterators, typed arrays, many other features, ECMAScript proposals, some cross-platform WHATWG / W3C features and proposals like URL. You can load only required features or use it without global namespace pollution.

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.

---

---

---

Example:

import 'core-js'; // <- at the top of your entry point

Array.from(new Set([1, 2, 3, 2, 1]));          // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2);                 // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

You can load only required features:

import 'core-js/features/array/from'; // <- at the top of your entry point
import 'core-js/features/array/flat'; // <- at the top of your entry point
import 'core-js/features/set';        // <- at the top of your entry point
import 'core-js/features/promise';    // <- at the top of your entry point

Array.from(new Set([1, 2, 3, 2, 1]));          // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2);                 // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

Or use it without global namespace pollution:

import from from 'core-js-pure/features/array/from';
import flat from 'core-js-pure/features/array/flat';
import Set from 'core-js-pure/features/set';
import Promise from 'core-js-pure/features/promise';

from(new Set([1, 2, 3, 2, 1]));                // => [1, 2, 3]
flat([1, [2, 3], [4, [5]]], 2);                // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

It's a version without global namespace pollution (the third example), for more info see core-js documentation.

Changelog

3.7.0 - 2020.11.06

• String#replaceAll moved to the stable ES, per June TC39 meeting
• Promise.any and AggregateError moved to the stable ES, per July TC39 meeting
• Added Reflect[@@toStringTag], per July TC39 meeting
• Forced replacement of Array#{ reduce, reduceRight } in Chrome 80-82 because of a bug, #766
• Following the changes in the upsert proposal, { Map, WeakMap }#emplace replace { Map, WeakMap }#upsert, these obsolete methods will be removed in the next major release
• By the current spec, AggregateError#errors is own data property
• Added correct iteration closing in the iteration helpers according to the current version of the proposal
• process.nextTick have a less priority than Promise in the microtask implementation, #855
• Fixed microtask implementation in engines with MutationObserver, but without document, #865, #866
• Fixed core-js-builder with an empty (after the targets engines or another filtration) modules list, #822
• Fixed possible twice call of window.onunhandledrejection, #760
• Fixed some possible problems related multiple global copies of core-js, #880
• Added a workaround for 3rd party Reflect.set polyfill bug, #847
• Updated compat data:
  • Chrome up to 86
  • FF up to 82
  • Safari up to 14
• Updated compat data mapping:
  • iOS up to 14
  • NodeJS up to 15.0
  • Electron up to 11.0
  • Samsung Internet up to 13.0
  • Opera Android up to 60
  • The rest automatically
• Updated all required dependencies