What Polyfills Are Included in react-app-polyfill?

The react-app-polyfill package provides three entry points—ie9, ie11, and stable—that bundle essential JavaScript polyfills for Internet Explorer 9/11 and modern browsers, including Promise, fetch, Object.assign, Symbol, Map, Set, and core-js stable features.

The react-app-polyfill package is maintained as part of the facebook/create-react-app ecosystem and supplies the minimal JavaScript polyfills required to run React applications in legacy environments. Understanding what polyfills are included in react-app-polyfill helps you select the correct entry point based on your target browser support matrix while keeping bundle sizes optimized.

Entry Points and Included Polyfills

The package exposes three distinct entry points in packages/react-app-polyfill/, each targeting specific browser compatibility needs.

IE9 Support (react-app-polyfill/ie9)

The ie9 entry point, defined in packages/react-app-polyfill/ie9.js, provides the most comprehensive legacy support by composing the IE11 polyfill set with additional shims for IE9-specific gaps.

According to the source code in facebook/create-react-app, this entry loads:

• All IE11 polyfills (Promise, fetch, Object.assign, Symbol, Array.from)
• Map from core-js/features/map
• Set from core-js/features/set
• requestAnimationFrame polyfill via the raf package

IE11 Support (react-app-polyfill/ie11)

The ie11 entry point in packages/react-app-polyfill/ie11.js covers the baseline requirements for Internet Explorer 11.

As implemented in the source, this entry includes:

• Promise polyfill (using the promise package when native support is missing) with rejection tracking
• fetch API via whatwg-fetch
• Object.assign via object-assign
• Symbol from core-js/features/symbol
• Array.from from core-js/features/array/from

Modern Browser Support (react-app-polyfill/stable)

For applications targeting only modern browsers but requiring stable ECMAScript features, the stable entry point in packages/react-app-polyfill/stable.js loads the full core-js stable set.

This entry provides:

• All stable ECMAScript features from core-js/stable (e.g., Array.prototype.includes, String.prototype.padStart, Object.entries)
• regenerator-runtime for generator functions and async/await support

Complete Polyfill Reference

When you combine the legacy entry points with the stable set, you receive a comprehensive polyfill layer:

• Promise (including async/await support)
• fetch (for network requests)
• Object.assign (required for object spread syntax)
• Symbol (necessary for for…of loops and iterables)
• Array.from (enables spread of array-like objects)
• Map and Set (ES6 collection types)
• requestAnimationFrame (animation timing API)
• Full stable language features via core-js and regenerator-runtime

These polyfills are deliberately scoped so they only load when you explicitly import the corresponding entry point, keeping bundles small for modern browsers while providing full compatibility for legacy environments.

Implementation Examples

To use these polyfills correctly, import them at the very beginning of your entry file before any other application code.

Supporting IE9

// src/index.js - must be the very first imports
import 'react-app-polyfill/ie9';
import 'react-app-polyfill/stable';

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';

ReactDOM.render(<App />, document.getElementById('root'));

Supporting IE11

// src/index.js - must be the very first imports
import 'react-app-polyfill/ie11';
import 'react-app-polyfill/stable';

// Your application code follows

Modern Browsers Only

import 'react-app-polyfill/stable';
// Rest of your application

Summary

• react-app-polyfill offers three entry points—ie9, ie11, and stable—located in packages/react-app-polyfill/
• The ie9 entry includes all IE11 polyfills plus Map, Set, and requestAnimationFrame from the raf package
• The ie11 entry provides Promise (with rejection tracking), fetch, Object.assign, Symbol, and Array.from
• The stable entry supplies all core-js stable features and regenerator-runtime for async/await support
• Always import polyfills as the first lines in your entry file to ensure global APIs are patched before application code executes

Frequently Asked Questions

Do I need to import both ie11 and stable?

Yes. The ie11 entry provides legacy browser APIs like Promise and fetch, while stable provides modern ECMAScript features like Array.prototype.includes and regenerator-runtime for async functions. Import both to ensure full compatibility across all target browsers.

Can I use react-app-polyfill without Create React App?

While designed for the facebook/create-react-app ecosystem, you can install and use react-app-polyfill in any webpack-based React project. However, the polyfills are specifically curated to match Create React App's supported browser matrix and may include unnecessary features for other build configurations.

Why is requestAnimationFrame only in the ie9 entry?

The requestAnimationFrame polyfill from the raf package is primarily needed for IE9, as IE10 and later include native support. The ie9.js file in packages/react-app-polyfill/ chains this polyfill alongside the IE11 set to provide complete animation timing support for legacy browsers without adding overhead to IE11 configurations.

How do I verify which polyfills are loading in my bundle?

Analyze your webpack bundle using tools like webpack-bundle-analyzer or source map explorers. Look for imports from core-js, whatwg-fetch, object-assign, promise, and raf packages. The specific entry point you import (ie9, ie11, or stable) determines which of these dependencies get included in your final production build.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}