Assumptions
arrayLikeIsIterable
When spreading or iterating an array-like object, assume that it implements a [Symbol.iterator] method with the same behavior of the native Array.prototype[Symbol.iterator], and thus directly iterate over its element by index.This can be useful, for example, to iterate DOM collections in older browsers
constantReexports
When re-exporting a bindin from a module, assume that it doesn't change and thus it's safe to directly export it, as if you were doingimport { value as val } from "dep";
export const value = val;NOTE: This also affects the
transform-modules-umd and transform-modules-amd plugins.constantSuper
The super class of a class can be changed at any time by using Object.setPrototypeOf, making it impossible for Babel to statically know it. When this option is enabled, Babel assumes that it's never changed and thus it is always the value that was placed in the extends clause in the class declaration.enumerableModuleMeta
When compiling ESM to CJS, Babel defines a __esModule property on the module.exports object. Assume that you never iterate over the keys of module.exports or of require("your-module") using for..in or Object.keys, and thus it's safe to define __esModule as enumerable.ignoreFunctionLength
Functions have a .length property that reflect the number of parameters up to the last non-default parameter. When this option is enabled, assume that the compiled code does not rely on this .length property.ignoreToPrimitiveHint
When using language features that might call the [Symbol.toPrimitive] method of objects, assume that they don't change their behavior based on the hint parameter.iterableIsArray
When using an iterable object (in array destructuring, for-of or spreads), assume that it is an array.mutableTemplateObject
When using language features that might call the [Symbol.toPrimitive] method of objects, assume that they don't change their behavior based on the hint parameter.noClassCalls
When transforming classes, assume that they are always instantiate with new and they are never called as functions.noDocumentAll
When using operators that check for null or undefined, assume that they are never used with the special value document.allnoNewArrows
Assume that the code never tries to instantiate arrow functions using new, which is disallowed according to the specification.NOTE: This assumption defaults to
true. It will default to false starting from Babel 8.objectRestNoSymbols
When using rest patterns in object destructuring, assume that destructured objects don't have symbol keys or that it's not a problem if they are not copied.privateFieldsAsProperties
Assume that "soft privacy" is enough for private fields, and thus they can be stored as public non-enumerable properties with an unique name (rather than using an external WeakMap). This makes debugging compiled private fields easier.pureGetters
Assume that getters, if present, don't have side-effects and can be accessed multiple times.setClassMethods
When declaring classess, assume that methods don't shadow getters on the superclass and that the program doesn't depend on methods being non-enumerable. Thus, it's safe to assign methods rather than using Object.defineProperty.setComputedProperties
When using computed object properties, assume that the object doesn't contain properties that overwrite setter defined in the same object, and thus it's safe to assign them rather than defining them using Object.defineProperty.setPublicClassFields
When using public class fields, assume that they don't shadow any getter in the current class, in its subclasses or in its superclass. Thus, it's safe to assign them rather than using Object.defineProperty.setSpreadProperties
When using object spread, assume that spreaded properties don't trigger getters on the target object and thus it's safe to assign them rather than defining them using Object.defineProperty.skipForOfIteratorClosing
When using for-of with an iterator, it should always be closed with .return() and with .throw() in case of an error. When this option is called Babel assumes that those methods are not defined or empty, and it avoids calling them.superIsCallableConstructor
When extending classes, assume that the super class is callable. This means that it won't be possible to extend native classes or built-ins, but only compiled classes or ES5 function constructors.