Welcome to our new website,core-js.io, where our documentation is moving!

I highly recommend reading this:So, what's next?

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

Raising funds

import 'core-js/actual';Promise.try(() => 42).then(it => console.log(it)); // => 42Array.from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5][1, 2].flatMap(it => [it, it]); // => [1, 1, 2, 2]Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))  .drop(1).take(5)  .filter(it => it % 2)  .map(it => it ** 2)  .toArray(); // => [9, 25]structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])

import 'core-js/actual/promise';import 'core-js/actual/set';import 'core-js/actual/iterator';import 'core-js/actual/array/from';import 'core-js/actual/array/flat-map';import 'core-js/actual/structured-clone';Promise.try(() => 42).then(it => console.log(it)); // => 42Array.from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5][1, 2].flatMap(it => [it, it]); // => [1, 1, 2, 2]Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))  .drop(1).take(5)  .filter(it => it % 2)  .map(it => it ** 2)  .toArray(); // => [9, 25]structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])

import Promise from 'core-js-pure/actual/promise';import Set from 'core-js-pure/actual/set';import Iterator from 'core-js-pure/actual/iterator';import from from 'core-js-pure/actual/array/from';import flatMap from 'core-js-pure/actual/array/flat-map';import structuredClone from 'core-js-pure/actual/structured-clone';Promise.try(() => 42).then(it => console.log(it)); // => 42from(new Set([1, 2, 3]).union(new Set([3, 4, 5]))); // => [1, 2, 3, 4, 5]flatMap([1, 2], it => [it, it]); // => [1, 1, 2, 2]Iterator.concat([1, 2], function * (i) { while (true) yield i++; }(3))  .drop(1).take(5)  .filter(it => it % 2)  .map(it => it ** 2)  .toArray(); // => [9, 25]structuredClone(new Set([1, 2, 3])); // => new Set([1, 2, 3])

Index

Usage⬆

Installation:⬆

// global versionnpm install --save core-js@3.46.0// version without global namespace pollutionnpm install --save core-js-pure@3.46.0// bundled global versionnpm install --save core-js-bundle@3.46.0

postinstall message⬆

ADBLOCK=true npm install// orDISABLE_OPENCOLLECTIVE=true npm install// ornpm install --loglevel silent

CommonJS API⬆

// polyfill all `core-js` features, including early-stage proposals:import "core-js";// or:import "core-js/full";// polyfill all actual features - stable ES, web standards and stage 3 ES proposals:import "core-js/actual";// polyfill only stable features - ES and web standards:import "core-js/stable";// polyfill only stable ES features:import "core-js/es";// if you want to polyfill `Set`:// all `Set`-related features, with early-stage ES proposals:import "core-js/full/set";// stable required for `Set` ES features, features from web standards and stage 3 ES proposals:import "core-js/actual/set";// stable required for `Set` ES features and features from web standards// (DOM collections iterator in this case):import "core-js/stable/set";// only stable ES features required for `Set`:import "core-js/es/set";// the same without global namespace pollution:import Set from "core-js-pure/full/set";import Set from "core-js-pure/actual/set";import Set from "core-js-pure/stable/set";import Set from "core-js-pure/es/set";// if you want to polyfill just the required methods:import "core-js/full/set/intersection";import "core-js/actual/array/find-last";import "core-js/stable/queue-microtask";import "core-js/es/array/from";// polyfill iterator helpers proposal:import "core-js/proposals/iterator-helpers";// polyfill all stage 2+ proposals:import "core-js/stage/2";

Tip

The usage of the/actual/ namespace is recommended since it includes all actual JavaScript features and does not include unstable early-stage proposals that are available mainly for experiments.

Warning

• Themodules path is an 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.
• If you usecore-js with the extension of native objects, recommended to load allcore-js modules at the top of the entry point of your application, otherwise, you can have conflicts.
  • For example, Google Maps use their ownSymbol.iterator, conflicting withArray.from,URLSearchParams and / or something else fromcore-js, seerelated issues.
  • Such conflicts are also resolvable by discovering and manually adding each conflicting entry fromcore-js.
• core-js is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle upcore-js instead of a usage loader for each file, otherwise, you will have hundreds of requests.

CommonJS and prototype methods without global namespace pollution⬆

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

Warning

The bind operator is an early-stage ECMAScript proposal and usage of this syntax can be dangerous.

Babel⬆

@babel/polyfill⬆

import 'core-js/stable';import 'regenerator-runtime/runtime';

@babel/preset-env⬆

Important

It is recommended to specify the used minorcore-js version, likecorejs: '3.46', instead ofcorejs: 3, since withcorejs: 3 will not be injected modules which were added in minorcore-js releases.

import 'core-js/stable';

import 'core-js/modules/es.array.unscopables.flat';import 'core-js/modules/es.array.unscopables.flat-map';import 'core-js/modules/es.object.from-entries';import 'core-js/modules/web.immediate';

import 'core-js/es';import 'core-js/proposals/set-methods';import 'core-js/full/set/map';

import 'core-js/modules/es.array.unscopables.flat';import 'core-js/modules/es.array.unscopables.flat-map';import 'core-js/modules/es.object.from-entries';import 'core-js/modules/esnext.set.difference';import 'core-js/modules/esnext.set.intersection';import 'core-js/modules/esnext.set.is-disjoint-from';import 'core-js/modules/esnext.set.is-subset-of';import 'core-js/modules/esnext.set.is-superset-of';import 'core-js/modules/esnext.set.map';import 'core-js/modules/esnext.set.symmetric-difference';import 'core-js/modules/esnext.set.union';

// first file:let set = new Set([1, 2, 3]);

// second file:let array = Array.of(1, 2, 3);

// first file:import 'core-js/modules/es.array.iterator';import 'core-js/modules/es.object.to-string';import 'core-js/modules/es.set';var set = new Set([1, 2, 3]);

// second file:import 'core-js/modules/es.array.of';var array = Array.of(1, 2, 3);

Important

In the case ofuseBuiltIns: 'usage', you should not addcore-js imports by yourself, they will be added automatically.

@babel/runtime⬆

import from from 'core-js-pure/stable/array/from';import flat from 'core-js-pure/stable/array/flat';import Set from 'core-js-pure/stable/set';import Promise from 'core-js-pure/stable/promise';from(new Set([1, 2, 3, 2, 1]));flat([1, [2, 3], [4, [5]]], 2);Promise.resolve(32).then(x => console.log(x));

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

Warning

If you use@babel/preset-env and@babel/runtime together, usecorejs option only in one place since it's duplicate functionality and will cause conflicts.

swc⬆

{  "env": {    "targets": "> 0.25%, not dead",    "mode": "entry",    "coreJs": "3.46"  }}

Configurable level of aggressiveness⬆

const configurator = require('core-js/configurator');configurator({  useNative: ['Promise'],                                 // polyfills will be used only if natives are completely unavailable  usePolyfill: ['Array.from', 'String.prototype.padEnd'], // polyfills will be used anyway  useFeatureDetection: ['Map', 'Set'],                    // default behavior});require('core-js/actual');

Custom build⬆

Supported engines and compatibility data⬆

Features:⬆

core-js(-pure)

ECMAScript⬆

core-js(-pure)/es

ECMAScript: Object⬆

class Object {  toString(): string; // ES2015+ fix: @@toStringTag support  __defineGetter__(property: PropertyKey, getter: Function): void;  __defineSetter__(property: PropertyKey, setter: Function): void;  __lookupGetter__(property: PropertyKey): Function | void;  __lookupSetter__(property: PropertyKey): Function | void;  __proto__: Object | null; // required a way setting of prototype - will not in IE10-, it's for modern engines like Deno  static assign(target: Object, ...sources: Array<Object>): Object;  static create(prototype: Object | null, properties?: { [property: PropertyKey]: PropertyDescriptor }): Object;  static defineProperties(object: Object, properties: { [property: PropertyKey]: PropertyDescriptor })): Object;  static defineProperty(object: Object, property: PropertyKey, attributes: PropertyDescriptor): Object;  static entries(object: Object): Array<[string, mixed]>;  static freeze(object: any): any;  static fromEntries(iterable: Iterable<[key, value]>): Object;  static getOwnPropertyDescriptor(object: any, property: PropertyKey): PropertyDescriptor | void;  static getOwnPropertyDescriptors(object: any): { [property: PropertyKey]: PropertyDescriptor };  static getOwnPropertyNames(object: any): Array<string>;  static getPrototypeOf(object: any): Object | null;  static groupBy(items: Iterable, callbackfn: (value: any, index: number) => key): { [key]: Array<mixed> };  static hasOwn(object: object, key: PropertyKey): boolean;  static is(value1: any, value2: any): boolean;  static isExtensible(object: any): boolean;  static isFrozen(object: any): boolean;  static isSealed(object: any): boolean;  static keys(object: any): Array<string>;  static preventExtensions(object: any): any;  static seal(object: any): any;  static setPrototypeOf(target: any, prototype: Object | null): any; // required __proto__ - IE11+  static values(object: any): Array<mixed>;}

core-js(-pure)/es|stable|actual|full/objectcore-js(-pure)/es|stable|actual|full/object/assigncore-js(-pure)/es|stable|actual|full/object/iscore-js(-pure)/es|stable|actual|full/object/set-prototype-ofcore-js(-pure)/es|stable|actual|full/object/get-prototype-ofcore-js(-pure)/es|stable|actual|full/object/createcore-js(-pure)/es|stable|actual|full/object/define-propertycore-js(-pure)/es|stable|actual|full/object/define-propertiescore-js(-pure)/es|stable|actual|full/object/get-own-property-descriptorcore-js(-pure)/es|stable|actual|full/object/get-own-property-descriptorscore-js(-pure)/es|stable|actual|full/object/group-bycore-js(-pure)/es|stable|actual|full/object/has-owncore-js(-pure)/es|stable|actual|full/object/keyscore-js(-pure)/es|stable|actual|full/object/valuescore-js(-pure)/es|stable|actual|full/object/entriescore-js(-pure)/es|stable|actual|full/object/get-own-property-namescore-js(-pure)/es|stable|actual|full/object/freezecore-js(-pure)/es|stable|actual|full/object/from-entriescore-js(-pure)/es|stable|actual|full/object/sealcore-js(-pure)/es|stable|actual|full/object/prevent-extensionscore-js/es|stable|actual|full/object/protocore-js(-pure)/es|stable|actual|full/object/is-frozencore-js(-pure)/es|stable|actual|full/object/is-sealedcore-js(-pure)/es|stable|actual|full/object/is-extensiblecore-js/es|stable|actual|full/object/to-stringcore-js(-pure)/es|stable|actual|full/object/define-gettercore-js(-pure)/es|stable|actual|full/object/define-settercore-js(-pure)/es|stable|actual|full/object/lookup-gettercore-js(-pure)/es|stable|actual|full/object/lookup-setter

let foo = { q: 1, w: 2 };let bar = { e: 3, r: 4 };let 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); // => trueObject.is(0, -0);    // => falseObject.is(42, 42);   // => trueObject.is(42, '42'); // => falsefunction Parent() { /* empty */ }function Child() { /* empty */ }Object.setPrototypeOf(Child.prototype, Parent.prototype);new Child() instanceof Child;  // => truenew Child() instanceof Parent; // => true({  [Symbol.toStringTag]: 'Foo',}).toString(); // => '[object Foo]'Object.keys('qwe'); // => ['0', '1', '2']Object.getPrototypeOf('qwe') === String.prototype; // => trueObject.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}// Shallow object cloning with prototype and descriptors:let copy = Object.create(Object.getPrototypeOf(object), Object.getOwnPropertyDescriptors(object));// Mixin:Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));const map = new Map([['a', 1], ['b', 2]]);Object.fromEntries(map); // => { a: 1, b: 2 }class Unit {  constructor(id) {    this.id = id;  }  toString() {    return `unit${ this.id }`;  }}const units = new Set([new Unit(101), new Unit(102)]);Object.fromEntries(units.entries()); // => { unit101: Unit { id: 101 }, unit102: Unit { id: 102 } }Object.hasOwn({ foo: 42 }, 'foo'); // => trueObject.hasOwn({ foo: 42 }, 'bar'); // => falseObject.hasOwn({}, 'toString');     // => falseObject.groupBy([1, 2, 3, 4, 5], it => it % 2); // => { 1: [1, 3, 5], 0: [2, 4] }

ECMAScript: Function⬆

class Function {  name: string;  bind(thisArg: any, ...args: Array<mixed>): Function;  @@hasInstance(value: any): boolean;}

core-js/es|stable|actual|full/functioncore-js/es|stable|actual|full/function/namecore-js/es|stable|actual|full/function/has-instancecore-js(-pure)/es|stable|actual|full/function/bindcore-js(-pure)/es|stable|actual|full/function/virtual/bind

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

ECMAScript: Error⬆

class Error {  static isError(value: any): boolean;  constructor(message: string, { cause: any }): %Error%;  toString(): string; // different fixes}class [  EvalError,  RangeError,  ReferenceError,  SyntaxError,  TypeError,  URIError,  WebAssembly.CompileError,  WebAssembly.LinkError,  WebAssembly.RuntimeError,] extends Error {  constructor(message: string, { cause: any }): %Error%;}class AggregateError extends Error {  constructor(errors: Iterable, message?: string, { cause: any }?): AggregateError;  errors: Array<any>;  message: string;  cause: any;}class SuppressedError extends Error {  constructor(error: any, suppressed: any, message?: string): SuppressedError;  error: any;  suppressed: any;  message: string;}

core-js/es|stable|actual|full/errorcore-js/es|stable|actual|full/error/constructorcore-js(-pure)/es|stable|actual|full/error/is-errorcore-js/es|stable|actual|full/error/to-stringcore-js(-pure)/es|stable|actual|full/aggregate-errorcore-js(-pure)/es|stable|actual|full/suppressed-error

const error1 = new TypeError('Error 1');const error2 = new TypeError('Error 2');const aggregate = new AggregateError([error1, error2], 'Collected errors');aggregate.errors[0] === error1; // => trueaggregate.errors[1] === error2; // => trueconst cause = new TypeError('Something wrong');const error = new TypeError('Here explained what`s wrong', { cause });error.cause === cause; // => trueError.prototype.toString.call({ message: 1, name: 2 }) === '2: 1'; // => true

Error.isError(new Error('error')); // => trueError.isError(new TypeError('error')); // => trueError.isError(new DOMException('error')); // => trueError.isError(null); // => falseError.isError({}); // => falseError.isError(Object.create(Error.prototype)); // => false

Warning

We have no bulletproof way to polyfill thisError.isError / check if the object is an error, so it's an enough naive implementation.

ECMAScript: Array⬆

class Array {  at(index: int): any;  concat(...args: Array<mixed>): Array<mixed>; // with adding support of @@isConcatSpreadable and @@species  copyWithin(target: number, start: number, end?: number): this;  entries(): Iterator<[index, value]>;  every(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): boolean;  fill(value: any, start?: number, end?: number): this;  filter(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): Array<mixed>; // with adding support of @@species  find(callbackfn: (value: any, index: number, target: any) => boolean), thisArg?: any): any;  findIndex(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): uint;  findLast(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): any;  findLastIndex(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): uint;  flat(depthArg?: number = 1): Array<mixed>;  flatMap(mapFn: (value: any, index: number, target: any) => any, thisArg: any): Array<mixed>;  forEach(callbackfn: (value: any, index: number, target: any) => void, thisArg?: any): void;  includes(searchElement: any, from?: number): boolean;  indexOf(searchElement: any, from?: number): number;  join(separator: string = ','): string;  keys(): Iterator<index>;  lastIndexOf(searchElement: any, from?: number): number;  map(mapFn: (value: any, index: number, target: any) => any, thisArg?: any): Array<mixed>; // with adding support of @@species  push(...args: Array<mixed>): uint;  reduce(callbackfn: (memo: any, value: any, index: number, target: any) => any, initialValue?: any): any;  reduceRight(callbackfn: (memo: any, value: any, index: number, target: any) => any, initialValue?: any): any;  reverse(): this; // Safari 12.0 bug fix  slice(start?: number, end?: number): Array<mixed>; // with adding support of @@species  splice(start?: number, deleteCount?: number, ...items: Array<mixed>): Array<mixed>; // with adding support of @@species  some(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): boolean;  sort(comparefn?: (a: any, b: any) => number): this; // with modern behavior like stable sort  toReversed(): Array<mixed>;  toSpliced(start?: number, deleteCount?: number, ...items: Array<mixed>): Array<mixed>;  toSorted(comparefn?: (a: any, b: any) => number): Array<mixed>;  unshift(...args: Array<mixed>): uint;  values(): Iterator<value>;  with(index: includes, value: any): Array<mixed>;  @@iterator(): Iterator<value>;  @@unscopables: { [newMethodNames: string]: true };  static from(items: Iterable | ArrayLike, mapFn?: (value: any, index: number) => any, thisArg?: any): Array<mixed>;  static fromAsync(asyncItems: AsyncIterable | Iterable | ArrayLike, mapfn?: (value: any, index: number) => any, thisArg?: any): Array;  static isArray(value: any): boolean;  static of(...args: Array<mixed>): Array<mixed>;}class Arguments {  @@iterator(): Iterator<value>; // available only in core-js methods}

core-js(-pure)/es|stable|actual|full/arraycore-js(-pure)/es|stable|actual|full/array/fromcore-js(-pure)/es|stable|actual|full/array/from-asynccore-js(-pure)/es|stable|actual|full/array/ofcore-js(-pure)/es|stable|actual|full/array/is-arraycore-js(-pure)/es|stable|actual|full/array(/virtual)/atcore-js(-pure)/es|stable|actual|full/array(/virtual)/concatcore-js(-pure)/es|stable|actual|full/array(/virtual)/copy-withincore-js(-pure)/es|stable|actual|full/array(/virtual)/entriescore-js(-pure)/es|stable|actual|full/array(/virtual)/everycore-js(-pure)/es|stable|actual|full/array(/virtual)/fillcore-js(-pure)/es|stable|actual|full/array(/virtual)/filtercore-js(-pure)/es|stable|actual|full/array(/virtual)/findcore-js(-pure)/es|stable|actual|full/array(/virtual)/find-indexcore-js(-pure)/es|stable|actual|full/array(/virtual)/find-lastcore-js(-pure)/es|stable|actual|full/array(/virtual)/find-last-indexcore-js(-pure)/es|stable|actual|full/array(/virtual)/flatcore-js(-pure)/es|stable|actual|full/array(/virtual)/flat-mapcore-js(-pure)/es|stable|actual|full/array(/virtual)/for-eachcore-js(-pure)/es|stable|actual|full/array(/virtual)/includescore-js(-pure)/es|stable|actual|full/array(/virtual)/index-ofcore-js(-pure)/es|stable|actual|full/array(/virtual)/iteratorcore-js(-pure)/es|stable|actual|full/array(/virtual)/joincore-js(-pure)/es|stable|actual|full/array(/virtual)/keyscore-js(-pure)/es|stable|actual|full/array(/virtual)/last-index-ofcore-js(-pure)/es|stable|actual|full/array(/virtual)/mapcore-js(-pure)/es|stable|actual|full/array(/virtual)/pushcore-js(-pure)/es|stable|actual|full/array(/virtual)/reducecore-js(-pure)/es|stable|actual|full/array(/virtual)/reduce-rightcore-js(-pure)/es|stable|actual|full/array(/virtual)/reversecore-js(-pure)/es|stable|actual|full/array(/virtual)/slicecore-js(-pure)/es|stable|actual|full/array(/virtual)/somecore-js(-pure)/es|stable|actual|full/array(/virtual)/sortcore-js(-pure)/es|stable|actual|full/array(/virtual)/splicecore-js(-pure)/es|stable|actual|full/array(/virtual)/to-reversedcore-js(-pure)/es|stable|actual|full/array(/virtual)/to-sortedcore-js(-pure)/es|stable|actual|full/array(/virtual)/to-splicedcore-js(-pure)/es|stable|actual|full/array(/virtual)/unshiftcore-js(-pure)/es|stable|actual|full/array(/virtual)/valuescore-js(-pure)/es|stable|actual|full/array(/virtual)/with

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', it => it ** 2);            // => [1, 4, 9]Array.of(1);       // => [1]Array.of(1, 2, 3); // => [1, 2, 3]let array = ['a', 'b', 'c'];for (let value of array) console.log(value);          // => 'a', 'b', 'c'for (let value of array.values()) console.log(value); // => 'a', 'b', 'c'for (let key of array.keys()) console.log(key);       // => 0, 1, 2for (let [key, value] of array.entries()) {  console.log(key);                                   // => 0, 1, 2  console.log(value);                                 // => 'a', 'b', 'c'}function isOdd(value) {  return value % 2;}[4, 8, 15, 16, 23, 42].find(isOdd);      // => 15[4, 8, 15, 16, 23, 42].findIndex(isOdd); // => 2[1, 2, 3, 4].findLast(isOdd);            // => 3[1, 2, 3, 4].findLastIndex(isOdd);       // => 2Array(5).fill(42); // => [42, 42, 42, 42, 42][1, 2, 3, 4, 5].copyWithin(0, 3); // => [4, 5, 3, 4, 5][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);          // => trueArray(1).indexOf(undefined);  // => -1Array(1).includes(undefined); // => true[1, [2, 3], [4, 5]].flat();    // => [1, 2, 3, 4, 5][1, [2, [3, [4]]], 5].flat();  // => [1, 2, [3, [4]], 5][1, [2, [3, [4]]], 5].flat(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][1, 2, 3].at(1);  // => 2[1, 2, 3].at(-1); // => 3const sequence = [1, 2, 3];sequence.toReversed(); // => [3, 2, 1]sequence; // => [1, 2, 3]const initialArray = [1, 2, 3, 4];initialArray.toSpliced(1, 2, 5, 6, 7); // => [1, 5, 6, 7, 4]initialArray; // => [1, 2, 3, 4]const outOfOrder = [3, 1, 2];outOfOrder.toSorted(); // => [1, 2, 3]outOfOrder; // => [3, 1, 2]const correctionNeeded = [1, 1, 3];correctionNeeded.with(1, 2); // => [1, 2, 3]correctionNeeded; // => [1, 1, 3]

await Array.fromAsync((async function * () { yield * [1, 2, 3]; })(), i => i ** 2); // => [1, 4, 9]

ECMAScript: Iterator⬆

class Iterator {  static from(iterable: Iterable<any> | Iterator<any>): Iterator<any>;  drop(limit: uint): Iterator<any>;  every(callbackfn: (value: any, counter: uint) => boolean): boolean;  filter(callbackfn: (value: any, counter: uint) => boolean): Iterator<any>;  find(callbackfn: (value: any, counter: uint) => boolean)): any;  flatMap(callbackfn: (value: any, counter: uint) => Iterable<any> | Iterator<any>): Iterator<any>;  forEach(callbackfn: (value: any, counter: uint) => void): void;  map(callbackfn: (value: any, counter: uint) => any): Iterator<any>;  reduce(callbackfn: (memo: any, value: any, counter: uint) => any, initialValue: any): any;  some(callbackfn: (value: any, counter: uint) => boolean): boolean;  take(limit: uint): Iterator<any>;  toArray(): Array<any>;  @@dispose(): undefined;  @@toStringTag: 'Iterator'}

core-js(-pure)/es|stable|actual|full/iteratorcore-js(-pure)/es|stable|actual|full/iterator/disposecore-js(-pure)/es|stable|actual|full/iterator/dropcore-js(-pure)/es|stable|actual|full/iterator/everycore-js(-pure)/es|stable|actual|full/iterator/filtercore-js(-pure)/es|stable|actual|full/iterator/findcore-js(-pure)/es|stable|actual|full/iterator/flat-mapcore-js(-pure)/es|stable|actual|full/iterator/for-eachcore-js(-pure)/es|stable|actual|full/iterator/fromcore-js(-pure)/es|stable|actual|full/iterator/mapcore-js(-pure)/es|stable|actual|full/iterator/reducecore-js(-pure)/es|stable|actual|full/iterator/somecore-js(-pure)/es|stable|actual|full/iterator/takecore-js(-pure)/es|stable|actual|full/iterator/to-array

[1, 2, 3, 4, 5, 6, 7].values()  .drop(1)  .take(5)  .filter(it => it % 2)  .map(it => it ** 2)  .toArray(); // => [9, 25]Iterator.from({  next: () => ({ done: Math.random() > 0.9, value: Math.random() * 10 | 0 }),}).toArray(); // => [7, 6, 3, 0, 2, 8]

Warning

• For preventing prototype pollution, in thepure version, new%IteratorPrototype% methods are not added to the real%IteratorPrototype%, they are available only on wrappers - instead of[].values().map(fn) useIterator.from([]).map(fn).

ECMAScript: String and RegExp⬆

class String {  static fromCodePoint(...codePoints: Array<number>): string;  static raw({ raw: Array<string> }, ...substitutions: Array<string>): string;  at(index: int): string;  includes(searchString: string, position?: number): boolean;  startsWith(searchString: string, position?: number): boolean;  endsWith(searchString: string, position?: number): boolean;  repeat(count: number): string;  padStart(length: number, fillStr?: string = ' '): string;  padEnd(length: number, fillStr?: string = ' '): string;  codePointAt(pos: number): number | void;  match(template: any): any; // ES2015+ fix for support @@match  matchAll(regexp: RegExp): Iterator;  replace(template: any, replacer: any): any; // ES2015+ fix for support @@replace  replaceAll(searchValue: string | RegExp, replaceString: string | (searchValue, index, this) => string): string;  search(template: any): any; // ES2015+ fix for support @@search  split(template: any, limit?: int): Array<string>;; // ES2015+ fix for support @@split, some fixes for old engines  trim(): string;  trimLeft(): string;  trimRight(): string;  trimStart(): string;  trimEnd(): string;  isWellFormed(): boolean;  toWellFormed(): string;  anchor(name: string): string;  big(): string;  blink(): string;  bold(): string;  fixed(): string;  fontcolor(color: string): string;  fontsize(size: any): string;  italics(): string;  link(url: string): string;  small(): string;  strike(): string;  sub(): string;  substr(start: int, length?: int): string;  sup(): string;  @@iterator(): Iterator<characters>;}class RegExp {  // support of sticky (`y`) flag, dotAll (`s`) flag, named capture groups, can alter flags  constructor(pattern: RegExp | string, flags?: string): RegExp;  static escape(value: string): string  exec(): Array<string | undefined> | null; // IE8 fixes  test(string: string): boolean; // delegation to `.exec`  toString(): string; // ES2015+ fix - generic  @@match(string: string): Array | null;  @@matchAll(string: string): Iterator;  @@replace(string: string, replaceValue: Function | string): string;  @@search(string: string): number;  @@split(string: string, limit: number): Array<string>;  readonly attribute dotAll: boolean; // IE9+  readonly attribute flags: string;   // IE9+  readonly attribute sticky: boolean; // IE9+}function escape(string: string): string;function unescape(string: string): string;

core-js(-pure)/es|stable|actual|full/stringcore-js(-pure)/es|stable|actual|full/string/from-code-pointcore-js(-pure)/es|stable|actual|full/string/rawcore-js/es|stable|actual|full/string/matchcore-js/es|stable|actual|full/string/replacecore-js/es|stable|actual|full/string/searchcore-js/es|stable|actual|full/string/splitcore-js(-pure)/es|stable|actual/string(/virtual)/atcore-js(-pure)/es|stable|actual|full/string(/virtual)/code-point-atcore-js(-pure)/es|stable|actual|full/string(/virtual)/ends-withcore-js(-pure)/es|stable|actual|full/string(/virtual)/includescore-js(-pure)/es|stable|actual|full/string(/virtual)/starts-withcore-js(-pure)/es|stable|actual|full/string(/virtual)/match-allcore-js(-pure)/es|stable|actual|full/string(/virtual)/pad-startcore-js(-pure)/es|stable|actual|full/string(/virtual)/pad-endcore-js(-pure)/es|stable|actual|full/string(/virtual)/repeatcore-js(-pure)/es|stable|actual|full/string(/virtual)/replace-allcore-js(-pure)/es|stable|actual|full/string(/virtual)/trimcore-js(-pure)/es|stable|actual|full/string(/virtual)/trim-startcore-js(-pure)/es|stable|actual|full/string(/virtual)/trim-endcore-js(-pure)/es|stable|actual|full/string(/virtual)/trim-leftcore-js(-pure)/es|stable|actual|full/string(/virtual)/trim-rightcore-js(-pure)/es|stable|actual|full/string(/virtual)/is-well-formedcore-js(-pure)/es|stable|actual|full/string(/virtual)/to-well-formedcore-js(-pure)/es|stable|actual|full/string(/virtual)/anchorcore-js(-pure)/es|stable|actual|full/string(/virtual)/bigcore-js(-pure)/es|stable|actual|full/string(/virtual)/blinkcore-js(-pure)/es|stable|actual|full/string(/virtual)/boldcore-js(-pure)/es|stable|actual|full/string(/virtual)/fixedcore-js(-pure)/es|stable|actual|full/string(/virtual)/fontcolorcore-js(-pure)/es|stable|actual|full/string(/virtual)/fontsizecore-js(-pure)/es|stable|actual|full/string(/virtual)/italicscore-js(-pure)/es|stable|actual|full/string(/virtual)/linkcore-js(-pure)/es|stable|actual|full/string(/virtual)/smallcore-js(-pure)/es|stable|actual|full/string(/virtual)/strikecore-js(-pure)/es|stable|actual|full/string(/virtual)/subcore-js(-pure)/es|stable|actual|full/string(/virtual)/substrcore-js(-pure)/es|stable|actual|full/string(/virtual)/supcore-js(-pure)/es|stable|actual|full/string(/virtual)/iteratorcore-js/es|stable|actual|full/regexpcore-js/es|stable|actual|full/regexp/constructorcore-js(-pure)/es|stable|actual|full/regexp/escapecore-js/es|stable|actual|full/regexp/dot-allcore-js(-pure)/es|stable|actual|full/regexp/flagscore-js/es|stable|actual|full/regexp/stickycore-js/es|stable|actual|full/regexp/testcore-js/es|stable|actual|full/regexp/to-stringcore-js/es|stable|actual|full/escapecore-js/es|stable|actual|full/unescape

for (let value of 'a𠮷b') {  console.log(value); // => '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''hello'.padStart(10);         // => '     hello''hello'.padStart(10, '1234'); // => '12341hello''hello'.padEnd(10);           // => 'hello     ''hello'.padEnd(10, '1234');   // => 'hello12341''𠮷'.codePointAt(0); // => 134071String.fromCodePoint(97, 134071, 98); // => 'a𠮷b'let name = 'Bob';String.raw`Hi\n${ name }!`;           // => 'Hi\\nBob!' (ES2015 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('https://example.com'); // => '<a href="https://example.com">baz</a>'RegExp('.', 's').test('\n'); // => trueRegExp('.', 's').dotAll;     // => trueRegExp('foo:(?<foo>\\w+),bar:(?<bar>\\w+)').exec('foo:abc,bar:def').groups; // => { foo: 'abc', bar: 'def' }'foo:abc,bar:def'.replace(RegExp('foo:(?<foo>\\w+),bar:(?<bar>\\w+)'), '$<bar>,$<foo>'); // => 'def,abc'// eslint-disable-next-line regexp/no-useless-flag -- exampleRegExp(/./g, 'm'); // => /./m/foo/.flags;   // => ''/foo/gi.flags; // => 'gi'RegExp('foo', 'y').sticky; // => trueconst text = 'First line\nSecond line';const regex = RegExp('(?<index>\\S+) line\\n?', 'y');regex.exec(text).groups.index; // => 'First'regex.exec(text).groups.index; // => 'Second'regex.exec(text);    // => null'foo'.match({ [Symbol.match]: () => 1 });     // => 1'foo'.replace({ [Symbol.replace]: () => 2 }); // => 2'foo'.search({ [Symbol.search]: () => 3 });   // => 3'foo'.split({ [Symbol.split]: () => 4 });     // => 4RegExp.prototype.toString.call({ source: 'foo', flags: 'bar' }); // => '/foo/bar''   hello   '.trimLeft();  // => 'hello   ''   hello   '.trimRight(); // => '   hello''   hello   '.trimStart(); // => 'hello   ''   hello   '.trimEnd();   // => '   hello'for (let { groups: { number, letter } } of '1111a2b3cccc'.matchAll(RegExp('(?<number>\\d)(?<letter>\\D)', 'g'))) {  console.log(number, letter); // => 1 a, 2 b, 3 c}'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -> 'Test foo test test foo test.''abc'.at(1);  // => 'b''abc'.at(-1); // => 'c''a💩b'.isWellFormed();      // => true'a\uD83Db'.isWellFormed();  // => false'a💩b'.toWellFormed();      // => 'a💩b''a\uD83Db'.toWellFormed();  // => 'a�b'

console.log(RegExp.escape('10$')); // => '\\x310\\$'console.log(RegExp.escape('abcdefg_123456')); // => '\\x61bcdefg_123456'console.log(RegExp.escape('Привет')); // => 'Привет'console.log(RegExp.escape('(){}[]|,.?*+-^$=<>\\/#&!%:;@~\'"`'));// => '\\(\\)\\{\\}\\[\\]\\|\\x2c\\.\\?\\*\\+\\x2d\\^\\$\\x3d\\x3c\\x3e\\\\\\/\\x23\\x26\\x21\\x25\\x3a\\x3b\\x40\\x7e\\x27\\x22\\x60'console.log(RegExp.escape('\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'));// => '\\\t\\\n\\\v\\\f\\\r\\x20\\xa0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u2028\\u2029\\ufeff'console.log(RegExp.escape('💩')); // => '💩'console.log(RegExp.escape('\uD83D')); // => '\\ud83d'

ECMAScript: Number⬆

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

class Number {  constructor(value: any): number;  toExponential(digits: number): string;  toFixed(digits: number): string;  toPrecision(precision: number): string;  static isFinite(number: any): boolean;  static isNaN(number: any): boolean;  static isInteger(number: any): boolean;  static isSafeInteger(number: any): boolean;  static parseFloat(string: string): number;  static parseInt(string: string, radix?: number = 10): number;  static EPSILON: number;  static MAX_SAFE_INTEGER: number;  static MIN_SAFE_INTEGER: number;}function parseFloat(string: string): number;function parseInt(string: string, radix?: number = 10): number;

core-js(-pure)/es|stable|actual|full/numbercore-js(-pure)/es|stable|actual|full/number/constructorcore-js(-pure)/es|stable|actual|full/number/is-finitecore-js(-pure)/es|stable|actual|full/number/is-nancore-js(-pure)/es|stable|actual|full/number/is-integercore-js(-pure)/es|stable|actual|full/number/is-safe-integercore-js(-pure)/es|stable|actual|full/number/parse-floatcore-js(-pure)/es|stable|actual|full/number/parse-intcore-js(-pure)/es|stable|actual|full/number/epsiloncore-js(-pure)/es|stable|actual|full/number/max-safe-integercore-js(-pure)/es|stable|actual|full/number/min-safe-integercore-js(-pure)/es|stable|actual|full/number(/virtual)/to-exponentialcore-js(-pure)/es|stable|actual|full/number(/virtual)/to-fixedcore-js(-pure)/es|stable|actual|full/number(/virtual)/to-precisioncore-js(-pure)/es|stable|actual|full/parse-floatcore-js(-pure)/es|stable|actual|full/parse-int

ECMAScript: Math⬆

namespace Math {  acosh(number: number): number;  asinh(number: number): number;  atanh(number: number): number;  cbrt(number: number): number;  clz32(number: number): number;  cosh(number: number): number;  expm1(number: number): number;  fround(number: number): number;  f16round(number: any): number;  hypot(...args: Array<number>): number;  imul(number1: number, number2: number): number;  log1p(number: number): number;  log10(number: number): number;  log2(number: number): number;  sign(number: number): 1 | -1 | 0 | -0 | NaN;  sinh(number: number): number;  sumPrecise(items: Iterable<number>): Number;  tanh(number: number): number;  trunc(number: number): number;}

core-js(-pure)/es|stable|actual|full/mathcore-js(-pure)/es|stable|actual|full/math/acoshcore-js(-pure)/es|stable|actual|full/math/asinhcore-js(-pure)/es|stable|actual|full/math/atanhcore-js(-pure)/es|stable|actual|full/math/cbrtcore-js(-pure)/es|stable|actual|full/math/clz32core-js(-pure)/es|stable|actual|full/math/coshcore-js(-pure)/es|stable|actual|full/math/expm1core-js(-pure)/es|stable|actual|full/math/froundcore-js(-pure)/es|stable|actual|full/math/f16roundcore-js(-pure)/es|stable|actual|full/math/hypotcore-js(-pure)/es|stable|actual|full/math/imulcore-js(-pure)/es|stable|actual|full/math/log1pcore-js(-pure)/es|stable|actual|full/math/log10core-js(-pure)/es|stable|actual|full/math/log2core-js(-pure)/es|stable|actual|full/math/signcore-js(-pure)/es|stable|actual|full/math/sinhcore-js(-pure)/es|stable|actual|full/math/sum-precisecore-js(-pure)/es|stable|actual|full/math/tanhcore-js(-pure)/es|stable|actual|full/math/trunc

1e20 + 0.1 + -1e20; // => 0Math.sumPrecise([1e20, 0.1, -1e20]); // => 0.1

ECMAScript: Date⬆

class Date {  getYear(): int;  setYear(year: int): number;  toGMTString(): string;  toISOString(): string;  toJSON(): string;  toString(): string;  @@toPrimitive(hint: 'default' | 'number' | 'string'): string | number;  static now(): number;}

core-js/es|stable|actual|full/datecore-js/es|stable|actual|full/date/to-stringcore-js(-pure)/es|stable|actual|full/date/nowcore-js(-pure)/es|stable|actual|full/date/get-yearcore-js(-pure)/es|stable|actual|full/date/set-yearcore-js(-pure)/es|stable|actual|full/date/to-gmt-stringcore-js(-pure)/es|stable|actual|full/date/to-iso-stringcore-js(-pure)/es|stable|actual|full/date/to-jsoncore-js(-pure)/es|stable|actual|full/date/to-primitive

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

ECMAScript: Promise⬆

class Promise {  constructor(executor: (resolve: Function, reject: Function) => void): Promise;  then(onFulfilled: Function, onRejected: Function): Promise;  catch(onRejected: Function): Promise;  finally(onFinally: Function): Promise;  static all(iterable: Iterable): Promise;  static allSettled(iterable: Iterable): Promise;  static any(promises: Iterable): Promise;  static race(iterable: Iterable): Promise;  static reject(r: any): Promise;  static resolve(x: any): Promise;  static try(callbackfn: Function, ...args?: Array<mixed>): Promise;  static withResolvers(): { promise: Promise, resolve: function, reject: function };}

core-js(-pure)/es|stable|actual|full/promisecore-js(-pure)/es|stable|actual|full/promise/all-settledcore-js(-pure)/es|stable|actual|full/promise/anycore-js(-pure)/es|stable|actual|full/promise/finallycore-js(-pure)/es|stable|actual|full/promise/trycore-js(-pure)/es|stable|actual|full/promise/with-resolvers

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

/* eslint-disable promise/prefer-await-to-callbacks -- example */Promise.resolve(42).then(x => console.log(x));         // => 42Promise.reject(42).catch(error => console.log(error)); // => 42Promise.resolve($.getJSON('/data.json')); // => ES promise

Promise.resolve(42).finally(() => console.log('You will see it anyway'));Promise.reject(42).finally(() => console.log('You will see it anyway'));

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

/* eslint-disable promise/prefer-await-to-callbacks -- example */function timeLimit(promise, time) {  return Promise.race([promise, new Promise((resolve, reject) => {    setTimeout(reject, time * 1e3, new Error(`Await > ${ time } sec`));  })]);}timeLimit(sleepRandom(5), 10).then(x => console.log(x));           // => 853, after 5 sec.timeLimit(sleepRandom(15), 10).catch(error => console.log(error)); // Error: Await > 10 sec

Promise.allSettled([  Promise.resolve(1),  Promise.reject(2),  Promise.resolve(3),]).then(console.log); // => [{ value: 1, status: 'fulfilled' }, { reason: 2, status: 'rejected' }, { value: 3, status: 'fulfilled' }]

Promise.any([  Promise.resolve(1),  Promise.reject(2),  Promise.resolve(3),]).then(console.log); // => 1Promise.any([  Promise.reject(1),  Promise.reject(2),  Promise.reject(3),]).catch(({ errors }) => console.log(errors)); // => [1, 2, 3]

/* eslint-disable promise/prefer-await-to-callbacks -- example */Promise.try(() => 42).then(it => console.log(`Promise, resolved as ${ it }`));Promise.try(() => { throw new Error('42'); }).catch(error => console.log(`Promise, rejected as ${ error }`));Promise.try(async () => 42).then(it => console.log(`Promise, resolved as ${ it }`));Promise.try(async () => { throw new Error('42'); }).catch(error => console.log(`Promise, rejected as ${ error }`));Promise.try(it => it, 42).then(it => console.log(`Promise, resolved as ${ it }`));

const d = Promise.withResolvers();d.resolve(42);d.promise.then(console.log); // => 42

let 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 new Error(msg);}(async () => {  try {    console.log('Run');                // => Run    console.log(await sleepRandom(5)); // => 936, after 5 sec.    let [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, 'Error!');    console.log('Will not be displayed');  } catch (error) {    console.log(error);                // => Error: 'Error!', after 5 sec.  }})();

Unhandled rejection tracking⬆

process.on('unhandledRejection', (reason, promise) => console.log('unhandled', reason, promise));process.on('rejectionHandled', promise => console.log('handled', promise));let promise = Promise.reject(42);// unhandled 42 [object Promise]// eslint-disable-next-line promise/prefer-await-to-then -- examplesetTimeout(() => promise.catch(() => { /* empty */ }), 1e3);// handled [object Promise]

globalThis.addEventListener('unhandledrejection', e => console.log('unhandled', e.reason, e.promise));globalThis.addEventListener('rejectionhandled', e => console.log('handled', e.reason, e.promise));// orglobalThis.onunhandledrejection = e => console.log('unhandled', e.reason, e.promise);globalThis.onrejectionhandled = e => console.log('handled', e.reason, e.promise);let promise = Promise.reject(42);// => unhandled 42 [object Promise]// eslint-disable-next-line promise/prefer-await-to-then -- examplesetTimeout(() => promise.catch(() => { /* empty */ }), 1e3);// => handled 42 [object Promise]

ECMAScript: Symbol⬆

class Symbol {  constructor(description?): symbol;  readonly attribute description: string | void;  static asyncDispose: @@asyncDispose;  static asyncIterator: @@asyncIterator;  static dispose: @@dispose;  static hasInstance: @@hasInstance;  static isConcatSpreadable: @@isConcatSpreadable;  static iterator: @@iterator;  static match: @@match;  static replace: @@replace;  static search: @@search;  static species: @@species;  static split: @@split;  static toPrimitive: @@toPrimitive;  static toStringTag: @@toStringTag;  static unscopables: @@unscopables;  static for(key: string): symbol;  static keyFor(sym: symbol): string;  static useSimple(): void;  static useSetter(): void;}class Object {  static getOwnPropertySymbols(object: any): Array<symbol>;}

class Object {  static create(prototype: Object | null, properties?: { [property: PropertyKey]: PropertyDescriptor }): Object;  static defineProperties(object: Object, properties: { [property: PropertyKey]: PropertyDescriptor })): Object;  static defineProperty(object: Object, property: PropertyKey, attributes: PropertyDescriptor): Object;  static getOwnPropertyDescriptor(object: any, property: PropertyKey): PropertyDescriptor | void;  static getOwnPropertyNames(object: any): Array<string>;  propertyIsEnumerable(key: PropertyKey): boolean;}

core-js(-pure)/es|stable|actual|full/symbolcore-js(-pure)/es|stable|actual|full/symbol/async-disposecore-js(-pure)/es|stable|actual|full/symbol/async-iteratorcore-js/es|stable|actual|full/symbol/descriptioncore-js(-pure)/es|stable|actual|full/symbol/disposecore-js(-pure)/es|stable|actual|full/symbol/has-instancecore-js(-pure)/es|stable|actual|full/symbol/is-concat-spreadablecore-js(-pure)/es|stable|actual|full/symbol/iteratorcore-js(-pure)/es|stable|actual|full/symbol/matchcore-js(-pure)/es|stable|actual|full/symbol/replacecore-js(-pure)/es|stable|actual|full/symbol/searchcore-js(-pure)/es|stable|actual|full/symbol/speciescore-js(-pure)/es|stable|actual|full/symbol/splitcore-js(-pure)/es|stable|actual|full/symbol/to-primitivecore-js(-pure)/es|stable|actual|full/symbol/to-string-tagcore-js(-pure)/es|stable|actual|full/symbol/unscopablescore-js(-pure)/es|stable|actual|full/symbol/forcore-js(-pure)/es|stable|actual|full/symbol/key-forcore-js(-pure)/es|stable|actual|full/object/get-own-property-symbolscore-js(-pure)/es|stable|actual|full/math/to-string-tag

let Person = (() => {  let NAME = Symbol('name');  return class {    constructor(name) {      this[NAME] = name;    }    getName() {      return this[NAME];    }  };})();let person = new Person('Vasya');console.log(person.getName());            // => 'Vasya'console.log(person.name);                 // => undefinedconsole.log(person[Symbol('name')]);      // => undefined, symbols are uniqfor (let key in person) console.log(key); // => nothing, symbols are not enumerable

let symbol = Symbol.for('key');symbol === Symbol.for('key'); // trueSymbol.keyFor(symbol);        // 'key'

let object = { a: 1 };Object.defineProperty(object, 'b', { value: 2 });object[Symbol('c')] = 3;Object.keys(object);                  // => ['a']Object.getOwnPropertyNames(object);   // => ['a', 'b']Object.getOwnPropertySymbols(object); // => [Symbol(c)]Reflect.ownKeys(object);              // => ['a', 'b', Symbol(c)]

Symbol('foo').description; // => 'foo'// eslint-disable-next-line symbol-description -- exampleSymbol().description;      // => undefined

Caveats when usingSymbol polyfill:⬆

Symbol.useSimple();let object1 = { [Symbol('symbol1')]: true };for (let key in object1) console.log(key); // => 'Symbol(symbol1)_t.qamkg9f3q', w/o native SymbolSymbol.useSetter();let object2 = { [Symbol('symbol2')]: true };for (let key in object2) console.log(key); // nothing

ECMAScript: Collections⬆

Map⬆

class Map {  constructor(iterable?: Iterable<[key, value]>): Map;  clear(): void;  delete(key: any): boolean;  forEach(callbackfn: (value: any, key: any, target: any) => void, thisArg: any): void;  get(key: any): any;  has(key: any): boolean;  set(key: any, val: any): this;  values(): Iterator<value>;  keys(): Iterator<key>;  entries(): Iterator<[key, value]>;  @@iterator(): Iterator<[key, value]>;  readonly attribute size: number;  static groupBy(items: Iterable, callbackfn: (value: any, index: number) => key): Map<key, Array<mixed>>;}

core-js(-pure)/es|stable|actual|full/mapcore-js(-pure)/es|stable|actual|full/map/group-by

let array = [1];let map = new Map([['a', 1], [42, 2]]);map.set(array, 3).set(true, 4);console.log(map.size);        // => 4console.log(map.has(array));  // => trueconsole.log(map.has([1]));    // => falseconsole.log(map.get(array));  // => 3map.forEach((val, key) => {  console.log(val);           // => 1, 2, 3, 4  console.log(key);           // => 'a', 42, [1], true});map.delete(array);console.log(map.size);        // => 3console.log(map.get(array));  // => undefinedconsole.log(Array.from(map)); // => [['a', 1], [42, 2], [true, 4]]map = new Map([['a', 1], ['b', 2], ['c', 3]]);for (let [key, value] of map) {  console.log(key);                                 // => 'a', 'b', 'c'  console.log(value);                               // => 1, 2, 3}for (let value of map.values()) console.log(value); // => 1, 2, 3for (let key of map.keys()) console.log(key);       // => 'a', 'b', 'c'for (let [key, value] of map.entries()) {  console.log(key);                                 // => 'a', 'b', 'c'  console.log(value);                               // => 1, 2, 3}map = Map.groupBy([1, 2, 3, 4, 5], it => it % 2);map.get(1); // => [1, 3, 5]map.get(0); // => [2, 4]

Set⬆

class Set {  constructor(iterable?: Iterable<value>): Set;  add(key: any): this;  clear(): void;  delete(key: any): boolean;  forEach((value: any, key: any, target: any) => void, thisArg: any): void;  has(key: any): boolean;  values(): Iterator<value>;  keys(): Iterator<value>;  entries(): Iterator<[value, value]>;  difference(other: SetLike<mixed>): Set;  intersection(other: SetLike<mixed>): Set;  isDisjointFrom(other: SetLike<mixed>): boolean;  isSubsetOf(other: SetLike<mixed>): boolean;  isSupersetOf(other: SetLike<mixed>): boolean;  symmetricDifference(other: SetLike<mixed>): Set;  union(other: SetLike<mixed>): Set;  @@iterator(): Iterator<value>;  readonly attribute size: number;}

core-js(-pure)/es|stable|actual|full/setcore-js(-pure)/es|stable|actual|full/set/differencecore-js(-pure)/es|stable|actual|full/set/intersectioncore-js(-pure)/es|stable|actual|full/set/is-disjoint-fromcore-js(-pure)/es|stable|actual|full/set/is-subset-ofcore-js(-pure)/es|stable|actual|full/set/is-superset-ofcore-js(-pure)/es|stable|actual|full/set/symmetric-differencecore-js(-pure)/es|stable|actual|full/set/union

let set = new Set(['a', 'b', 'a', 'c']);set.add('d').add('b').add('e');console.log(set.size);        // => 5console.log(set.has('b'));    // => trueset.forEach(it => {  console.log(it);            // => 'a', 'b', 'c', 'd', 'e'});set.delete('b');console.log(set.size);        // => 4console.log(set.has('b'));    // => falseconsole.log(Array.from(set)); // => ['a', 'c', 'd', 'e']set = new Set([1, 2, 3, 2, 1]);for (let value of set) console.log(value);          // => 1, 2, 3for (let value of set.values()) console.log(value); // => 1, 2, 3for (let key of set.keys()) console.log(key);       // => 1, 2, 3for (let [key, value] of set.entries()) {  console.log(key);                                 // => 1, 2, 3  console.log(value);                               // => 1, 2, 3}new Set([1, 2, 3]).union(new Set([3, 4, 5]));               // => Set {1, 2, 3, 4, 5}new Set([1, 2, 3]).intersection(new Set([3, 4, 5]));        // => Set {3}new Set([1, 2, 3]).difference(new Set([3, 4, 5]));          // => Set {1, 2}new Set([1, 2, 3]).symmetricDifference(new Set([3, 4, 5])); // => Set {1, 2, 4, 5}new Set([1, 2, 3]).isDisjointFrom(new Set([4, 5, 6]));      // => truenew Set([1, 2, 3]).isSubsetOf(new Set([5, 4, 3, 2, 1]));    // => truenew Set([5, 4, 3, 2, 1]).isSupersetOf(new Set([1, 2, 3]));  // => true

WeakMap⬆

class WeakMap {  constructor(iterable?: Iterable<[key, value]>): WeakMap;  delete(key: Object): boolean;  get(key: Object): any;  has(key: Object): boolean;  set(key: Object, val: any): this;}

core-js(-pure)/es|stable|actual|full/weak-map

let a = [1];let b = [2];let c = [3];let weakmap = new WeakMap([[a, 1], [b, 2]]);weakmap.set(c, 3).set(b, 4);console.log(weakmap.has(a));   // => trueconsole.log(weakmap.has([1])); // => falseconsole.log(weakmap.get(a));   // => 1weakmap.delete(a);console.log(weakmap.get(a));   // => undefined// Private properties store:let Person = (() => {  let names = new WeakMap();  return class {    constructor(name) {      names.set(this, name);    }    getName() {      return names.get(this);    }  };})();let person = new Person('Vasya');console.log(person.getName());            // => 'Vasya'for (let key in person) console.log(key); // => only 'getName'

WeakSet⬆

class WeakSet {  constructor(iterable?: Iterable<value>): WeakSet;  add(key: Object): this;  delete(key: Object): boolean;  has(key: Object): boolean;}

core-js(-pure)/es|stable|actual|full/weak-set

let a = [1];let b = [2];let c = [3];let weakset = new WeakSet([a, b, a]);weakset.add(c).add(b).add(c);console.log(weakset.has(b));   // => trueconsole.log(weakset.has([2])); // => falseweakset.delete(b);console.log(weakset.has(b));   // => false

Warning

• Weak-collections polyfill stores values as hidden properties of keys. It works correctly and does not leak in most cases. However, it is desirable to store a collection longer than its keys.
• Native symbols asWeakMap keys can't be properly polyfilled without memory leaks.

ECMAScript: Explicit Resource Management⬆

Note

This is only built-ins for this Explicit Resource Management,using syntax support requirestranspiler support.

class Symbol {  static asyncDispose: @@asyncDispose;  static dispose: @@dispose;}class DisposableStack {  constructor(): DisposableStack;  dispose(): undefined;  use(value: Disposable): value;  adopt(value: object, onDispose: Function): value;  defer(onDispose: Function): undefined;  move(): DisposableStack;  @@dispose(): undefined;  @@toStringTag: 'DisposableStack';}class AsyncDisposableStack {  constructor(): AsyncDisposableStack;  disposeAsync(): Promise<undefined>;  use(value: AsyncDisposable | Disposable): value;  adopt(value: object, onDispose: Function): value;  defer(onDispose: Function): undefined;  move(): AsyncDisposableStack;  @@asyncDispose(): Promise<undefined>;  @@toStringTag: 'AsyncDisposableStack';}class SuppressedError extends Error {  constructor(error: any, suppressed: any, message?: string): SuppressedError;  error: any;  suppressed: any;  message: string;  cause: any;}class Iterator {  @@dispose(): undefined;}class AsyncIterator {  @@asyncDispose(): Promise<undefined>;}

core-js(-pure)/es|stable|actual|full/disposable-stackcore-js(-pure)/es|stable|actual|full/async-disposable-stackcore-js(-pure)/es|stable|actual|full/iterator/disposecore-js(-pure)/es|stable|actual|full/async-iterator/async-dispose

ECMAScript: Typed Arrays⬆

class ArrayBuffer {  constructor(length: any): ArrayBuffer;  readonly attribute byteLength: number;  readonly attribute detached: boolean;  slice(start: any, end: any): ArrayBuffer;  transfer(newLength?: number): ArrayBuffer;  transferToFixedLength(newLength?: number): ArrayBuffer;  static isView(arg: any): boolean;}class DataView {  constructor(buffer: ArrayBuffer, byteOffset?: number, byteLength?: number): DataView;  getInt8(offset: any): int8;  getUint8(offset: any): uint8  getInt16(offset: any, littleEndian?: boolean = false): int16;  getUint16(offset: any, littleEndian?: boolean = false): uint16;  getInt32(offset: any, littleEndian?: boolean = false): int32;  getUint32(offset: any, littleEndian?: boolean = false): uint32;  getFloat16(offset: any, littleEndian?: boolean = false): float16  getFloat32(offset: any, littleEndian?: boolean = false): float32;  getFloat64(offset: any, littleEndian?: boolean = false): float64;  setInt8(offset: any, value: any): void;  setUint8(offset: any, value: any): void;  setInt16(offset: any, value: any, littleEndian?: boolean = false): void;  setUint16(offset: any, value: any, littleEndian?: boolean = false): void;  setInt32(offset: any, value: any, littleEndian?: boolean = false): void;  setUint32(offset: any, value: any, littleEndian?: boolean = false): void;  setFloat16(offset: any, value: any, littleEndian?: boolean = false): void;  setFloat32(offset: any, value: any, littleEndian?: boolean = false): void;  setFloat64(offset: any, value: any, littleEndian?: boolean = false): void;  readonly attribute buffer: ArrayBuffer;  readonly attribute byteLength: number;  readonly attribute byteOffset: number;}class [  Int8Array,  Uint8Array,  Uint8ClampedArray,  Int16Array,  Uint16Array,  Int32Array,  Uint32Array,  Float32Array,  Float64Array,] extends %TypedArray% {  constructor(length: number): %TypedArray%;  constructor(object: %TypedArray% | Iterable | ArrayLike): %TypedArray%;  constructor(buffer: ArrayBuffer, byteOffset?: number, length?: number): %TypedArray%}class %TypedArray% {  at(index: int): number;  copyWithin(target: number, start: number, end?: number): this;  entries(): Iterator<[index, value]>;  every(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean, thisArg?: any): boolean;  fill(value: number, start?: number, end?: number): this;  filter(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean, thisArg?: any): %TypedArray%;  find(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean), thisArg?: any): any;  findIndex(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean, thisArg?: any): uint;  findLast(callbackfn: (value: any, index: number, target: %TypedArray%) => boolean, thisArg?: any): any;  findLastIndex(callbackfn: (value: any, index: number, target: %TypedArray%) => boolean, thisArg?: any): uint;  forEach(callbackfn: (value: number, index: number, target: %TypedArray%) => void, thisArg?: any): void;  includes(searchElement: any, from?: number): boolean;  indexOf(searchElement: any, from?: number): number;  join(separator: string = ','): string;  keys(): Iterator<index>;  lastIndexOf(searchElement: any, from?: number): number;  map(mapFn: (value: number, index: number, target: %TypedArray%) => number, thisArg?: any): %TypedArray%;  reduce(callbackfn: (memo: any, value: number, index: number, target: %TypedArray%) => any, initialValue?: any): any;  reduceRight(callbackfn: (memo: any, value: number, index: number, target: %TypedArray%) => any, initialValue?: any): any;  reverse(): this;  set(array: ArrayLike, offset?: number): void;  slice(start?: number, end?: number): %TypedArray%;  some(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean, thisArg?: any): boolean;  sort(comparefn?: (a: number, b: number) => number): this; // with modern behavior like stable sort  subarray(begin?: number, end?: number): %TypedArray%;  toReversed(): %TypedArray%;  toSorted(comparefn?: (a: any, b: any) => number): %TypedArray%;  toString(): string;  toLocaleString(): string;  values(): Iterator<value>;  with(index: includes, value: any): %TypedArray%;  @@iterator(): Iterator<value>;  readonly attribute buffer: ArrayBuffer;  readonly attribute byteLength: number;  readonly attribute byteOffset: number;  readonly attribute length: number;  BYTES_PER_ELEMENT: number;  static from(items: Iterable | ArrayLike, mapFn?: (value: any, index: number) => any, thisArg?: any): %TypedArray%;  static of(...args: Array<mixed>): %TypedArray%;  static BYTES_PER_ELEMENT: number;}class Uint8Array {  static fromBase64(string: string, options?: { alphabet?: 'base64' | 'base64url', lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial' }): Uint8Array;  static fromHex(string: string): Uint8Array;  setFromBase64(string: string, options?: { alphabet?: 'base64' | 'base64url', lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial' }): { read: uint, written: uint };  setFromHex(string: string): { read: uint, written: uint };  toBase64(options?: { alphabet?: 'base64' | 'base64url', omitPadding?: boolean }): string;  toHex(): string;}

core-js/es|stable|actual|full/array-buffercore-js/es|stable|actual|full/array-buffer/constructorcore-js/es|stable|actual|full/array-buffer/is-viewcore-js/es|stable|actual|full/array-buffer/detachedcore-js/es|stable|actual|full/array-buffer/slicecore-js/es|stable|actual|full/array-buffer/transfercore-js/es|stable|actual|full/array-buffer/transfer-to-fixed-lengthcore-js/es|stable|actual|full/data-viewcore-js/es|stable|actual|full/dataview/get-float16core-js/es|stable|actual|full/dataview/set-float16core-js/es|stable|actual|full/typed-arraycore-js/es|stable|actual|full/typed-array/int8-arraycore-js/es|stable|actual|full/typed-array/uint8-arraycore-js/es|stable|actual|full/typed-array/uint8-clamped-arraycore-js/es|stable|actual|full/typed-array/int16-arraycore-js/es|stable|actual|full/typed-array/uint16-arraycore-js/es|stable|actual|full/typed-array/int32-arraycore-js/es|stable|actual|full/typed-array/uint32-arraycore-js/es|stable|actual|full/typed-array/float32-arraycore-js/es|stable|actual|full/typed-array/float64-arraycore-js/es|stable|actual|full/typed-array/atcore-js/es|stable|actual|full/typed-array/copy-withincore-js/es|stable|actual|full/typed-array/entriescore-js/es|stable|actual|full/typed-array/everycore-js/es|stable|actual|full/typed-array/fillcore-js/es|stable|actual|full/typed-array/filtercore-js/es|stable|actual|full/typed-array/findcore-js/es|stable|actual|full/typed-array/find-indexcore-js/es|stable|actual|full/typed-array/find-lastcore-js/es|stable|actual|full/typed-array/find-last-indexcore-js/es|stable|actual|full/typed-array/for-eachcore-js/es|stable|actual|full/typed-array/fromcore-js/es|stable|actual|full/typed-array/from-base64core-js/es|stable|actual|full/typed-array/from-hexcore-js/es|stable|actual|full/typed-array/includescore-js/es|stable|actual|full/typed-array/index-ofcore-js/es|stable|actual|full/typed-array/iteratorcore-js/es|stable|actual|full/typed-array/joincore-js/es|stable|actual|full/typed-array/keyscore-js/es|stable|actual|full/typed-array/last-index-ofcore-js/es|stable|actual|full/typed-array/mapcore-js/es|stable|actual|full/typed-array/ofcore-js/es|stable|actual|full/typed-array/reducecore-js/es|stable|actual|full/typed-array/reduce-rightcore-js/es|stable|actual|full/typed-array/reversecore-js/es|stable|actual|full/typed-array/setcore-js/es|stable|actual|full/typed-array/set-from-base64core-js/es|stable|actual|full/typed-array/set-from-hexcore-js/es|stable|actual|full/typed-array/slicecore-js/es|stable|actual|full/typed-array/somecore-js/es|stable|actual|full/typed-array/sortcore-js/es|stable|actual|full/typed-array/subarraycore-js/es|stable|actual|full/typed-array/to-base64core-js/es|stable|actual|full/typed-array/to-hexcore-js/es|stable|actual|full/typed-array/to-locale-stringcore-js/es|stable|actual|full/typed-array/to-reversedcore-js/es|stable|actual|full/typed-array/to-sortedcore-js/es|stable|actual|full/typed-array/to-stringcore-js/es|stable|actual|full/typed-array/valuescore-js/es|stable|actual|full/typed-array/with

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]let buffer = new ArrayBuffer(8);let 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]let typed = new Uint8Array([1, 2, 3]);let a = typed.slice(1);    // => [2, 3]typed.buffer === a.buffer; // => falselet b = typed.subarray(1); // => [2, 3]typed.buffer === b.buffer; // => truetyped.filter(it => it % 2); // => [1, 3]typed.map(it => it * 1.5);  // => [1, 3, 4]for (let value of typed) console.log(value);          // => 1, 2, 3for (let value of typed.values()) console.log(value); // => 1, 2, 3for (let key of typed.keys()) console.log(key);       // => 0, 1, 2for (let [key, value] of typed.entries()) {  console.log(key);                                   // => 0, 1, 2  console.log(value);                                 // => 1, 2, 3}new Int32Array([1, 2, 3]).at(1);  // => 2new Int32Array([1, 2, 3]).at(-1); // => 3buffer = Int8Array.of(1, 2, 3, 4, 5, 6, 7, 8).buffer;console.log(buffer.byteLength); // => 8console.log(buffer.detached); // => falseconst newBuffer = buffer.transfer(4);console.log(buffer.byteLength); // => 0console.log(buffer.detached); // => trueconsole.log(newBuffer.byteLength); // => 4console.log(newBuffer.detached); // => falseconsole.log([...new Int8Array(newBuffer)]); // => [1, 2, 3, 4]

let arr = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);console.log(arr.toBase64()); // => 'SGVsbG8gV29ybGQ='console.log(arr.toBase64({ omitPadding: true })); // => 'SGVsbG8gV29ybGQ'console.log(arr.toHex()); // => '48656c6c6f20576f726c64'console.log(Uint8Array.fromBase64('SGVsbG8gV29ybGQ=')); // => Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100])console.log(Uint8Array.fromHex('48656c6c6f20576f726c64')); // => Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100])

Warning

• Polyfills of Typed Arrays constructors work completely how they should work by the spec. Still, because of the internal usage of getters / setters on each instance, they are slow and consume significant memory. However, polyfills of Typed Arrays constructors are required mainly for old IE, all modern engines have native Typed Arrays constructors and require only fixes of constructors and polyfills of methods.
• ArrayBuffer.prototype.{ transfer, transferToFixedLength } polyfilled only in runtime with nativestructuredClone withArrayBuffer transfer orMessageChannel support.

ECMAScript: Reflect⬆

namespace Reflect {  apply(target: Function, thisArgument: any, argumentsList: Array<mixed>): any;  construct(target: Function, argumentsList: Array<mixed>, newTarget?: Function): Object;  defineProperty(target: Object, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;  deleteProperty(target: Object, propertyKey: PropertyKey): boolean;  get(target: Object, propertyKey: PropertyKey, receiver?: any): any;  getOwnPropertyDescriptor(target: Object, propertyKey: PropertyKey): PropertyDescriptor | void;  getPrototypeOf(target: Object): Object | null;  has(target: Object, propertyKey: PropertyKey): boolean;  isExtensible(target: Object): boolean;  ownKeys(target: Object): Array<string | symbol>;  preventExtensions(target: Object): boolean;  set(target: Object, propertyKey: PropertyKey, V: any, receiver?: any): boolean;  setPrototypeOf(target: Object, proto: Object | null): boolean; // required __proto__ - IE11+}

core-js(-pure)/es|stable|actual|full/reflectcore-js(-pure)/es|stable|actual|full/reflect/applycore-js(-pure)/es|stable|actual|full/reflect/constructcore-js(-pure)/es|stable|actual|full/reflect/define-propertycore-js(-pure)/es|stable|actual|full/reflect/delete-propertycore-js(-pure)/es|stable|actual|full/reflect/getcore-js(-pure)/es|stable|actual|full/reflect/get-own-property-descriptorcore-js(-pure)/es|stable|actual|full/reflect/get-prototype-ofcore-js(-pure)/es|stable|actual|full/reflect/hascore-js(-pure)/es|stable|actual|full/reflect/is-extensiblecore-js(-pure)/es|stable|actual|full/reflect/own-keyscore-js(-pure)/es|stable|actual|full/reflect/prevent-extensionscore-js(-pure)/es|stable|actual|full/reflect/setcore-js(-pure)/es|stable|actual|full/reflect/set-prototype-of

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

ECMAScript: JSON⬆

namespace JSON {  stringify(value: any, replacer?: Array<string | number> | (this: any, key: string, value: any) => any, space?: string | number): string | void;  @@toStringTag: 'JSON';}

core-js(-pure)/es|stable|actual|full/json/stringifycore-js(-pure)/es|stable|actual|full/json/to-string-tag

JSON.stringify({ '𠮷': ['\uDF06\uD834'] }); // => '{"𠮷":["\\udf06\\ud834"]}'

ECMAScript: globalThis⬆

let globalThis: GlobalThisValue;

core-js(-pure)/es|stable|actual|full/global-this

globalThis.Array === Array; // => true

ECMAScript proposals⬆

Finished proposals⬆

globalThis⬆

let globalThis: GlobalThisValue;

core-js/proposals/global-this

Relative indexing method⬆

class Array {  at(index: int): any;}class String {  at(index: int): string;}class %TypedArray% {  at(index: int): number;}

core-js/proposals/relative-indexing-method

Array.prototype.includes⬆

class Array {  includes(searchElement: any, from?: number): boolean;}class %TypedArray% {  includes(searchElement: any, from?: number): boolean;}

core-js/proposals/array-includes

Array.prototype.flat /Array.prototype.flatMap⬆

class Array {  flat(depthArg?: number = 1): Array<mixed>;  flatMap(mapFn: (value: any, index: number, target: any) => any, thisArg: any): Array<mixed>;}

core-js/proposals/array-flat-map

Array find from last⬆

class Array {  findLast(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): any;  findLastIndex(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): uint;}class %TypedArray% {  findLast(callbackfn: (value: any, index: number, target: %TypedArray%) => boolean, thisArg?: any): any;  findLastIndex(callbackfn: (value: any, index: number, target: %TypedArray%) => boolean, thisArg?: any): uint;}

core-js/proposals/array-find-from-last

ChangeArray by copy⬆

class Array {  toReversed(): Array<mixed>;  toSpliced(start?: number, deleteCount?: number, ...items: Array<mixed>): Array<mixed>;  toSorted(comparefn?: (a: any, b: any) => number): Array<mixed>;  with(index: includes, value: any): Array<mixed>;}class %TypedArray% {  toReversed(): %TypedArray%;  toSorted(comparefn?: (a: any, b: any) => number): %TypedArray%;  with(index: includes, value: any): %TypedArray%;}

core-js/proposals/change-array-by-copy-stage-4core-js(-pure)/es|stable|actual|full/array(/virtual)/to-reversedcore-js(-pure)/es|stable|actual|full/array(/virtual)/to-sortedcore-js(-pure)/es|stable|actual|full/array(/virtual)/to-splicedcore-js(-pure)/es|stable|actual|full/array(/virtual)/withcore-js/es|stable|actual|full/typed-array/to-reversedcore-js/es|stable|actual|full/typed-array/to-sortedcore-js/es|stable|actual|full/typed-array/with

Array grouping⬆

class Object {  static groupBy(items: Iterable, callbackfn: (value: any, index: number) => key): { [key]: Array<mixed> };}class Map {  static groupBy(items: Iterable, callbackfn: (value: any, index: number) => key): Map<key, Array<mixed>>;}

core-js/proposals/array-grouping-v2

Array.fromAsync⬆

class Array {  static fromAsync(asyncItems: AsyncIterable | Iterable | ArrayLike, mapfn?: (value: any, index: number) => any, thisArg?: any): Array;}

core-js/proposals/array-from-async-stage-2

ArrayBuffer.prototype.transfer and friends⬆

class ArrayBuffer {  readonly attribute detached: boolean;  transfer(newLength?: number): ArrayBuffer;  transferToFixedLength(newLength?: number): ArrayBuffer;}

core-js/proposals/array-buffer-transfer

Uint8Array to / from base64 and hex⬆

class Uint8Array {  static fromBase64(string: string, options?: { alphabet?: 'base64' | 'base64url', lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial' }): Uint8Array;  static fromHex(string: string): Uint8Array;  setFromBase64(string: string, options?: { alphabet?: 'base64' | 'base64url', lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial' }): { read: uint, written: uint };  setFromHex(string: string): { read: uint, written: uint };  toBase64(options?: { alphabet?: 'base64' | 'base64url', omitPadding?: boolean }): string;  toHex(): string;}

core-js/proposals/array-buffer-base64

Error.isError⬆

class Error {  static isError(value: any): boolean;}

core-js/proposals/is-error

Warning

We have no bulletproof way to polyfill thisError.isError / check if the object is an error, so it's an enough naive implementation.

Explicit Resource Management⬆

Note

This is only built-ins for this Explicit Resource Management,using syntax support requirestranspiler support.

class Symbol {  static asyncDispose: @@asyncDispose;  static dispose: @@dispose;}class DisposableStack {  constructor(): DisposableStack;  dispose(): undefined;  use(value: Disposable): value;  adopt(value: object, onDispose: Function): value;  defer(onDispose: Function): undefined;  move(): DisposableStack;  @@dispose(): undefined;  @@toStringTag: 'DisposableStack';}class AsyncDisposableStack {  constructor(): AsyncDisposableStack;  disposeAsync(): Promise<undefined>;  use(value: AsyncDisposable | Disposable): value;  adopt(value: object, onDispose: Function): value;  defer(onDispose: Function): undefined;  move(): AsyncDisposableStack;  @@asyncDispose(): Promise<undefined>;  @@toStringTag: 'AsyncDisposableStack';}class SuppressedError extends Error {  constructor(error: any, suppressed: any, message?: string): SuppressedError;  error: any;  suppressed: any;  message: string;  cause: any;}class Iterator {  @@dispose(): undefined;}class AsyncIterator {  @@asyncDispose(): Promise<undefined>;}

core-js/proposals/explicit-resource-management

Float16 methods⬆

class DataView {  getFloat16(offset: any, littleEndian?: boolean = false): float16  setFloat16(offset: any, value: any, littleEndian?: boolean = false): void;}namespace Math {  fround(number: any): number;}

core-js/proposals/float16

Iterator helpers⬆

class Iterator {  static from(iterable: Iterable<any> | Iterator<any>): Iterator<any>;  drop(limit: uint): Iterator<any>;  every(callbackfn: (value: any, counter: uint) => boolean): boolean;  filter(callbackfn: (value: any, counter: uint) => boolean): Iterator<any>;  find(callbackfn: (value: any, counter: uint) => boolean)): any;  flatMap(callbackfn: (value: any, counter: uint) => Iterable<any> | Iterator<any>): Iterator<any>;  forEach(callbackfn: (value: any, counter: uint) => void): void;  map(callbackfn: (value: any, counter: uint) => any): Iterator<any>;  reduce(callbackfn: (memo: any, value: any, counter: uint) => any, initialValue: any): any;  some(callbackfn: (value: any, counter: uint) => boolean): boolean;  take(limit: uint): Iterator<any>;  toArray(): Array<any>;  @@toStringTag: 'Iterator'}

core-js/proposals/iterator-helpers-stage-3-2

Object.values /Object.entries⬆

class Object {  static entries(object: Object): Array<[string, mixed]>;  static values(object: any): Array<mixed>;}

core-js/proposals/object-values-entries

Object.fromEntries⬆

class Object {  static fromEntries(iterable: Iterable<[key, value]>): Object;}

core-js/proposals/object-from-entries

Object.getOwnPropertyDescriptors⬆

class Object {  static getOwnPropertyDescriptors(object: any): { [property: PropertyKey]: PropertyDescriptor };}

core-js/proposals/object-getownpropertydescriptors

AccessibleObject.prototype.hasOwnProperty⬆

class Object {  static hasOwn(object: object, key: PropertyKey): boolean;}

core-js/proposals/accessible-object-hasownproperty

String padding⬆

class String {  padStart(length: number, fillStr?: string = ' '): string;  padEnd(length: number, fillStr?: string = ' '): string;}

core-js/proposals/string-padding

String#matchAll⬆.

class String {  matchAll(regexp: RegExp): Iterator;}

core-js/proposals/string-match-all

String#replaceAll⬆

class String {  replaceAll(searchValue: string | RegExp, replaceString: string | (searchValue, index, this) => string): string;}

core-js/proposals/string-replace-all-stage-4

String.prototype.trimStart /String.prototype.trimEnd⬆

class String {  trimLeft(): string;  trimRight(): string;  trimStart(): string;  trimEnd(): string;}

core-js/proposals/string-left-right-trim

RegExps (dotAll) flag⬆

// patched for support `RegExp` dotAll (`s`) flag:class RegExp {  constructor(pattern: RegExp | string, flags?: string): RegExp;  exec(): Array<string | undefined> | null;  readonly attribute dotAll: boolean;  readonly attribute flags: string;}

core-js/proposals/regexp-dotall-flag

RegExp named capture groups⬆

// patched for support `RegExp` named capture groups:class RegExp {  constructor(pattern: RegExp | string, flags?: string): RegExp;  exec(): Array<string | undefined> | null;  @@replace(string: string, replaceValue: Function | string): string;}

core-js/proposals/regexp-named-groups

RegExp escaping⬆

class RegExp {  static escape(value: string): string}

core-js/proposals/regexp-escaping

Promise.allSettled⬆

class Promise {  static allSettled(iterable: Iterable): Promise;}

core-js/proposals/promise-all-settled

Promise.any⬆

class AggregateError {  constructor(errors: Iterable, message: string): AggregateError;  errors: Array<any>;  message: string;}class Promise {  static any(promises: Iterable): Promise<any>;}

core-js/proposals/promise-any

Promise.prototype.finally⬆

class Promise {  finally(onFinally: Function): Promise;}

core-js/proposals/promise-finally

Promise.try

class Promise {  static try(callbackfn: Function, ...args?: Array<mixed>): Promise;}

core-js/proposals/promise-try

Promise.withResolvers⬆

class Promise {  static withResolvers(): { promise: Promise, resolve: function, reject: function };}

core-js/proposals/promise-with-resolvers

Symbol.asyncIterator for asynchronous iteration⬆

class Symbol {  static asyncIterator: @@asyncIterator;}

core-js/proposals/async-iteration

Symbol.prototype.description⬆

class Symbol {  readonly attribute description: string | void;}

core-js/proposals/symbol-description

Well-formedJSON.stringify⬆

namespace JSON {  stringify(target: any, replacer?: Function | Array, space?: string | number): string | void;}

core-js/proposals/well-formed-stringify

Well-formed unicode strings⬆

class String {  isWellFormed(): boolean;  toWellFormed(): string;}

core-js/proposals/well-formed-unicode-strings

NewSet methods⬆

class Set {  difference(other: SetLike<mixed>): Set;  intersection(other: SetLike<mixed>): Set;  isDisjointFrom(other: SetLike<mixed>): boolean;  isSubsetOf(other: SetLike<mixed>): boolean;  isSupersetOf(other: SetLike<mixed>): boolean;  symmetricDifference(other: SetLike<mixed>): Set;  union(other: SetLike<mixed>): Set;}

core-js/proposals/set-methods-v2

Math.sumPrecise

namespace Math {  sumPrecise(items: Iterable<number>): Number;}

core-js/proposals/math-sum

Stage 3 proposals⬆

core-js(-pure)/stage/3

Iterator sequencing⬆

class Iterator {  concat(...items: Array<IterableObject>): Iterator<any>;}

core-js/proposals/iterator-sequencingcore-js(-pure)/actual|full/iterator/concat

Iterator.concat([0, 1].values(), [2, 3], function * () {  yield 4;  yield 5;}()).toArray(); // => [0, 1, 2, 3, 4, 5]

Map upsert⬆

class Map {  getOrInsert(key: any, value: any): any;  getOrInsertComputed(key: any, (key: any) => value: any): any;}class WeakMap {  getOrInsert(key: any, value: any): any;  getOrInsertComputed(key: any, (key: any) => value: any): any;}

core-js/proposals/map-upsert-v4core-js(-pure)/actual|full/map/get-or-insertcore-js(-pure)/actual|full/map/get-or-insert-computedcore-js(-pure)/actual|full/weak-map/get-or-insertcore-js(-pure)/actual|full/weak-map/get-or-insert-computed

const map = new Map([['a', 1]]);map.getOrInsert('a', 2); // => 1map.getOrInsert('b', 3); // => 3map.getOrInsertComputed('a', key => key); // => 1map.getOrInsertComputed('c', key => key); // => 'c'console.log(map); // => Map { 'a': 1, 'b': 3, 'c': 'c' }

JSON.parse source text access⬆

namespace JSON {  isRawJSON(O: any): boolean;  // patched for source support  parse(text: string, reviver?: (this: any, key: string, value: any, context: { source?: string }) => any): any;  rawJSON(text: any): RawJSON;  // patched for `JSON.rawJSON` support  stringify(value: any, replacer?: Array<string | number> | (this: any, key: string, value: any) => any, space?: string | number): string | void;}

core-js/proposals/json-parse-with-sourcecore-js(-pure)/actual|full/json/is-raw-jsoncore-js(-pure)/actual|full/json/parsecore-js(-pure)/actual|full/json/raw-jsoncore-js(-pure)/actual|full/json/stringify

function digitsToBigInt(key, val, { source }) {  return /^\d+$/.test(source) ? BigInt(source) : val;}function bigIntToRawJSON(key, val) {  return typeof val === 'bigint' ? JSON.rawJSON(String(val)) : val;}const tooBigForNumber = BigInt(Number.MAX_SAFE_INTEGER) + 2n;JSON.parse(String(tooBigForNumber), digitsToBigInt) === tooBigForNumber; // trueconst wayTooBig = BigInt(`1${ '0'.repeat(1000) }`);JSON.parse(String(wayTooBig), digitsToBigInt) === wayTooBig; // trueconst embedded = JSON.stringify({ tooBigForNumber }, bigIntToRawJSON);embedded === '{"tooBigForNumber":9007199254740993}'; // true

Symbol.metadata for decorators metadata proposal⬆

class Symbol {  static metadata: @@metadata;}class Function {  @@metadata: null;}

core-js/proposals/decorator-metadata-v2core-js(-pure)/actual|full/symbol/metadatacore-js(-pure)/actual|full/function/metadata

Stage 2.7 proposals⬆

core-js(-pure)/stage/2.7

Iterator chunking⬆

class Iterator {  chunks(chunkSize: number): Iterator<any>;  windows(windowSize: number, undersized?: 'only-full' | 'allow-partial' | undefined): Iterator<any>;}

core-js/proposals/iterator-chunking-v2core-js(-pure)/full/iterator/chunkscore-js(-pure)/full/iterator/windows

const digits = () => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].values();let chunks = Array.from(digits().chunks(2));  // [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]let windows = Array.from(digits().windows(2));  // [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]]let windowsPartial = Array.from([0, 1].values().windows(3, 'allow-partial'));  // [[0, 1]]let windowsFull = Array.from([0, 1].values().windows(3));  // []

Joint iteration⬆

class Iterator {  zip<T extends readonly Iterable<unknown>[]>(    iterables: T,    options?: {      mode?: 'shortest' | 'longest' | 'strict';      padding?: { [K in keyof T]?: T[K] extends Iterable<infer U> ? U : never };    }  ): IterableIterator<{ [K in keyof T]: T[K] extends Iterable<infer U> ? U : never }>;  zipKeyed<K extends PropertyKey, V extends Record<K, Iterable<unknown>>>(    iterables: V,    options?: {      mode?: 'shortest' | 'longest' | 'strict';      padding?: { [P in keyof V]?: V[P] extends Iterable<infer U> ? U : never };    }  ): IterableIterator<{ [P in keyof V]: V[P] extends Iterable<infer U> ? U : never }>;}

core-js/proposals/joint-iterationcore-js(-pure)/full/iterator/zipcore-js(-pure)/full/iterator/zip-keyed

Iterator.zip([  [0, 1, 2],  [3, 4, 5],]).toArray();  // => [[0, 3], [1, 4], [2, 5]]Iterator.zipKeyed({  a: [0, 1, 2],  b: [3, 4, 5, 6],  c: [7, 8, 9],}, {  mode: 'longest',  padding: { c: 10 },}).toArray();/*[  { a: 0,         b: 3, c: 7  },  { a: 1,         b: 4, c: 8  },  { a: 2,         b: 5, c: 9  },  { a: undefined, b: 6, c: 10 },]; */

Stage 2 proposals⬆

core-js(-pure)/stage/2

AsyncIterator helpers⬆

class Iterator {  toAsync(): AsyncIterator<any>;}class AsyncIterator {  static from(iterable: AsyncIterable<any> | Iterable<any> | AsyncIterator<any>): AsyncIterator<any>;  drop(limit: uint): AsyncIterator<any>;  every(async callbackfn: (value: any, counter: uint) => boolean): Promise<boolean>;  filter(async callbackfn: (value: any, counter: uint) => boolean): AsyncIterator<any>;  find(async callbackfn: (value: any, counter: uint) => boolean)): Promise<any>;  flatMap(async callbackfn: (value: any, counter: uint) => AsyncIterable<any> | Iterable<any> | AsyncIterator<any>): AsyncIterator<any>;  forEach(async callbackfn: (value: any, counter: uint) => void): Promise<void>;  map(async callbackfn: (value: any, counter: uint) => any): AsyncIterator<any>;  reduce(async callbackfn: (memo: any, value: any, counter: uint) => any, initialValue: any): Promise<any>;  some(async callbackfn: (value: any, counter: uint) => boolean): Promise<boolean>;  take(limit: uint): AsyncIterator<any>;  toArray(): Promise<Array>;  @@toStringTag: 'AsyncIterator'}

core-js/proposals/async-iterator-helperscore-js(-pure)/actual|full/async-iteratorcore-js(-pure)/actual|full/async-iterator/dropcore-js(-pure)/actual|full/async-iterator/everycore-js(-pure)/actual|full/async-iterator/filtercore-js(-pure)/actual|full/async-iterator/findcore-js(-pure)/actual|full/async-iterator/flat-mapcore-js(-pure)/actual|full/async-iterator/for-eachcore-js(-pure)/actual|full/async-iterator/fromcore-js(-pure)/actual|full/async-iterator/mapcore-js(-pure)/actual|full/async-iterator/reducecore-js(-pure)/actual|full/async-iterator/somecore-js(-pure)/actual|full/async-iterator/takecore-js(-pure)/actual|full/async-iterator/to-arraycore-js(-pure)/actual|full/iterator/to-async

await AsyncIterator.from([1, 2, 3, 4, 5, 6, 7])  .drop(1)  .take(5)  .filter(it => it % 2)  .map(it => it ** 2)  .toArray(); // => [9, 25]await [1, 2, 3].values().toAsync().map(async it => it ** 2).toArray(); // => [1, 4, 9]

Caveats:⬆

const configurator = require('core-js/configurator');configurator({ USE_FUNCTION_CONSTRUCTOR: true });require('core-js/actual/async-iterator');(async function * () { /* empty */ })() instanceof AsyncIterator; // => true

const configurator = require('core-js/configurator');const { getPrototypeOf } = Object;configurator({ AsyncIteratorPrototype: getPrototypeOf(getPrototypeOf(getPrototypeOf(async function * () { /* empty */ }()))) });require('core-js/actual/async-iterator');(async function * () { /* empty */ })() instanceof AsyncIterator; // => true

Iterator.range⬆

class Iterator {  range(start: number, end: number, options: { step: number = 1, inclusive: boolean = false } | step: number = 1): NumericRangeIterator;  range(start: bigint, end: bigint | Infinity | -Infinity, options: { step: bigint = 1n, inclusive: boolean = false } | step: bigint = 1n): NumericRangeIterator;}

core-js/proposals/number-rangecore-js(-pure)/full/iterator/range

for (const i of Iterator.range(1, 10)) {  console.log(i); // => 1, 2, 3, 4, 5, 6, 7, 8, 9}for (const i of Iterator.range(1, 10, { step: 3, inclusive: true })) {  console.log(i); // => 1, 4, 7, 10}

Array.isTemplateObject⬆

class Array {  static isTemplateObject(value: any): boolean}

core-js/proposals/array-is-template-objectcore-js(-pure)/full/array/is-template-object

console.log(Array.isTemplateObject((it => it)`qwe${ 123 }asd`)); // => true

Number.prototype.clamp⬆

class Number {  clamp(min: number, max: number): number;}

core-js/proposals/math-clamp-v2core-js(-pure)/full/number/clamp

5.0.clamp(0, 10); // => 5-5.0.clamp(0, 10); // => 015.0.clamp(0, 10); // => 10

String.dedent⬆

class String {  static dedent(templateOrTag: { raw: Array<string> } | function, ...substitutions: Array<string>): string | function;}

core-js/proposals/string-dedentcore-js(-pure)/full/string/dedent

const message = 42;console.log(String.dedent`  print('${ message }')`); // => print('42')String.dedent(console.log)`  print('${ message }')`; // => ["print('", "')", raw: Array(2)], 42

Symbol predicates⬆

class Symbol {  static isRegisteredSymbol(value: any): boolean;  static isWellKnownSymbol(value: any): boolean;}

core-js/proposals/symbol-predicates-v2core-js(-pure)/full/symbol/is-registered-symbolcore-js(-pure)/full/symbol/is-well-known-symbol

Symbol.isRegisteredSymbol(Symbol.for('key')); // => trueSymbol.isRegisteredSymbol(Symbol('key')); // => falseSymbol.isWellKnownSymbol(Symbol.iterator); // => trueSymbol.isWellKnownSymbol(Symbol('key')); // => false

Symbol.customMatcher for extractors⬆

class Symbol {  static customMatcher: @@customMatcher;}

core-js/proposals/pattern-extractorscore-js(-pure)/full/symbol/custom-matcher

Stage 1 proposals⬆

core-js(-pure)/stage/1

Observable⬆

class Observable {  constructor(subscriber: Function): Observable;  subscribe(observer: Function | { next?: Function, error?: Function, complete?: Function }): Subscription;  @@observable(): this;  static of(...items: Array<mixed>): Observable;  static from(x: Observable | Iterable): Observable;  static readonly attribute @@species: this;}class Symbol {  static observable: @@observable;}

core-js/proposals/observablecore-js(-pure)/full/observablecore-js(-pure)/full/symbol/observable

new Observable(observer => {  observer.next('hello');  observer.next('world');  observer.complete();}).subscribe({  next(it) { console.log(it); },  complete() { console.log('!'); },});

New collections methods⬆

.of and.from methods on collection constructors⬆

class Set {  static of(...args: Array<mixed>): Set;  static from(iterable: Iterable<mixed>, mapFn?: (value: any, index: number) => any, thisArg?: any): Set;  addAll(...args: Array<mixed>): this;  deleteAll(...args: Array<mixed>): boolean;  every(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): boolean;  filter(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): Set;  find(callbackfn: (value: any, key: any, target: any) => boolean), thisArg?: any): any;  join(separator: string = ','): string;  map(callbackfn: (value: any, key: any, target: any) => any, thisArg?: any): Set;  reduce(callbackfn: (memo: any, value: any, key: any, target: any) => any, initialValue?: any): any;  some(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): boolean;}class Map {  static of(...args: Array<[key, value]>): Map;  static from(iterable: Iterable<mixed>, mapFn?: (value: any, index: number) => [key: any, value: any], thisArg?: any): Map;  static keyBy(iterable: Iterable<mixed>, callbackfn?: (value: any) => any): Map;  deleteAll(...args: Array<mixed>): boolean;  every(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): boolean;  filter(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): Map;  find(callbackfn: (value: any, key: any, target: any) => boolean), thisArg?: any): any;  findKey(callbackfn: (value: any, key: any, target: any) => boolean), thisArg?: any): any;  includes(searchElement: any): boolean;  keyOf(searchElement: any): any;  mapKeys(mapFn: (value: any, index: number, target: any) => any, thisArg?: any): Map;  mapValues(mapFn: (value: any, index: number, target: any) => any, thisArg?: any): Map;  merge(...iterables: Array<Iterable>): this;  reduce(callbackfn: (memo: any, value: any, key: any, target: any) => any, initialValue?: any): any;  some(callbackfn: (value: any, key: any, target: any) => boolean, thisArg?: any): boolean;  update(key: any, callbackfn: (value: any, key: any, target: any) => any, thunk?: (key: any, target: any) => any): this;}class WeakSet {  static of(...args: Array<mixed>): WeakSet;  static from(iterable: Iterable<mixed>, mapFn?: (value: any, index: number) => Object, thisArg?: any): WeakSet;  addAll(...args: Array<mixed>): this;  deleteAll(...args: Array<mixed>): boolean;}class WeakMap {  static of(...args: Array<[key, value]>): WeakMap;  static from(iterable: Iterable<mixed>, mapFn?: (value: any, index: number) => [key: Object, value: any], thisArg?: any): WeakMap;  deleteAll(...args: Array<mixed>): boolean;}

core-js/proposals/collection-methodscore-js/proposals/collection-of-fromcore-js(-pure)/full/set/add-allcore-js(-pure)/full/set/delete-allcore-js(-pure)/full/set/everycore-js(-pure)/full/set/filtercore-js(-pure)/full/set/findcore-js(-pure)/full/set/fromcore-js(-pure)/full/set/joincore-js(-pure)/full/set/mapcore-js(-pure)/full/set/ofcore-js(-pure)/full/set/reducecore-js(-pure)/full/set/somecore-js(-pure)/full/map/delete-allcore-js(-pure)/full/map/everycore-js(-pure)/full/map/filtercore-js(-pure)/full/map/findcore-js(-pure)/full/map/find-keycore-js(-pure)/full/map/fromcore-js(-pure)/full/map/includescore-js(-pure)/full/map/key-bycore-js(-pure)/full/map/key-ofcore-js(-pure)/full/map/map-keyscore-js(-pure)/full/map/map-valuescore-js(-pure)/full/map/mergecore-js(-pure)/full/map/ofcore-js(-pure)/full/map/reducecore-js(-pure)/full/map/somecore-js(-pure)/full/map/updatecore-js(-pure)/full/weak-set/add-allcore-js(-pure)/full/weak-set/delete-allcore-js(-pure)/full/weak-set/ofcore-js(-pure)/full/weak-set/fromcore-js(-pure)/full/weak-map/delete-allcore-js(-pure)/full/weak-map/ofcore-js(-pure)/full/weak-map/from

Set.of(1, 2, 3, 2, 1); // => Set {1, 2, 3}Map.from([[1, 2], [3, 4]], ([key, value]) => [key ** 2, value ** 2]); // => Map { 1: 4, 9: 16 }

compositeKey andcompositeSymbol⬆

function compositeKey(...args: Array<mixed>): object;function compositeSymbol(...args: Array<mixed>): symbol;

core-js/proposals/keys-compositioncore-js(-pure)/full/composite-keycore-js(-pure)/full/composite-symbol

// returns a symbolconst symbol = compositeSymbol({});console.log(typeof symbol); // => 'symbol'// works the same, but returns a plain frozen object without a prototypeconst key = compositeKey({});console.log(typeof key); // => 'object'console.log({}.toString.call(key)); // => '[object Object]'console.log(Object.getPrototypeOf(key)); // => nullconsole.log(Object.isFrozen(key)); // => trueconst a = ['a'];const b = ['b'];const c = ['c'];/* eslint-disable no-self-compare -- example */console.log(compositeSymbol(a) === compositeSymbol(a)); // => trueconsole.log(compositeSymbol(a) !== compositeSymbol(['a'])); // => trueconsole.log(compositeSymbol(a, 1) === compositeSymbol(a, 1)); // => trueconsole.log(compositeSymbol(a, b) !== compositeSymbol(b, a)); // => trueconsole.log(compositeSymbol(a, b, c) === compositeSymbol(a, b, c)); // => trueconsole.log(compositeSymbol(1, a) === compositeSymbol(1, a)); // => trueconsole.log(compositeSymbol(1, a, 2, b) === compositeSymbol(1, a, 2, b)); // => trueconsole.log(compositeSymbol(a, a) === compositeSymbol(a, a)); // => true

Array filtering⬆

class Array {  filterReject(callbackfn: (value: any, index: number, target: any) => boolean, thisArg?: any): Array<mixed>;}class %TypedArray% {  filterReject(callbackfn: (value: number, index: number, target: %TypedArray%) => boolean, thisArg?: any): %TypedArray%;}

core-js/proposals/array-filtering-stage-1core-js(-pure)/full/array(/virtual)/filter-rejectcore-js/full/typed-array/filter-reject

[1, 2, 3, 4, 5].filterReject(it => it % 2); // => [2, 4]

Array deduplication⬆

class Array {  uniqueBy(resolver?: (item: any) => any): Array<mixed>;}class %TypedArray% {  uniqueBy(resolver?: (item: any) => any): %TypedArray%;;}

core-js/proposals/array-uniquecore-js(-pure)/full/array(/virtual)/unique-bycore-js/full/typed-array/unique-by

[1, 2, 3, 2, 1].uniqueBy(); // [1, 2, 3][  { id: 1, uid: 10000 },  { id: 2, uid: 10000 },  { id: 3, uid: 10001 },].uniqueBy(it => it.uid);    // => [{ id: 1, uid: 10000 }, { id: 3, uid: 10001 }]

DataView get / setUint8Clamped methods⬆

class DataView {  getUint8Clamped(offset: any): uint8  setUint8Clamped(offset: any, value: any): void;}

core-js/proposals/data-view-get-set-uint8-clampedcore-js/full/dataview/get-uint8-clampedcore-js/full/dataview/set-uint8-clamped

const view = new DataView(new ArrayBuffer(1));view.setUint8Clamped(0, 100500);console.log(view.getUint8Clamped(0)); // => 255

Number.fromString⬆

class Number {  fromString(string: string, radix: number): number;}

core-js/proposals/number-from-stringcore-js(-pure)/full/number/from-string

String.cooked⬆

class String {  static cooked(template: Array<string>, ...substitutions: Array<string>): string;}

core-js/proposals/string-cookedcore-js(-pure)/full/string/cooked

function safePath(strings, ...subs) {  return String.cooked(strings, ...subs.map(sub => encodeURIComponent(sub)));}let id = 'spottie?';safePath`/cats/${ id }`; // => /cats/spottie%3F

String.prototype.codePoints⬆

class String {  codePoints(): Iterator<{ codePoint, position }>;}

core-js/proposals/string-code-pointscore-js(-pure)/full/string/code-points

for (let { codePoint, position } of 'qwe'.codePoints()) {  console.log(codePoint); // => 113, 119, 101  console.log(position);  // => 0, 1, 2}

Symbol.customMatcher for pattern matching⬆

class Symbol {  static customMatcher: @@customMatcher;}

core-js/proposals/pattern-matching-v2core-js(-pure)/full/symbol/custom-matcher

Stage 0 proposals⬆

core-js(-pure)/stage/0

Function.prototype.demethodize⬆

class Function {  demethodize(): Function;}

core-js/proposals/function-demethodizecore-js(-pure)/full/function/demethodizecore-js(-pure)/full/function/virtual/demethodize

const slice = Array.prototype.slice.demethodize();slice([1, 2, 3], 1); // => [2, 3]

Function.{ isCallable, isConstructor }⬆

class Function {  static isCallable(value: any): boolean;  static isConstructor(value: any): boolean;}

core-js/proposals/function-is-callable-is-constructorcore-js(-pure)/full/function/is-callablecore-js(-pure)/full/function/is-constructor

/* eslint-disable prefer-arrow-callback -- example */Function.isCallable(null);                        // => falseFunction.isCallable({});                          // => falseFunction.isCallable(function () { /* empty */ }); // => trueFunction.isCallable(() => { /* empty */ });       // => trueFunction.isCallable(class { /* empty */ });       // => falseFunction.isConstructor(null);                        // => falseFunction.isConstructor({});                          // => falseFunction.isConstructor(function () { /* empty */ }); // => trueFunction.isConstructor(() => { /* empty */ });       // => falseFunction.isConstructor(class { /* empty */ });       // => true

Pre-stage 0 proposals⬆

core-js(-pure)/stage/pre

Reflect metadata⬆

namespace Reflect {  defineMetadata(metadataKey: any, metadataValue: any, target: Object, propertyKey?: PropertyKey): void;  getMetadata(metadataKey: any, target: Object, propertyKey?: PropertyKey): any;  getOwnMetadata(metadataKey: any, target: Object, propertyKey?: PropertyKey): any;  hasMetadata(metadataKey: any, target: Object, propertyKey?: PropertyKey): boolean;  hasOwnMetadata(metadataKey: any, target: Object, propertyKey?: PropertyKey): boolean;  deleteMetadata(metadataKey: any, target: Object, propertyKey?: PropertyKey): boolean;  getMetadataKeys(target: Object, propertyKey?: PropertyKey): Array<mixed>;  getOwnMetadataKeys(target: Object, propertyKey?: PropertyKey): Array<mixed>;  metadata(metadataKey: any, metadataValue: any): decorator(target: Object, targetKey?: PropertyKey) => void;}

core-js/proposals/reflect-metadatacore-js(-pure)/full/reflect/define-metadatacore-js(-pure)/full/reflect/delete-metadatacore-js(-pure)/full/reflect/get-metadatacore-js(-pure)/full/reflect/get-metadata-keyscore-js(-pure)/full/reflect/get-own-metadatacore-js(-pure)/full/reflect/get-own-metadata-keyscore-js(-pure)/full/reflect/has-metadatacore-js(-pure)/full/reflect/has-own-metadatacore-js(-pure)/full/reflect/metadata

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

Web standards⬆

self⬆

getter self: GlobalThisValue;

core-js(-pure)/stable|actual|full/self

// eslint-disable-next-line no-restricted-globals -- exampleself.Array === Array; // => true

structuredClone⬆

function structuredClone(value: Serializable, { transfer?: Sequence<Transferable> }): any;

core-js(-pure)/stable|actual|full/structured-clone

const structured = [{ a: 42 }];const sclone = structuredClone(structured);console.log(sclone);                      // => [{ a: 42 }]console.log(structured !== sclone);       // => trueconsole.log(structured[0] !== sclone[0]); // => trueconst circular = {};circular.circular = circular;const cclone = structuredClone(circular);console.log(cclone.circular === cclone);  // => truestructuredClone(42);                                            // => 42structuredClone({ x: 42 });                                     // => { x: 42 }structuredClone([1, 2, 3]);                                     // => [1, 2, 3]structuredClone(new Set([1, 2, 3]));                            // => Set{ 1, 2, 3 }structuredClone(new Map([['a', 1], ['b', 2]]));                 // => Map{ a: 1, b: 2 }structuredClone(new Int8Array([1, 2, 3]));                      // => new Int8Array([1, 2, 3])structuredClone(new AggregateError([1, 2, 3], 'message'));      // => new AggregateError([1, 2, 3], 'message'))structuredClone(new TypeError('message', { cause: 42 }));       // => new TypeError('message', { cause: 42 })structuredClone(new DOMException('message', 'DataCloneError')); // => new DOMException('message', 'DataCloneError')structuredClone(document.getElementById('myfileinput'));        // => new FileListstructuredClone(new DOMPoint(1, 2, 3, 4));                      // => new DOMPoint(1, 2, 3, 4)structuredClone(new Blob(['test']));                            // => new Blob(['test'])structuredClone(new ImageData(8, 8));                           // => new ImageData(8, 8)// etc.structuredClone(new WeakMap()); // => DataCloneError on non-serializable types

Warning

• Many platform types cannot be transferred in most engines since we have no way to polyfill this behavior, however.transfer option works for some platform types. I recommend avoiding this option.
• Some specific platform types can't be cloned in old engines. Mainly it's very specific types or very old engines, but here are some exceptions. For example, we have no sync way to cloneImageBitmap in Safari 14.0- or Firefox 83-, so it's recommended to look to thepolyfill source if you wanna clone something specific.

Base64 utility methods⬆

function atob(data: string): string;function btoa(data: string): string;

core-js(-pure)/stable|actual|full/atobcore-js(-pure)/stable|actual|full/btoa

btoa('hi, core-js');      // => 'aGksIGNvcmUtanM='atob('aGksIGNvcmUtanM='); // => 'hi, core-js'

setTimeout andsetInterval⬆

function setTimeout(callback: any, time: any, ...args: Array<mixed>): number;function setInterval(callback: any, time: any, ...args: Array<mixed>): number;

core-js(-pure)/stable|actual|full/set-timeoutcore-js(-pure)/stable|actual|full/set-interval

// Before:setTimeout(log.bind(null, 42), 1000);// After:setTimeout(log, 1000, 42);

setImmediate⬆

function setImmediate(callback: any, ...args: Array<mixed>): number;function clearImmediate(id: number): void;

core-js(-pure)/stable|actual|full/set-immediatecore-js(-pure)/stable|actual|full/clear-immediate

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

queueMicrotask⬆

function queueMicrotask(fn: Function): void;

core-js(-pure)/stable|actual|full/queue-microtask

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

URL andURLSearchParams⬆

class URL {  constructor(url: string, base?: string);  attribute href: string;  readonly attribute origin: string;  attribute protocol: string;  attribute username: string;  attribute password: string;  attribute host: string;  attribute hostname: string;  attribute port: string;  attribute pathname: string;  attribute search: string;  readonly attribute searchParams: URLSearchParams;  attribute hash: string;  toJSON(): string;  toString(): string;  static canParse(url: string, base?: string): boolean;  static parse(url: string, base?: string): URL | null;}class URLSearchParams {  constructor(params?: string | Iterable<[key, value]> | Object);  append(name: string, value: string): void;  delete(name: string, value?: string): void;  get(name: string): string | void;  getAll(name: string): Array<string>;  has(name: string, value?: string): boolean;  set(name: string, value: string): void;  sort(): void;  toString(): string;  forEach(callbackfn: (value: any, index: number, target: any) => void, thisArg: any): void;  entries(): Iterator<[key, value]>;  keys(): Iterator<key>;  values(): Iterator<value>;  @@iterator(): Iterator<[key, value]>;  readonly attribute size: number;}

core-js/proposals/urlcore-js(-pure)/stable|actual|full/urlcore-js(-pure)/stable|actual|full/url/can-parsecore-js/stable|actual|full/url/to-jsoncore-js(-pure)/stable|actual|full/url-search-params

URL.canParse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'); // => trueURL.canParse('https'); // => falseURL.parse('https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'); // => urlURL.parse('https'); // => nullconst url = new URL('https://login:password@example.com:8080/foo/bar?a=1&b=2&a=3#fragment');console.log(url.href);       // => 'https://login:password@example.com:8080/foo/bar?a=1&b=2&a=3#fragment'console.log(url.origin);     // => 'https://example.com:8080'console.log(url.protocol);   // => 'https:'console.log(url.username);   // => 'login'console.log(url.password);   // => 'password'console.log(url.host);       // => 'example.com:8080'console.log(url.hostname);   // => 'example.com'console.log(url.port);       // => '8080'console.log(url.pathname);   // => '/foo/bar'console.log(url.search);     // => '?a=1&b=2&a=3'console.log(url.hash);       // => '#fragment'console.log(url.toJSON());   // => 'https://login:password@example.com:8080/foo/bar?a=1&b=2&a=3#fragment'console.log(url.toString()); // => 'https://login:password@example.com:8080/foo/bar?a=1&b=2&a=3#fragment'for (let [key, value] of url.searchParams) {  console.log(key);   // => 'a', 'b', 'a'  console.log(value); // => '1', '2', '3'}url.pathname = '';url.searchParams.append('c', 4);console.log(url.search); // => '?a=1&b=2&a=3&c=4'console.log(url.href);   // => 'https://login:password@example.com:8080/?a=1&b=2&a=3&c=4#fragment'const params = new URLSearchParams('?a=1&b=2&a=3');params.append('c', 4);params.append('a', 2);params.delete('a', 1);params.sort();console.log(params.size); // => 4for (let [key, value] of params) {  console.log(key);   // => 'a', 'a', 'b', 'c'  console.log(value); // => '3', '2', '2', '4'}console.log(params.has('a')); // => trueconsole.log(params.has('a', 3)); // => trueconsole.log(params.has('a', 4)); // => falseconsole.log(params.toString()); // => 'a=3&a=2&b=2&c=4'

Warning

• IE8 does not support setters, so they do not work onURL instances. However,URL constructor can be used for basicURL parsing.
• Legacy encodings in a search query are not supported. Also,core-js implementation has some other encoding-related issues.
• URL implementations from all of the popular browsers have significantly more problems thancore-js, however, replacing all of them does not look like a good idea. You can customize the aggressiveness of polyfillby your requirements.

DOMException:⬆

class DOMException {  constructor(message: string, name?: string);  readonly attribute name: string;  readonly attribute message: string;  readonly attribute code: string;  attribute stack: string; // in engines that should have it  @@toStringTag: 'DOMException';}

core-js(-pure)/stable|actual|full/dom-exceptioncore-js(-pure)/stable|actual|full/dom-exception/constructorcore-js/stable|actual|full/dom-exception/to-string-tag

const exception = new DOMException('error', 'DataCloneError');console.log(exception.name);                            // => 'DataCloneError'console.log(exception.message);                         // => 'error'console.log(exception.code);                            // => 25console.log(typeof exception.stack);                    // => 'string'console.log(exception instanceof DOMException);         // => trueconsole.log(exception instanceof Error);                // => trueconsole.log(exception.toString());                      // => 'DataCloneError: error'console.log(Object.prototype.toString.call(exception)); // => '[object DOMException]'

Iterable DOM collections⬆

class [  CSSRuleList,  CSSStyleDeclaration,  CSSValueList,  ClientRectList,  DOMRectList,  DOMStringList,  DataTransferItemList,  FileList,  HTMLAllCollection,  HTMLCollection,  HTMLFormElement,  HTMLSelectElement,  MediaList,  MimeTypeArray,  NamedNodeMap,  PaintRequestList,  Plugin,  PluginArray,  SVGLengthList,  SVGNumberList,  SVGPathSegList,  SVGPointList,  SVGStringList,  SVGTransformList,  SourceBufferList,  StyleSheetList,  TextTrackCueList,  TextTrackList,  TouchList,] {  @@iterator(): Iterator<value>;}class [DOMTokenList, NodeList] {  forEach(callbackfn: (value: any, index: number, target: any) => void, thisArg: any): void;  entries(): Iterator<[key, value]>;  keys(): Iterator<key>;  values(): Iterator<value>;  @@iterator(): Iterator<value>;}

core-js(-pure)/stable|actual|full/dom-collections/iteratorcore-js/stable|actual|full/dom-collections/for-each

for (let { id } of document.querySelectorAll('*')) {  if (id) console.log(id);}for (let [index, { id }] of document.querySelectorAll('*').entries()) {  if (id) console.log(index, id);}document.querySelectorAll('*').forEach(it => console.log(it.id));

Iteration helpers⬆

function isIterable(value: any): boolean;function getIterator(value: any): Object;function getIteratorMethod(value: any): Function | void;

core-js-pure/es|stable|actual|full/is-iterablecore-js-pure/es|stable|actual|full/get-iteratorcore-js-pure/es|stable|actual|full/get-iterator-method

import isIterable from 'core-js-pure/actual/is-iterable';import getIterator from 'core-js-pure/actual/get-iterator';import getIteratorMethod from 'core-js-pure/actual/get-iterator-method';let list = (function () {  // eslint-disable-next-line prefer-rest-params -- example  return arguments;})(1, 2, 3);console.log(isIterable(list)); // true;let iterator = getIterator(list);console.log(iterator.next().value); // 1console.log(iterator.next().value); // 2console.log(iterator.next().value); // 3console.log(iterator.next().value); // undefinedgetIterator({}); // TypeError: [object Object] is not iterable!let method = getIteratorMethod(list);console.log(typeof method);         // 'function'iterator = method.call(list);console.log(iterator.next().value); // 1console.log(iterator.next().value); // 2console.log(iterator.next().value); // 3console.log(iterator.next().value); // undefinedconsole.log(getIteratorMethod({})); // undefined

Missing polyfills⬆