Introduction

Can the process of attaching polyfill scripts to source code be called transpiling??

How to Apply Polyfill Scripts

An actual example of a polyfill script looks like this. 
The latest version of the JS Array wrapper object methods includes flat(). It's simply a method that extracts elements from a 2D array to create a 1D array, for example

const arr = [[1],[2],[3]] 
console.log(arr.flat()) // [1,2,3]

It works like this. However, flat is ES10 JS syntax and doesn't work in older browsers.

What if it's a project developed with React and uses the flat method internally, but an older browser is used? Transpiling and bundling would be successful, the browser would successfully download and execute the JS bundle, but problems would occur during execution, throwing a Runtime error. To solve this, if we attach a polyfill, the code could evolve as follows.

if (!Array.prototype.flat) {
  Array.prototype.flat = function(depth = 1) {
    if (this == null) {
      throw new TypeError('Array.prototype.flat called on null or undefined');
    }
   
    const O = Object(this);

    const len = parseInt(O.length) || 0;
 
    let depthNum = depth === undefined ? 1 : Number(depth);
    if (depthNum < 0) depthNum = 0;
    if (depthNum === Infinity) depthNum = Number.MAX_SAFE_INTEGER;
    

    function flattenDeep(arr, currentDepth) {
      const result = [];
      
      for (let i = 0; i < arr.length; i++) {
        const element = arr[i];
     
        if (Array.isArray(element) && currentDepth > 0) {
          result.push(...flattenDeep(element, currentDepth - 1));
        } else {
          result.push(element);
        }
      }
      
      return result;
    }
    
    return flattenDeep(O, depthNum);
  };
}

const arr = [[1],[2],[3]];
console.log(arr.flat());

Reading the code, polyfill is just a fancy word, it's simply defining a new flat method directly in the wrapper object's prototype. However, during development, you use numerous methods and features in the source code, and newly released JS versions include many new features. It's practically impossible for developers to understand all of these, implement all features through hard coding, and write polyfill scripts directly every time they use new features.

What solves this effectively is the Core-Js library.

How to Efficiently Load Polyfill Scripts

import 'core-js/features/array/flat';
const arr = [[1],[2],[3]]; 
console.log(arr.flat());

module.exports = {
  presets: [
    ['@babel/preset-env', { targets: { ie: 11 } }],
    useBuiltIns: 'usage',
    corejs: 3
  ],
};