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

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

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]]].flatten(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/flatten'; // <- 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]]].flatten(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 flatten from 'core-js-pure/features/array/flatten';
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]
flatten([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.