zloirock/core-js

This system is the core-js polyfill library, which provides implementations for ECMAScript standards and web APIs to ensure compatibility across diverse JavaScript environments. It offers a modular architecture with granular entry points for stable features, experimental proposals, and pure/non-polluting usage, allowing developers to selectively include only the necessary polyfills. The system also includes tooling for generating custom bundles, analyzing engine compatibility, and maintaining strict adherence to evolving language specifications.

36 changes.

The project underwent a major restructuring for core-js v4, introducing a modular package system with granular entry points for stable ECMAScript features and TC39 proposals. This period focused on removing legacy polyfills, enhancing tree-shaking capabilities, and expanding engine compatibility support through updated tooling and comprehensive test suites.

67 changes.

The project expanded its API surface by introducing dedicated stable and full entry points for a comprehensive set of ECMAScript features, including modern Array, String, and Promise methods. This period also involved migrating build scripts and core compatibility data to ES modules while significantly broadening test coverage across Node, browser, and Deno environments.

14 changes.

This period focused on stabilizing ES Iterator methods and Explicit Resource Management APIs for production use, alongside comprehensive improvements to test coverage and code quality. Simultaneously, the project undertook a major website redesign, introducing a new theming system, interactive playground, and robust build infrastructure to support legacy browsers and versioned documentation.

This change introduces new methods to the DataView API under the /full/ namespace, specifically adding getFloat16, setFloat16, getUint8Clamped, and setUint8Clamped. These additions expose experimental ESNext features, allowing users to read and write 16-bit floating-point numbers and clamped unsigned 8-bit integers directly from DataViews, which is useful for handling binary data formats like FP16 or color values.

packages/core-js/full/data-view · high confidence

The \packages/core-js/es/number\ directory now provides entry points for the full set of ES2015 Number static methods and prototype methods. Users importing from this path gain access to polyfills for \Number.isFinite\, \Number.isInteger\, \Number.isNaN\, \Number.isSafeInteger\, \Number.parseFloat\, \Number.parseInt\, \Number.EPSILON\, \Number.MAX\_SAFE\_INTEGER\, \Number.MIN\_SAFE\_INTEGER\, and the constructor, as well as prototype methods \toExponential\, \toFixed\, and \toPrecision\. This change ensures that code relying on these ES2015 features works correctly in older environments when using the \/es/\ subset of the library.

packages/core-js/es/number · high confidence

This change introduces new entry points under \packages/core-js/es/regexp\ to support ES2018+ RegExp features. Users can now import specific capabilities such as the \dotAll\ flag (via \regexp/dot-all.js\), the \sticky\ flag (via \regexp/sticky.js\), and the static \RegExp.escape\ method (via \regexp/escape.js\). The \index.js\ entry point aggregates these along with other ES2018+ features like \test\ and \to-string\, ensuring that polyfills for \es.regexp.dot-all\, \es.regexp.sticky\, and \es.regexp.escape\ are included when using the \/es/\ path.

packages/core-js/es/regexp · high confidence

The \packages/core-js/full/number\ entry point now exposes the \Number.clamp\ and \Number.range\ methods (along with their virtual prototype counterparts) via the new \/full/\ namespace. Users importing from this path can now utilize these ES Next number utilities directly, in addition to the standard number static methods and properties already available.

packages/core-js/full/number · high confidence

The \packages/core-js/es/reflect\ directory now includes individual entry points for all Reflect methods (such as \apply\, \construct\, \defineProperty\, \deleteProperty\, \get\, \has\, \isExtensible\, \ownKeys\, \preventExtensions\, \set\, \setPrototypeOf\, and \to-string-tag\), allowing for more granular inclusion of features. Each entry point is implemented in strict mode and exports the corresponding method from the core modules. The main \index.js\ aggregates these requirements to export the full \Reflect\ object, and a new \to-string-tag.js\ entry point provides the \Reflect\[@@toStringTag\]\ property.

packages/core-js/es/reflect · high confidence

The \packages/core-js/es\ directory now provides dedicated entry points for stable ECMAScript features, allowing users to import only the specific standards they need. New modules include \globalThis\, \AggregateError\, \SuppressedError\, \escape\, \unescape\, \parseFloat\, \parseInt\, \getIterator\, and \getIteratorMethod\. These entry points bundle the necessary internal dependencies to ensure the features work correctly when imported individually.

packages/core-js/es · high confidence

New entry points are now available at packages/core-js/stable/dom-collections, including index.js, for-each.js, and iterator.js. These modules expose DOM collection iteration methods (keys, values, entries, iterator, forEach) and ensure strict mode is enabled, providing a stable API surface for accessing these utilities.

packages/core-js/stable/dom-collections · high confidence

This change introduces a new set of stable entry points under \packages/core-js/stable/number\ for various Number API methods, including \constructor\, \epsilon\, \isFinite\, \isInteger\, \isNaN\, \isSafeInteger\, \maxSafeInteger\, \minSafeInteger\, \parseFloat\, \parseInt\, \toExponential\, \toFixed\, and \toPrecision\, as well as their virtual counterparts. These new files act as wrappers that re-export the corresponding implementations from the \es/number\ module, ensuring strict mode is enabled and providing a stable interface for these standard Number features.

packages/core-js/stable/number · high confidence

This change introduces a comprehensive set of new entry points under \packages/core-js/stable/object/\ (including \assign\, \create\, \entries\, \freeze\, \hasOwn\, \keys\, \values\, and others). Each file acts as a stable wrapper that re-exports the corresponding implementation from the \es/object\ layer, ensuring that users can import these Object utilities via the stable path. Additionally, the \index.js\ and \from-entries\ entry points now explicitly require \web.dom-collections.iterator\ to ensure necessary polyfills are loaded.

packages/core-js/stable/object, packages/core-js/stable/string/virtual · high confidence

This change introduces new stable entry points for the \URL.canParse\ and \URL.parse\ methods, allowing users to import these specific functionalities directly via \core-js/stable/url/can-parse\ and \core-js/stable/url/parse\. It also adds a \to-json\ entry point and a consolidated \index\ entry for the URL module, ensuring these features are available in the stable API surface alongside existing URL capabilities.

packages/core-js/stable/url · high confidence

The \packages/core-js/stable\ directory now contains dedicated entry points for all stable core-js features, providing a recommended way to load only the required polyfills with their dependencies. This includes new modules for \AggregateError\, \atob\/\btoa\, \structuredClone\, \self\, and \globalThis\, as well as stable wrappers for existing features like \Date\, \Function\, and \Promise\ methods, allowing users to import specific stable implementations directly.

packages/core-js/stable · high confidence

This change adds a comprehensive set of new entry points under \packages/core-js/stable/instance\ for various Array and String prototype methods (such as \at\, \find\, \flat\, \matchAll\, \replaceAll\, \toReversed\, and \with\). These files act as stable wrappers that re-export the corresponding implementations from the \es/instance\ directory, ensuring that these methods are accessible via a stable path. Additionally, specific implementations for \entries\, \forEach\, \keys\, and \values\ are included to handle DOM collection iteration compatibility alongside standard array methods.

packages/core-js/stable/instance · high confidence

New SCSS files have been added to the website's styling system to define the visual appearance of key interface sections. This includes syntax highlighting themes for code blocks, layout and navigation styles for the header and footer, responsive behavior for the main content area and documentation menu, styling for the interactive playground editor and console, and visual rules for tooltips. These styles ensure consistent theming and responsive design across the website's core components.

website/src/scss/parts · high confidence

The library now exposes the AsyncDisposableStack feature through the full entry points at packages/core-js/full/async-disposable-stack. This allows users to import the implementation directly via the standard core-js full path, making the explicit resource management capability available for asynchronous disposal scenarios.

packages/core-js/full/async-disposable-stack · high confidence

Users can now import a bundled version of core-js (v3.50.0) for Deno via \deno.land/x/corejs\. This bundle includes polyfills for ECMAScript features up to 2021 (such as \Object.hasOwn\, \Array.prototype.at\, \Promise.any\, and iterator utilities) and is designed to be loaded at the top of the entry point to provide global namespace pollution-free access to these standards.

deno · high confidence

New entry-point files have been added to the \packages/core-js/es/date\ directory, providing direct access to specific Date methods including \getYear\, \now\, \setYear\, \toGMTString\, \toISOString\, \toJSON\, \toString\, and \toPrimitive\. These files enable more granular inclusion of Date features from the \/es/\ path, allowing users to import only the specific Date functionalities they need rather than loading the entire Date module.

packages/core-js/es/date · high confidence

New entry points are now available at \core-js/es/map/get-or-insert\, \core-js/es/map/get-or-insert-computed\, and their \WeakMap\ equivalents, allowing users to import these specific methods directly. The \core-js/es/map\ and \core-js/es/weak-map\ index files have been updated to include these methods, ensuring they are polyfilled when importing the full collection modules.

packages/core-js/es/map · high confidence

New entry points have been added under the \packages/core-js/stable/json\ path, providing stable access to JSON-related features such as \parse\, \stringify\, \is-raw-json\, \raw-json\, and \to-string-tag\. These modules re-export the corresponding implementations from the \es/json\ layer, ensuring consistent behavior for users relying on the stable API surface.

packages/core-js/stable/json · high confidence

New stable entry points have been added for Map and WeakMap methods, specifically \get-or-insert\, \get-or-insert-computed\, and \group-by\. These files act as wrappers that re-export the corresponding implementations from the \es\ directory, ensuring that these specific functionalities are accessible via the stable API path alongside the standard Map and WeakMap index files.

packages/core-js/stable/map · high confidence

This change introduces a new set of stable entry points under \packages/core-js/stable/reflect\ for the Reflect API. These files act as wrappers that re-export the corresponding implementations from the \es/reflect\ layer, ensuring consistent access to Reflect methods (such as \apply\, \construct\, \defineProperty\, \get\, \set\, etc.) via a stable path. Additionally, a specific entry point for \Reflect.toStringTag\ is provided, which explicitly exports the string 'Reflect'.

packages/core-js/stable/reflect · high confidence

New entry points are now available at packages/core-js/stable/url-search-params and packages/core-js/stable/weak-set. These files provide stable access to the respective Web API implementations (URLSearchParams and WeakSet) by re-exporting the parent modules and ensuring the required DOM collection iterators are loaded, allowing users to import these features via a dedicated stable path.

packages/core-js/stable/url-search-params, packages/core-js/stable/weak-set · high confidence

The website configuration now explicitly defines directory paths for documentation, blog, templates, and source files, alongside specific bundle names for standard and ES module builds. Additionally, version management is updated to include a new 'v4 (alpha)' entry alongside the existing 'v3' default, enabling the website to serve content from the v4 branch.

website/config · high confidence

The core-js library now provides dedicated entry points for individual Array methods under the /es/array/ path (e.g., /es/array/at.js, /es/array/flat.js, /es/array/find-last.js, /es/array/to-reversed.js). This allows users to import only the specific polyfills they need rather than loading the entire array module, supporting more granular inclusion of features. The update includes entry points for both stable ES methods and newer proposals like Array.prototype.at, Array.prototype.findLast, and Array.prototype.toReversed.

packages/core-js/es/array · high confidence

The \packages/core-js/es/array/virtual\ directory now exposes individual entry points for a comprehensive set of Array prototype methods, including \at\, \concat\, \copyWithin\, \entries\, \every\, \fill\, \filter\, \find\, \findIndex\, \findLast\, \findLastIndex\, \flat\, \flatMap\, \forEach\, \includes\, \indexOf\, \join\, \keys\, \lastIndexOf\, \map\, \push\, \reduce\, \reduceRight\, \reverse\, \slice\, \some\, \sort\, \splice\, \toReversed\, \toSorted\, \toSpliced\, \unshift\, \values\, and \with\. This change allows users to import specific virtual array methods individually rather than relying solely on the bulk \index.js\ export, enabling more granular tree-shaking and smaller bundle sizes for applications that only use a subset of these features.

packages/core-js/es/array/virtual · high confidence

A new \core-js-builder\ package is added, providing an API to generate custom polyfill bundles tailored to specific engine targets. Users can now selectively include or exclude modules, specify output formats (bundled, ESM, or CJS), and enable build summaries, allowing for optimized delivery of polyfills without shipping the entire library.

packages/core-js-builder · high confidence

The library introduces a new \/full/\ namespace (replacing \/features/\) that provides direct import paths for specific Map, WeakMap, and WeakSet methods. This location adds entry points for \Map\ methods such as \deleteAll\, \emplace\, \every\, \filter\, \find\, \findKey\, \from\, \getOrInsert\, \getOrInsertComputed\, \groupBy\, \includes\, \keyBy\, \keyOf\, \mapKeys\, \mapValues\, \merge\, \of\, \reduce\, \some\, \update\, \updateOrInsert\, and \upsert\. It also adds corresponding entry points for \WeakMap\ (\deleteAll\, \emplace\, \from\, \getOrInsert\, \getOrInsertComputed\, \of\, \upsert\) and \WeakSet\ (\addAll\, \deleteAll\, \from\, \of\). These files ensure that importing these specific methods also pulls in their required dependencies, enabling more granular tree-shaking for users who only need a subset of these collection utilities.

packages/core-js/full/map · high confidence

The \core-js\ library now exposes individual entry points under the \/full/iterator/\ namespace for various Iterator prototype methods and static utilities. Users can now import specific helpers such as \chunks\, \concat\, \drop\, \filter\, \find\, \flatMap\, \forEach\, \from\, \includes\, \indexed\ (renamed from \asIndexedPairs\), \join\, \map\, \range\, \reduce\, \sliding\, \some\, \take\, \toArray\, \toAsync\, \windows\, \zip\, and \zipKeyed\ directly. This change provides a more granular import structure for accessing the full set of Iterator helpers, with some entries like \indexed\ and \asIndexedPairs\ marked for removal in core-js@4 to reflect the final proposal naming.

packages/core-js/full/iterator · high confidence

The library introduces a new \/full/\ namespace structure, replacing the previous \/features/\ path, to provide full polyfills for Math methods. This update adds several new experimental and standard Math functions, including \clamp\, \f16round\, \deg-per-rad\, \degrees\, \fscale\, \iaddh\, \isubh\, \imulh\, \rad-per-deg\, \radians\, \scale\, \seeded-prng\, \signbit\, \sumPrecise\, and \umulh\. Additionally, strict mode has been enabled in these modules to ensure consistent execution behavior.

packages/core-js/full/math · high confidence

The /full/set entry point now exposes a comprehensive suite of Set methods, including addAll, deleteAll, difference, every, filter, find, intersection, isDisjointFrom, isSubsetOf, isSupersetOf, join, map, reduce, some, symmetricDifference, and union, as well as the static constructors Set.from and Set.of. These additions allow users to perform bulk operations, set algebra, and functional transformations directly on Set instances without needing to import individual feature modules.

packages/core-js/full/set · high confidence

The core-js library now exposes \URL.canParse\ and \URL.parse\ methods, along with \URL.prototype.toJSON\, accessible through the new \/full/url/\ import paths. These additions provide standardized ways to validate and parse URLs without instantiating a full URL object, enhancing URL handling capabilities for users relying on this polyfill layer.

packages/core-js/full/url · high confidence

The \packages/core-js/actual\ directory now provides a new set of entry points that combine stable ECMAScript features with Stage 3 proposals (such as \Array.group\, \Array.fromAsync\, \Error.isError\, and \ArrayBuffer.transfer\). These files allow users to import only the specific features they need, automatically pulling in the necessary polyfills from the \esnext\ modules while reusing the stable implementations where available.

packages/core-js/actual · high confidence

A new \scripts/check-dependencies\ module has been introduced to centralize and parallelize the process of detecting outdated dependencies across the project. This script scans \package.json\ files in the root, website, packages, scripts, and tests directories, applying specific exclusion and version-bump rules (minor/patch) defined in a local configuration file. It leverages the \updates\ CLI tool to identify obsolete packages and can optionally update versions in place when the \UDEPS\ environment variable is set, providing a more robust and configurable way to manage dependency hygiene compared to previous ad-hoc approaches.

scripts/check-dependencies · high confidence

The \core-js/stage\ directory now provides dedicated entry points (\stage/0\, \stage/1\, \stage/2\, \stage/2.7\, \stage/3\, \stage/4\, and \pre\) that bundle polyfills for ECMAScript proposals according to their TC39 standardization stage. Users can import these specific paths to include only the proposal features relevant to their target environment, rather than loading the entire proposals bundle.

packages/core-js/stage · high confidence

This update adds a comprehensive set of new instance method entries under the \core-js/full/instance\ path, including \at\, \clamp\, \demethodize\, \filter-out\, \filter-reject\, \group-by\, \group-by-to-map\, \group-to-map\, \is-well-formed\, \match-all\, \replace-all\, \to-reversed\, \to-sorted\, \to-spliced\, \to-well-formed\, \unique-by\, and \un-this\. These entries expose polyfills for modern ECMAScript proposals (such as Array methods, Well-Formed Unicode Strings, and Function.prototype methods) and the new \/full/\ namespace, allowing users to import these specific instance capabilities directly.

packages/core-js/full/instance · high confidence

A new \scripts/bundle-package/bundle-package.mjs\ script has been added to handle the creation of \core-js\ bundles. This tool supports generating bundles for both Deno (targeting version 1.0) and standard environments (including ES Modules). It utilizes \core-js-builder\ to assemble the source and \terser\ to produce minified outputs with source maps, applying specific compression settings and excluding obsolete or withdrawn \esnext\ features to ensure compatibility and stability.

scripts/bundle-package · high confidence

This change introduces a new \packages/core-js/web\ directory that aggregates entry points for various web-standard APIs. Users can now import consolidated modules for \DOMException\, \URL\ (including \URL.canParse\ and \URL.parse\), \URLSearchParams\ (with \size\, \has\, and \delete\ methods), \structuredClone\, \queueMicrotask\, \atob\/\btoa\, and DOM collection iterators. These entry points bundle the necessary underlying polyfills and dependencies, simplifying the inclusion of these specific web features.

packages/core-js/web · high confidence

The website now includes a new table-of-contents menu that highlights the current section and smooth-scrolls to anchors, a 'Run' button on JavaScript code blocks that links to the playground with the code pre-filled, and a fully functional playground page that compiles and executes code using Babel, displaying results in a console with improved serialization for complex objects like Sets, Maps, and Promises.

website/src/js · high confidence

Users can now import \DataView.prototype.getFloat16\ and \DataView.prototype.setFloat16\ directly from the \/es/data-view/\ entry points. These methods, previously experimental, are now included in the stable ES module exports, allowing for granular inclusion of these specific features alongside other standard DataView operations.

packages/core-js/es/data-view · high confidence

This change exposes a comprehensive set of Iterator prototype methods as stable ES features, making them directly importable from the \core-js/es/iterator\ path. Users can now import specific utilities such as \chunks\, \concat\, \dispose\, \drop\, \every\, \filter\, \find\, \flatMap\, \forEach\, \from\, \includes\, \join\, \map\, \reduce\, \some\, \take\, \toArray\, \windows\, \zip\, and \zipKeyed\ individually. The \index.js\ entry point aggregates all these methods, ensuring that importing the full iterator module includes these newly stabilized capabilities alongside existing ones like \constructor\.

packages/core-js/es/iterator · high confidence

The \packages/core-js/es/instance\ directory now includes dedicated entry points for a comprehensive set of Array and String instance methods (such as \at\, \find\, \flat\, \matchAll\, \replaceAll\, \toReversed\, and \trim\). These new files provide stable, standardized access to these methods, ensuring that polyfills are applied correctly when the native implementation is missing or when strict prototype checking is required.

packages/core-js/es/instance · high confidence

This change exposes a suite of Iterator utility methods under the stable \core-js/stable/iterator\ path, allowing users to import them with guaranteed stability. The newly added entry points include \chunks\, \concat\, \dispose\, \drop\, \every\, \filter\, \find\, \flat-map\, \for-each\, \from\, \includes\, \join\, \map\, \reduce\, \some\, \take\, \to-array\, \windows\, \zip\, and \zip-keyed\. These modules act as stable wrappers that re-export the underlying implementations from the \es/iterator\ namespace, with specific helpers like \concat\, \flat-map\, \from\, \index\, \zip\, and \zip-keyed\ also pulling in the \web.dom-collections.iterator\ module to ensure compatibility with DOM collections.

packages/core-js/stable/iterator · high confidence

Users can now import Promise.allSettled, Promise.any, Promise.withResolvers, and Promise.try directly from the stable entry points (e.g., core-js/stable/promise/all-settled). These new modules re-export the corresponding implementations from the ES layer, ensuring that these features are available via the stable API path alongside existing stable Promise methods like finally.

packages/core-js/stable/promise · high confidence

New stable entry points have been added under \packages/core-js/stable/symbol\ for various Symbol properties, including \async-dispose\, \async-iterator\, \description\, \dispose\, \match-all\, and others. These files re-export the corresponding implementations from the \es\ namespace, allowing users to import these specific Symbol features via a stable path. The \index.js\ entry point also ensures that \web.dom-collections.iterator\ is loaded when importing the full symbol module.

packages/core-js/stable/symbol · high confidence

New stable entry points have been added for ArrayBuffer-related features, including the constructor, detached status, is-view checks, slice, and transfer methods (both general and fixed-length variants). These new files in the stable directory act as wrappers that re-export the corresponding implementations from the ES directory, ensuring consistent access to these capabilities through the stable API path.

packages/core-js/stable/array-buffer · high confidence

Added stable ES entry points for \Math.sumPrecise\, \Math.f16round\, and \DataView.prototype.{getFloat16, setFloat16}\, alongside other standard Math methods (such as \acosh\, \asinh\, \atanh\, \cbrt\, \clz32\, \cosh\, \expm1\, \fround\, \hypot\, \imul\, \log10\, \log1p\, \log2\, \sign\, \sinh\, \tanh\, \to-string-tag\, and \trunc\). These new files in \packages/core-js/stable/math\ and \packages/core-js/stable/data-view\ re-export the corresponding implementations from the \es\ namespace, allowing users to import these features via the stable path.

packages/core-js/stable/math · high confidence

Added stable \/stable/regexp/\ entry points that re-export existing ES-level implementations (including \RegExp.escape\, \dotAll\, \flags\, \match\, \replace\, \search\, \split\, \sticky\, \test\, \toString\, and the constructor). This allows users to import these RegExp utilities via stable paths, ensuring consistent behavior across environments.

packages/core-js/stable/regexp · high confidence

New stable entry points have been added for Set methods including difference, intersection, is-disjoint-from, is-subset-of, is-superset-of, symmetric-difference, and union. These allow users to import these specific Set operations directly from the stable path, ensuring consistent availability across environments.

packages/core-js/stable/set · high confidence

This change adds a comprehensive set of new entry points under the \packages/core-js/stable/string/\ directory, providing stable, standardized access to various String prototype methods and static functions. The diff introduces individual modules for methods such as \anchor\, \at\, \big\, \blink\, \bold\, \code-point-at\, \ends-with\, \fixed\, \fontcolor\, \fontsize\, \from-code-point\, \includes\, \is-well-formed\, \italics\, \iterator\, \link\, \match-all\, \match\, \pad-end\, \pad-start\, \raw\, \repeat\, \replace-all\, \replace\, \search\, \small\, \split\, \starts-with\, \strike\, \sub\, \substr\, \sup\, \to-well-formed\, \trim\, \trim-end\, \trim-left\, \trim-right\, and \trim-start\, along with a main \index.js\ that re-exports the entire stable string namespace. Each module strictly enforces strict mode and delegates to the corresponding implementation in the \es/string/\ path, ensuring that users can import specific string utilities from a stable location that aligns with finalized ECMAScript standards.

packages/core-js/stable/array, packages/core-js/stable/string · high confidence

This change adds a comprehensive set of \/stable/typed-array/\ entry points that expose core JavaScript Typed Array features, including \.at()\, \findLast\, \toReversed\, \toSorted\, \with\, \copyWithin\, and binary conversion methods like \toBase64\/\fromBase64\. These new modules provide stable, strict-mode wrappers that re-export the underlying ES implementations, ensuring consistent availability and behavior for these standard features across the library.

packages/core-js/stable/typed-array · high confidence

The \core-js-compat\ package has been updated to version 3.50.0, introducing a dedicated \compat\ entry point that accepts a \targets\ object (in addition to browserslist queries) to list required modules for specific environment versions. This release adds comprehensive TypeScript declarations for the new API and internal helpers, and expands engine support to include Bun, Deno, Electron, Hermes, PhantomJS, React Native, Rhino, and various mobile browsers (Chrome/Firefox/Opera for Android). It also introduces an \inverse\ option to identify modules NOT required for a target, an \esmodules\ option (including an 'intersect' mode), and a new \getModulesListForTargetVersion\ helper to retrieve the module list available in a specific \core-js\ version.

packages/core-js-compat · high confidence

The library has removed its internal ES5 and ES6 shims (including implementations for Map, Set, Object.create, Array.from, and various prototype extensions) along with custom utility methods for Array, Date, Function, Number, and String. This change indicates a shift away from supporting older environments like IE8 or relying on custom polyfilled behavior, likely assuming a modern runtime or external polyfilling strategy.

src · high confidence

A change to existing behaviour in (repo-wide) — 2427 commits (436 fixs), 13 files.

(repo-wide) · low confidence · unverified

The library now exposes a \/full/\ namespace (replacing the previous \/features/\ path) that provides explicit entry points for individual modules. This change adds new files under \packages/core-js/full/\ for various APIs—including BigInt, Date, DOM collections, Observable, and Reflect metadata—ensuring they are loaded in strict mode and correctly re-exporting the underlying implementations from the \actual\ and \internals\ directories.

(repo-wide) · high confidence

The library introduces a new \/full/\ namespace structure, replacing the previous \/features/\ path, to provide standardized entry points for ArrayBuffer functionality. This change adds specific modules for the constructor, detached status, is-view checks, slice operations, and the new Stage 3 proposal methods \transfer\ and \transferToFixedLength\, ensuring these features are accessible via the updated import paths.

packages/core-js/full/array-buffer · high confidence

The /full/ namespace is now available as the replacement for the previous /features/ path, providing full-featured entry points for Error-related functionality. This includes new exports for Error.isError, Error constructor, and Error.prototype.toString, allowing users to import these specific error utilities via the /full/ path.

packages/core-js/full/error · high confidence

The /full/ namespace is introduced as the new entry point for RegExp-related features, replacing the previous /features/ path. This change adds a set of new modules under packages/core-js/full/regexp (including constructor, dot-all, escape, flags, index, match, replace, search, split, sticky, and to-string) that re-export the corresponding implementations from the /actual/ directory, ensuring strict mode is enabled for these exports.

packages/core-js/full/regexp · high confidence

A new script at scripts/check-actions/check-actions.mjs has been added to verify actions dependencies. When executed, it runs 'actions-up' in dry-run mode with a minimum age of 0 and confirms the check by printing a success message, ensuring that dependency states are validated before proceeding.

scripts/check-actions · high confidence

New dedicated entry points are now available under the \/es/json/\ path (e.g., \stringify\, \parse\, \isRawJSON\, \rawJSON\, \toStringTag\). These modules provide stable, explicit access to JSON functionality, ensuring that \stringify\ correctly handles \Date\#toJSON\ and other edge cases by relying on the underlying \es.json.stringify\ and \es.date.to-json\ implementations rather than falling back to the native global.

packages/core-js/es/json · high confidence

The \core-js\ library now exposes async iterator helper methods (such as \map\, \filter\, \reduce\, \take\, \drop\, \every\, \some\, \find\, \flatMap\, \forEach\, \from\, \toArray\, and \indexed\) via the new \/full/async-iterator/\ entry points. This change introduces the \/full/\ namespace as the replacement for the older \/features/\ path, ensuring that these utilities are included in the full build. Notably, the \asIndexedPairs\ method is now available alongside the renamed \indexed\ method, with both exposed in the main \index.js\ entry for backward compatibility.

packages/core-js/full/async-iterator · high confidence

The project's build and maintenance scripts (including \build-indexes\, \clean-and-copy\, \update-version\, \check-compat-data-mapping\, \downloads-by-versions\, \check-unused-modules\, and \prepare\) have been rewritten from CommonJS to ES modules and now use the \zx\ library for shell execution. This change introduces a new \zxi\ helper that manages local dependency installation and execution context for these scripts. Users will experience updated build behaviors, such as the \build-indexes\ script generating new \index.js\ files for \es\, \stable\, and \full\ namespaces, and the \clean-and-copy\ script creating \/features/\ entries as replacements for \/full/\. The \update-version\ script now automatically includes the number of commits in the changelog entry, and the \check-compat-data-mapping\ script validates browser compatibility data against live MDN sources.

scripts · high confidence

The internal helper modules in core-js-pure have been refactored to improve tree-shaking and validation. New dedicated validation functions (a-map, a-set, a-weak-map, a-weak-set) now explicitly check for required properties before treating an object as a collection instance. Collection helpers (map-helpers, set-helpers, etc.) are simplified to use caller wrappers. The export logic (export.js) is enhanced with options like 'bind', 'wrap', and 'sham' to better control how polyfills are attached to prototypes and global objects, ensuring stricter validation and preventing internal state exposure in the pure version.

packages/core-js-pure/override/internals · high confidence

The /full/ directory now serves as the primary entry point for loading core-js features with their dependencies, replacing the previous /features/ namespace. This change provides a cleaner, recommended way for users to import only the specific polyfills they need, with each module in this directory delegating to the corresponding implementation in the /actual/ folder while ensuring strict mode is enforced.

packages/core-js/full · high confidence

The \packages/core-js/full/object\ location now serves as the primary entry point for Object-related polyfills, replacing the older \/features/\ path. All individual method entry points (such as \assign\, \create\, \keys\, \values\, \entries\, \freeze\, \seal\, \is\, \hasOwn\, and prototype accessors) have been added to this namespace and are now executed in strict mode. This update also introduces support for Stage 3 \Object.groupBy\ and adds \Object.prototype.\_\proto\\_\ polyfilling. Additionally, several ESNext iteration methods (\iterateEntries\, \iterateKeys\, \iterateValues\) and \hasOwn\ are included, with \hasOwn\ explicitly marked for removal in core-js v4.

packages/core-js/full/object · high confidence

The \packages/core-js/full/typed-array\ directory now provides the primary entry points for Typed Array features, replacing the previous \/features/\ namespace. This change establishes a new \/full/\ structure where each method (such as \at\, \filter-out\, \from-base64\, and \unique-by\) is exposed via its own module that re-exports the implementation from the \actual\ layer. The entry points also handle necessary polyfill dependencies, such as requiring \es.map\ and \es.promise\ for methods like \group-by\ and \from-async\, and mark certain experimental proposals (like \at\ and \filter-out\) with a deprecation note for removal in core-js v4.

packages/core-js/full/typed-array · high confidence

The \packages/core-js/internals\ directory now contains a collection of internal helper modules that enforce type constraints and manage internal state for polyfills. This includes type-checking assertions (such as \a-callable\, \a-constructor\, \a-data-view\, \a-map\, \a-set\, \a-weak-map\, and \a-weak-set\) that throw \TypeError\ when arguments do not match expected types or internal slots, and resource management helpers (like \add-disposable-resource\) that support the explicit resource management proposal. These modules provide the foundational logic for ensuring correct invocation contexts and handling disposable resources within the core-js polyfill ecosystem.

packages/core-js/internals · high confidence

The library introduces a new \/full/\ namespace for JSON functionality, replacing the previous \/features/\ path. This update exposes \JSON.rawJSON\ and \JSON.isRawJSON\ for handling raw JSON data, adds a \source\ property to \JSON.parse\ results, and patches \JSON.stringify\ behavior, all now accessible via the standardized full JSON entry points.

packages/core-js/full/json · high confidence

The /full/ namespace now provides dedicated entry points for function-related features, including bind, has-instance, metadata, name, is-callable, and is-constructor. A new demethodize method is exposed via Function.prototype.demethodize (replacing the previous unThis proposal), while the legacy unThis method remains available but is marked for removal in core-js@4. All new entry points operate in strict mode.

packages/core-js/full/function · high confidence

The \packages/core-js/full/array\ directory now exposes individual entry points for a comprehensive set of Array methods, including standard ones (e.g., \concat\, \filter\, \map\, \reduce\) and newer proposals (e.g., \at\, \find-last\, \flat\, \group\, \to-reversed\, \unique-by\). This change introduces the \/full/\ namespace as the replacement for the previous \/features/\ path, allowing users to import specific array functionalities directly. It also includes polyfills for experimental methods like \filterOut\, \filterReject\, and \isTemplateObject\, with some marked for removal in core-js@4.

packages/core-js/full/array · high confidence

The library introduces a new \/full/symbol/\ namespace that provides direct entry points for individual Symbol features, replacing the older \/features/\ path. This update includes new exports for async resource management (\async-dispose\, \async-iterator\) and updates several Symbol predicates to align with the latest proposals: \Symbol.matcher\ is replaced by \Symbol.customMatcher\, and \Symbol.metadata\ is replaced by \Symbol.metadataKey\. Additionally, legacy predicates like \isRegistered\, \isWellKnown\, and \matcher\ are marked for removal in core-js v4, while new stage 3 features like \Symbol.patternMatch\ and \Symbol.replaceAll\ are now available.

packages/core-js/full/symbol · high confidence

A new \scripts/bundle-tests\ directory has been introduced, containing a Node.js script and a Webpack configuration to automate the bundling of unit tests (\unit-global\ and \unit-pure\) and the copying of QUnit and core-js assets into the \tests/bundles\ directory. This change centralizes the build process for test dependencies, ensuring that QUnit helpers and core-js are consistently available in the test bundles without requiring manual bundling steps.

scripts/bundle-tests · high confidence

The website now uses a new HTML structure and SCSS-based theme system that supports dark and light modes, with a theme switcher in the navigation bar and automatic detection of the user's system preference.

website/src · high confidence

The website now uses a new SCSS architecture in the includes directory, introducing a theming system that supports both dark and light color palettes. This change adds base styles for typography, layout, and components (forms, buttons, tables), along with specific styling for markdown alerts and responsive breakpoints, allowing the site to adapt its appearance based on the selected theme.

website/src/scss/includes · high confidence

This change introduces override modules for core-js-pure to ensure correct behavior in environments where native implementations may be non-compliant or missing. Specifically, it adds a polyfill for \Date.prototype.toJSON\ to handle NaN and non-standard objects correctly, implements the \self\ global property for web environments, and sets the \@@toStringTag\ on DOM collections to ensure proper identification. Additionally, it registers the \Symbol.dispose\ and \Symbol.asyncDispose\ well-known symbols to support the Explicit Resource Management proposal, and configures the \RegExp\ species constructor.

packages/core-js-pure/override/modules · high confidence

This change introduces new \full/promise\ entry points for \all-keyed\, \all-settled-keyed\, \try\, and \with-resolvers\, while updating existing entries like \all-settled\, \any\, and the main \index\ to explicitly require \esnext.aggregate-error\ and \esnext.promise.\*\ modules. These additions are marked with a TODO to remove them in core-js@4, indicating a shift in how these Promise-related features are bundled or deprecated in the upcoming major version.

packages/core-js/full/promise · high confidence

The core-js \/es/promise\ entry points now include stable implementations for \Promise.allSettled\, \Promise.any\, \Promise.try\, and \Promise.withResolvers\. Users importing from these specific paths (e.g., \core-js/es/promise/all-settled\) will now get the standard ES-compliant versions of these methods, ensuring consistent behavior aligned with the latest ECMAScript specifications rather than experimental or polyfill-only variants.

packages/core-js/es/promise · high confidence

The compatibility data generation script has been restructured and now automatically maps feature support for additional browser environments. Specifically, the build process now generates data for Chrome Android, Opera Android, Oculus Quest (formerly Oculus), React Native, and iOS, deriving these from existing Chrome, Safari, and Firefox data. This ensures that consumers of the compatibility data receive accurate version information for these platforms without manual intervention.

scripts/build-compat · high confidence

The website build process has been refactored to improve reliability and maintainability. The new runner script (runner.sh) now properly manages build lifecycle by killing any previous in-progress builds and cleaning up lock/pid files on exit, ensuring that failed builds do not leave stale state. The underlying Node.js runner (runner.mjs) and its helper module (helpers.mjs) have been restructured to centralize logic for cloning repositories, checking out specific versions, copying documentation and blog posts, and building core-js bundles. This change also introduces better error propagation, where build failures now trigger cleanup routines and result in a failed job status, rather than leaving partial or corrupted build artifacts.

website/scripts · high confidence

The \packages/core-js/modules\ directory has been reorganized to improve maintainability and tree-shaking. A new \README.md\ has been added to clarify that this folder contains polyfill implementations and is not intended for direct inclusion in projects. Additionally, the \es.array.for-each\ and \es.array.is-array\ modules have been updated to use internal helpers (\array-for-each\ and \is-array\) for their implementations, and \es.array.concat\ has been refactored to support \@@species\ and \@@isConcatSpreadable\.

packages/core-js/modules · high confidence

The /es/array-buffer entry points now include ArrayBuffer.prototype.transfer and ArrayBuffer.prototype.transferToFixedLength, moving these capabilities from proposal status to the stable ES path. Users importing from packages/core-js/es/array-buffer will now have access to these methods alongside existing features like slice, detached, and is-view, ensuring consistent availability in environments supporting the stable specification.

packages/core-js/es/array-buffer · high confidence

The Error.isError utility has been moved from the ES stage to the stable API, making it reliably available in stable imports. Additionally, polyfills for Error.prototype.toString and Error.cause are now included in the error module entry points, ensuring consistent error stringification and cause handling across environments.

packages/core-js/es/error, packages/core-js/stable/error · high confidence

The \packages/core-js/es/math\ entry point now exposes a broader set of \Math\ methods as stable ES features, including \acosh\, \asinh\, \atanh\, \cbrt\, \clz32\, \cosh\, \expm1\, \f16round\, \fround\, \hypot\, \imul\, \log10\, \log1p\, \log2\, \sign\, \sinh\, \sumPrecise\, \tanh\, and \trunc\. This change allows users importing from the \/es/\ path to access these utilities directly, reflecting their promotion to stable ECMAScript standards.

packages/core-js/es/math · high confidence

The /es/symbol path now exposes several previously experimental or internal Symbol features as stable ES entry points, including Symbol.asyncDispose, Symbol.asyncIterator, Symbol.description, Symbol.dispose, and Symbol.matchAll. This change updates the core-js /es/symbol index to include the corresponding module requirements and provides dedicated entry files for these symbols, allowing users to import them directly from the stable /es/ path alongside existing well-known symbols like Symbol.iterator and Symbol.hasInstance.

packages/core-js/es/symbol · high confidence

The \packages/core-js/es/typed-array\ entry points now expose a comprehensive set of Typed Array methods as stable ES features, including \.at()\, \.find()\, \.findLast()\, \.toReversed()\, \.toSorted()\, and \.with()\. Additionally, \Uint8Array\ binary conversion utilities (\.fromBase64()\, \.toBase64()\, \.fromHex()\, \.toHex()\, \.setFromBase64()\, and \.setFromHex()\) are now available in the stable \/es/\ path. Users importing from this location will now have access to these previously proposal-stage or unstable features, ensuring consistent behavior across environments that support the stable ECMAScript specification.

packages/core-js/es/typed-array · high confidence

The stable entry points for DOMException are now fully defined with explicit dependency requirements. The constructor and index modules now explicitly require the underlying implementation modules (constructor, stack, and toStringTag) and the ES error-to-string polyfill, ensuring that the DOMException object is correctly constructed and stringified in environments where these dependencies were previously missing or implicit. A dedicated to-string-tag module is also provided to expose the 'DOMException' string constant, improving compatibility for code relying on the @@toStringTag property.

packages/core-js/stable/dom-exception · high confidence

The \packages/core-js/es/string\ directory now provides stable, ES-standard entry points for string methods that have reached Stage 4 or the ES specification, including \at\, \matchAll\, \replaceAll\, \isWellFormed\, and \toWellFormed\, alongside legacy HTML wrapper methods like \anchor\, \big\, and \blink\. This change allows users to import these specific features directly from the \/es/\ path with guaranteed stability, while also introducing strict mode and granular inclusion for better compatibility and smaller bundle sizes.

packages/core-js/es/string · high confidence

The \packages/core-js/es/object\ entry point now exposes a comprehensive set of Object utilities as stable ES features, including \Object.fromEntries\, \Object.hasOwn\, and \Object.groupBy\, alongside standard methods like \assign\, \create\, \entries\, \freeze\, \keys\, \values\, and property descriptor tools. Additionally, the package now includes polyfills for legacy and non-standard Object properties, specifically \\_\proto\\\, \\\defineGetter\\\, \\\defineSetter\\\, \\\lookupGetter\\\, and \\\lookupSetter\\_\, ensuring broader compatibility for code relying on these legacy APIs.

packages/core-js/es/object · high confidence

The \packages/core-js/es/string/virtual\ entry points now expose the full set of String prototype methods as stable ES features, including \at\, \matchAll\, \replaceAll\, \isWellFormed\, \toWellFormed\, and the legacy HTML wrapper methods (e.g., \anchor\, \bold\, \italics\). This change aligns the virtual String API with the latest ECMAScript specifications, ensuring that these methods are available for direct use on string instances via the standard ES import path.

packages/core-js/es/string/virtual · high confidence

The \packages/core-js/es/set\ path now exposes stable entry points for the new Set methods (\difference\, \intersection\, \isDisjointFrom\, \isSubsetOf\, \isSupersetOf\, \symmetricDifference\, and \union\). Users can import these specific methods directly from the \/es/set/\ directory (e.g., \core-js/es/set/difference\) or use the full set index, ensuring these features are treated as part of the stable ES standard rather than experimental additions.

packages/core-js/es/set · high confidence

The Explicit Resource Management proposal is now stable in core-js, making AsyncDisposableStack, DisposableStack, and the async-dispose iterator method available via the stable entry points (e.g., core-js/stable/...). This change ensures these APIs are included in stable builds and no longer require experimental flags, allowing developers to use them in production without relying on the es/ path.

(repo-wide) · high confidence

The \packages/core-js/full/string\ directory now provides entry points for all standard and experimental string methods (including \at\, \codePoints\, \dedent\, \isWellFormed\, \matchAll\, \replaceAll\, and \toWellFormed\) under the new \/full/\ namespace. This change introduces the \/full/\ path as the replacement for the legacy \/features/\ namespace, ensuring that both static and prototype-based string methods are correctly re-exported with strict mode enabled. Users importing from this location will now access the full suite of string polyfills, including those marked for removal in core-js v4.

packages/core-js/full/array/virtual, packages/core-js/full/string · high confidence

The proposal entry points in \packages/core-js/proposals\ have been updated to align with the latest TC39 proposal stages and specifications. This includes moving \Object.fromEntries\, \Promise.allSettled\, \String.prototype.matchAll\, \Symbol.prototype.description\, and \Array.prototype.at\ to their stable ES entry points, while adding new entry points for proposals such as \Error.cause\, \Promise.withResolvers\, \Array.groupBy\, \Map.emplace\ (upsert), and \URL.canParse\. Several methods have been renamed to match spec drafts, including \filterOut\ to \filterReject\, \upsert\ to \emplace\, and \asIndexedPairs\ to \indexed\. Additionally, obsolete modules are marked for removal in core-js@4, and new proposals like \String.dedent\, \Math.clamp\, and \Iterator\ helpers are now available.

packages/core-js/proposals · high confidence

The usage script has been rewritten to use Playwright with the stealth plugin instead of Puppeteer, and it now fetches the top-1m Alexa dataset from a new URL (es6.zloirock.ru) because the original S3 source is deprecated. The script parses the CSV to detect core-js usage on websites, running checks in parallel with timeouts to handle slow or hanging sites, and reports the percentage of sites using core-js along with any access issues.

scripts/usage · high confidence

The core-js library has been restructured into a modular package system, moving source code into related sub-packages and renaming the legacy \/fn/\ directory to \/features/\. This release adds support for configurable polyfill aggressiveness via a new \configurator.js\, allowing users to explicitly force native implementations, polyfills, or feature detection for specific features. The package now includes a \postinstall.js\ script that displays a sponsorship banner (unless disabled by environment variables like \ADBLOCK\ or \CI\), and the main entry point (\index.js\) now exports the full library. The README has been updated to reflect the new modular import paths (e.g., \core-js/actual\) and includes examples for both global and pure (non-polluting) usage.

packages/core-js · high confidence

The core-js-compat package has been refactored to use ES modules (ESM) instead of CommonJS. The internal data structure has been reorganized into dedicated files: \data.mjs\ now holds the browser compatibility version mappings, \mapping.mjs\ contains the engine version translation tables (e.g., Chrome to Node/Deno/Electron), \external.mjs\ defines the minimum supported engine versions, and \modules-by-versions.mjs\ lists the modules included in each core-js release version. This change improves module loading and aligns with modern JavaScript standards.

packages/core-js-compat/src · high confidence

A new \build-local.mjs\ script has been added to streamline local website builds, orchestrating steps like copying core-js, blog posts, and common files before invoking the main build. The Vite configuration (\vite.config.mjs\) has been updated to explicitly set legacy plugin targets (IE 11, Chrome\>=38, Safari\>=7.1, FF\>=15) and CSS targets (ie11), ensuring the generated website assets are compatible with older browsers.

website · high confidence

Add Bun-based unit test runner; Add comprehensive unit tests for global ES polyfills; Added CI checks for compatibility test coverage and module version alignment; Added Karma-based unit test runner for browser bundles; Added TypeScript type definition tests for core-js modules; Added Web Platform Tests for URL parsing, setters, and ASCII conversion; Added automated publint validation for packages; Added browser-based unit test runners for core-js and core-js-pure; Added codespell test runner for spelling verification; Added entry point content and unit tests for core-js; Added quiet reporter and runner for Node unit tests; Added test helper utilities for QUnit assertions and environment detection; Added test infrastructure for observables in both global and pure modes; Added test infrastructure for validating Promise implementations in global and pure modes; Added test262 compliance test runner and preprocessor; Added tests for compat-tools utilities; Added tests for the core-js builder module; Added unit tests for core-js-pure ES array and error methods; Centralized ESLint configuration and runner; Initial compatibility test suite and runners; Removed test bootstrap.css.

The core-js library packages (core-js, core-js-pure, core-js-compat, and core-js-builder) have been updated to version 3.50.0. Development dependencies and build scripts have also been refreshed: ESLint is upgraded to version 10 in the tests/eslint workspace with corresponding plugin updates, webpack is updated to version 5 in the bundle-tests script, and the playwright testing infrastructure is updated to version 1.63.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 58 (+8.2)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 54 → 54 (+0.0)
• Architecture 95 → 95 (+0.1)
• Maturity 42 → 63 (+21.0)
• Readiness 53 → 53 (+0.8)
• Security 57 → 63 (+6.1)
• Accessibility 74 (new)
• Performance 100 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no architecture or design documentation (docs/web/docs/usage.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (docs/web/index.md)
• Documentation: written for insiders (docs/web/docs/missing-polyfills.md)
• Hotspot: packages/core-js/modules/web.url.constructor.js (packages/core-js/modules/web.url.constructor.js)

• High CVE: [GHSA redacted] (scripts/usage/package-lock.json)
• Outdated (npm): mkdirp
• Outdated (npm): vite
• Outdated (npm): webpack
• Split packages/core-js
• array-buffer-transfer.default (cognitive 17) (packages/core-js/internals/array-buffer-transfer.js)
• check-dependencies.checkPackage (cognitive 20) (scripts/check-dependencies/check-dependencies.mjs)
• collection.default (cognitive 32) (packages/core-js-pure/override/internals/collection.js)
• collection.default (cognitive 68) (packages/core-js/internals/collection.js)
• collection.default (cyclomatic 22) (packages/core-js-pure/override/internals/collection.js)
• collection.default (cyclomatic 36) (packages/core-js/internals/collection.js)
• define-built-in.default (cognitive 16) (packages/core-js/internals/define-built-in.js)
• export.default (cognitive 26) (packages/core-js/internals/export.js)
• export.default (cognitive 42) (packages/core-js-pure/override/internals/export.js)
• export.default (cyclomatic 17) (packages/core-js/internals/export.js)
• export.default (cyclomatic 36) (packages/core-js-pure/override/internals/export.js)
• get-substitution.default (cognitive 17) (packages/core-js/internals/get-substitution.js)
• iterate.default (cognitive 35) (packages/core-js/internals/iterate.js)
• iterate.default (cyclomatic 24) (packages/core-js/internals/iterate.js)
• iterator-define.default (cognitive 49) (packages/core-js/internals/iterator-define.js)
• …and 10 more

• 11 commits — 10 feature/other, 1 fixes

• (root) — 4 commits
• packages/core-js — 3 commits
• (repo) — 1 commit
• scripts/check-dependencies — 1 commit
• tests/entries — 1 commit
• website/scripts — 1 commit

• fix: fix Iterator.prototype.join in Chrome version
• change: Merge pull request #1558 from zloirock/website-runner-cleanup
• change: add Electron 46 compat data mapping
• change: add Opera for Android 102 compat data mapping
• change: add Samsung Browser 31 compat data mapping
• change: drop unneeded test
• change: move Iterator.prototype.includes to stable ES
• change: move Iterator.prototype.join to stable ES
• change: move Iterator chunking to stable ES
• change: update dependencies
• change: website runner: clean up after a failed build and fail the job

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

zloirock/core-js was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.