Home

This fork of babel, generates a more optimal output for today's browsers.

Default Parameters

Given a function with default parameters like:

function foo(a=2, b=3) {
  return a + b;
}

The upstream version generates output which touches on the expensive arguments object:

function foo() {
  var a = arguments[0] === undefined ? 2 : arguments[0];
  var b = arguments[1] === undefined ? 3 : arguments[1];
  return a + b;
}

Whilst this is in line with the ES6 spec, the value it provides by making the arity returned by foo.length consistent, is not something that's commonly used. Instead, we generate the following more performant output:

function foo(a, b) {
  a === undefined && (a = 2);
  b === undefined && (b = 3);
  return a + b;
}

Export Declarations

When defining exports, e.g.

export function foo() {
  alert("hi");
}

The upstream version generates the equivalent of:

function foo() {
  alert("hi");
}

exports.foo = foo;
Object.defineProperty(exports, "__esModule", {
  value: true
});

Whilst defining __esModule helps with compatibility with various loaders, we don't use it within µ, so we instead just output:

function foo() {
  alert("hi");
}

exports.foo = foo;

Import Declarations

Similarly, when defining imports, e.g.

import foo from "foo";

Upstream will generate:

var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };

var foo = _interopRequire(require("foo"));

We instead generate the following — without the __esModule check:

var foo = require("foo")["default"];

Note: This only works for the default module type of common. If you specify an alternative type, e.g. babel --modules amd, then it will behave as it would in upstream.

For...Of Loops

Upstream currently transforms:

for (var user of users) {
  display(user.name);
}

Into:

var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
  for (var _iterator = users[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
    var user = _step.value;
    display(user.name);
  }
} catch (err) {
  _didIteratorError = true;
  _iteratorError = err;
} finally {
  try {
    if (!_iteratorNormalCompletion && _iterator["return"]) {
      _iterator["return"]();
    }
  } finally {
    if (_didIteratorError) {
      throw _iteratorError;
    }
  }
}

Not only does this mean we can't use for...of loops on Arrays in older browsers without hacking Array.prototype, but it also puts a loop inside a try/catch which tends to be deadly for performance.

We instead generate the following:

for (var user, _isArray = Array.isArray(users), _i = 0, _j, _iterator = _isArray && users[Symbol.iterator]();;) {
  if (_isArray) {
    if (_i >= users.length) break;
    user = users[_i++];
  } else {
    _j = _iterator.next();
    if (_j.done) break;
    user = _j.value;
  }
  display(user.name);
}

This fast-paths Array values in for...of loops like in --loose mode, drops support for calling any generator return values, and tries to minimise unnecessary assignments during variable declarations.

Array Comprehensions

In a complete break with standards, we overload the for (x in y) syntax.