core-js

core-js is the most widely used modular standard library for JavaScript, providing polyfills for the full breadth of ECMAScript — promises, symbols, iterators, collections, typed arrays, and hundreds of other methods — up to the latest yearly editions, along with staged TC39 proposals and cross-platform WHATWG/W3C features like URL and structuredClone.

It is designed for granular consumption: you can pull in the entire library, import only the exact features your code needs, or use the pure version to add functionality without polluting the global namespace. Bundled with Babel’s preset-env and countless build pipelines, core-js quietly powers backwards compatibility for a huge share of the web.

What You Get

• Polyfills for ECMAScript features up to the latest yearly editions (ES2015 through ES2026)
• Implementations of staged TC39 proposals you can adopt before they ship natively
• Cross-platform web standards such as URL, URLSearchParams, queueMicrotask, and structuredClone
• A namespace-clean core-js-pure build that avoids modifying global prototypes
• The core-js-compat tooling to compute exactly which modules a given browser target needs

Common Use Cases

• Shipping modern JavaScript syntax and APIs to legacy browsers via Babel’s preset-env
• Adding a single missing method (e.g. Array.prototype.flatMap) without a full polyfill bundle
• Providing standard-library features inside a library without polluting consumers’ globals
• Experimenting with TC39 proposals in production code ahead of native support

Under The Hood

Architecture

core-js is an npm-workspaces monorepo of five packages: the main core-js (global-polluting polyfills), core-js-pure (namespace-clean ponyfills), core-js-compat (target-to-module mapping with TypeScript definitions), core-js-builder, and core-js-bundle. The main package exposes layered entry points — es, stable, actual, full, stage, proposals, web — so consumers dial in exactly how bleeding-edge they want to be. Individual modules install features through a central internals/export.js dispatcher, which handles global vs static vs prototype targets and the forced/sham flags that let the pure build reuse the same module source. A generated compat database flows through core-js-compat to drive Babel preset-env’s module selection.

Tech Stack

The library is written in portable CommonJS JavaScript (98.5% of the codebase) with hand-authored TypeScript definitions for the compat and builder packages. It targets every JS engine from ES3 up, so it avoids modern syntax internally and leans on its own internal helpers rather than external runtime dependencies. Build and test tooling uses Babel, zx scripts, Karma, and Test262, orchestrated through npm workspaces.

Code Quality

Quality is exceptional for the scope. Roughly 567 feature modules each declare their polyfill through the shared export.js helper ($({ target, proto }, {...})) and cite the exact TC39 spec URL they implement, composed from ~329 small single-purpose internal helpers such as to-object, a-callable, and length-of-array-like. Testing is deep and multi-layered: unit suites run under Karma, Node, and Bun, with dedicated promises, observables, entries, and type-definition runners plus the full Test262 conformance suite, compat-data validation, ESLint, publint, and codespell all wired into the test script.

API Design

The public API is deliberately transparent — for the global build you import a path and use the native-looking API, and names map directly onto ECMAScript spec names, so there is essentially nothing new to learn beyond the language. Granular feature/method import paths (e.g. core-js/actual/array/flat-map) are consistent and predictable, and core-js-pure offers the same surface as importable, side-effect-free values. The main friction is choosing among the es/stable/actual/full entry points and the global vs pure variant, which the extensive documentation covers thoroughly.