esperanto-source 0.6.34.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c80d326f36ea02656ae51fdb93af783f6c05f182
-  data.tar.gz: e4cf0bb2a55cd677418497d10f45e5cee6ca0a82
+  metadata.gz: a98d5b601e29366275a76d72e9234655c36d0648
+  data.tar.gz: 316a57604f6c072b894b40515d491a0fc744029d
 SHA512:
-  metadata.gz: 4de81b2a68d5a09b1cfd7432ef7ce5aa6a9d496e6c3131b642b38889408958f95d398fbbd3a0d594b475caec70e018541615d0746dc4d67125b9aaa6795500c2
-  data.tar.gz: 48ea237ba72a40119592355924554e48e989fbd0e5603e5a40c43c5c278ff4868bbf607db21f78920ada5e1b9a9b464ec99e598bda0f8a320e84e854fefd109b
+  metadata.gz: 0e53f43007bf4a985cdca9e133012ef276e0e5a90f09e25c77ef7d60289e246b9c1f51b9187c5a24e7ec1d3b635489493d720a74c5bfa10bd41c968fcab58101
+  data.tar.gz: 381b8dccc8c4e3f8a112124726711253c3031a7031a6cc366370b8489c5cad297a8dda07a4f1af4d9f843eb971370d90609798eed6522cda1c73dad3faea8b76

data/lib/esperanto/source/version.rb

@@ -1,5 +1,5 @@
 module Esperanto
   module Source
-    VERSION = '0.6.34.1'
+    VERSION = '0.7.0'
   end
 end

data/vendor/esperanto.browser.js

@@ -1,31 +1,35 @@
 /*
-	esperanto.js v0.6.34 - 2015-05-12
+	esperanto.js v0.7.0 - 2015-05-12
 	http://esperantojs.org
 
 	Released under the MIT License.
 */
 
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('acorn')) :
-	typeof define === 'function' && define.amd ? define(['acorn'], factory) :
-	global.esperanto = factory(global.acorn)
-}(this, function (acorn) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('acorn')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'acorn'], factory) :
+	factory((global.esperanto = {}), global.acorn)
+}(this, function (exports, acorn) { 'use strict';
 
-	function hasNamedImports ( mod ) {
+	var utils_hasNamedImports = hasNamedImports;
+
+	function hasNamedImports(mod) {
 		var i = mod.imports.length;
 
-		while ( i-- ) {
-			if ( mod.imports[i].isNamed ) {
+		while (i--) {
+			if (mod.imports[i].isNamed) {
 				return true;
 			}
 		}
 	}
 
-	function hasNamedExports ( mod ) {
+	var utils_hasNamedExports = hasNamedExports;
+
+	function hasNamedExports(mod) {
 		var i = mod.exports.length;
 
-		while ( i-- ) {
-			if ( !mod.exports[i].isDefault ) {
+		while (i--) {
+			if (!mod.exports[i].isDefault) {
 				return true;
 			}
 		}
@@ -930,95 +934,105 @@
 
 	var magic_string = MagicString;
 
-	var ast_walk__shouldSkip;
-	var ast_walk__shouldAbort;
+	var ast_walk = walk;
 
-	function walk ( ast, leave) {var enter = leave.enter, leave = leave.leave;
-		ast_walk__shouldAbort = false;
-		visit( ast, null, enter, leave );
+	var shouldSkip = undefined;
+	var shouldAbort = undefined;
+	function walk(ast, _ref) {
+		var enter = _ref.enter;
+		var leave = _ref.leave;
+
+		shouldAbort = false;
+		visit(ast, null, enter, leave);
 	}
 
-	var ast_walk__context = {
-		skip: function()  {return ast_walk__shouldSkip = true},
-		abort: function()  {return ast_walk__shouldAbort = true}
+	var context = {
+		skip: function () {
+			return shouldSkip = true;
+		},
+		abort: function () {
+			return shouldAbort = true;
+		}
 	};
 
-	var ast_walk__childKeys = {};
+	var childKeys = {};
 
-	var ast_walk__toString = Object.prototype.toString;
+	var toString = Object.prototype.toString;
 
-	function isArray ( thing ) {
-		return ast_walk__toString.call( thing ) === '[object Array]';
+	function isArray(thing) {
+		return toString.call(thing) === '[object Array]';
 	}
 
-	function visit ( node, parent, enter, leave ) {
-		if ( !node || ast_walk__shouldAbort ) return;
+	function visit(node, parent, enter, leave) {
+		if (!node || shouldAbort) return;
 
-		if ( enter ) {
-			ast_walk__shouldSkip = false;
-			enter.call( ast_walk__context, node, parent );
-			if ( ast_walk__shouldSkip || ast_walk__shouldAbort ) return;
+		if (enter) {
+			shouldSkip = false;
+			enter.call(context, node, parent);
+			if (shouldSkip || shouldAbort) return;
 		}
 
-		var keys = ast_walk__childKeys[ node.type ] || (
-			ast_walk__childKeys[ node.type ] = Object.keys( node ).filter( function(key ) {return typeof node[ key ] === 'object'} )
-		);
+		var keys = childKeys[node.type] || (childKeys[node.type] = Object.keys(node).filter(function (key) {
+			return typeof node[key] === 'object';
+		}));
 
-		var key, value, i, j;
+		var key = undefined,
+		    value = undefined,
+		    i = undefined,
+		    j = undefined;
 
 		i = keys.length;
-		while ( i-- ) {
+		while (i--) {
 			key = keys[i];
-			value = node[ key ];
+			value = node[key];
 
-			if ( isArray( value ) ) {
+			if (isArray(value)) {
 				j = value.length;
-				while ( j-- ) {
-					visit( value[j], node, enter, leave );
+				while (j--) {
+					visit(value[j], node, enter, leave);
 				}
-			}
-
-			else if ( value && value.type ) {
-				visit( value, node, enter, leave );
+			} else if (value && value.type) {
+				visit(value, node, enter, leave);
 			}
 		}
 
-		if ( leave && !ast_walk__shouldAbort ) {
-			leave( node, parent );
+		if (leave && !shouldAbort) {
+			leave(node, parent);
 		}
 	}
 
-	function getId ( m ) {
+	function getId(m) {
 		return m.id;
 	}
 
-	function getName ( m ) {
+	function getName(m) {
 		return m.name;
 	}
 
-	function quote ( str ) {
+	function quote(str) {
 		return "'" + JSON.stringify(str).slice(1, -1).replace(/'/g, "\\'") + "'";
 	}
 
-	function req ( path ) {
-		return (("require(" + (quote(path))) + ")");
+	function req(path) {
+		return "require(" + quote(path) + ")";
 	}
 
-	function globalify ( name ) {
-	  	if ( /^__dep\d+__$/.test( name ) ) {
-			return 'undefined';
+	function globalify(name) {
+		if (/^__dep\d+__$/.test(name)) {
+			return "undefined";
 		} else {
-			return ("global." + name);
+			return "global." + name;
 		}
 	}
 
+	var annotate = annotateAst;
 	/*
 		This module traverse a module's AST, attaching scope information
 		to nodes as it goes, which is later used to determine which
 		identifiers need to be rewritten to avoid collisions
 	*/
 
-	function Scope ( options ) {
+	function Scope(options) {
 		options = options || {};
 
 		this.parent = options.parent;
@@ -1026,28 +1040,29 @@
 	}
 
 	Scope.prototype = {
-		add: function ( name ) {
-			this.names.push( name );
+		add: function (name) {
+			this.names.push(name);
 		},
 
-		contains: function ( name, ignoreTopLevel ) {
-			if ( ignoreTopLevel && !this.parent ) {
+		contains: function (name, ignoreTopLevel) {
+			if (ignoreTopLevel && !this.parent) {
 				return false;
 			}
 
-			if ( ~this.names.indexOf( name ) ) {
+			if (~this.names.indexOf(name)) {
 				return true;
 			}
 
-			if ( this.parent ) {
-				return this.parent.contains( name, ignoreTopLevel );
+			if (this.parent) {
+				return this.parent.contains(name, ignoreTopLevel);
 			}
 
 			return false;
 		}
 	};
+	function annotateAst(ast, options) {
+		var trackAssignments = options && options.trackAssignments;
 
-	function annotateAst ( ast ) {
 		var scope = new Scope();
 		var blockScope = new Scope();
 		var declared = {};
@@ -1056,38 +1071,40 @@
 
 		var envDepth = 0;
 
-		walk( ast, {
-			enter: function ( node ) {
-				if ( node.type === 'ImportDeclaration' || node.type === 'ExportSpecifier' ) {
+		ast_walk(ast, {
+			enter: function (node) {
+				if (node.type === 'ImportDeclaration' || node.type === 'ExportSpecifier') {
 					node._skip = true;
 				}
 
-				if ( node._skip ) {
+				if (node._skip) {
 					return this.skip();
 				}
 
-				switch ( node.type ) {
+				switch (node.type) {
 					case 'FunctionExpression':
 					case 'FunctionDeclaration':
 
 						envDepth += 1;
 
-						// fallthrough
+					// fallthrough
 
 					case 'ArrowFunctionExpression':
-						if ( node.id ) {
-							addToScope( node );
+						if (node.id) {
+							addToScope(node);
 
 							// If this is the root scope, this may need to be
 							// exported early, so we make a note of it
-							if ( !scope.parent && node.type === 'FunctionDeclaration' ) {
-								topLevelFunctionNames.push( node.id.name );
+							if (!scope.parent && node.type === 'FunctionDeclaration') {
+								topLevelFunctionNames.push(node.id.name);
 							}
 						}
 
-						var names = node.params.map( getName );
+						var names = node.params.map(getName);
 
-						names.forEach( function(name ) {return declared[ name ] = true} );
+						names.forEach(function (name) {
+							return declared[name] = true;
+						});
 
 						scope = node._scope = new Scope({
 							parent: scope,
@@ -1104,19 +1121,19 @@
 						break;
 
 					case 'VariableDeclaration':
-						node.declarations.forEach( node.kind === 'let' ? addToBlockScope : addToScope );
+						node.declarations.forEach(node.kind === 'let' ? addToBlockScope : addToScope);
 						break;
 
 					case 'ClassExpression':
 					case 'ClassDeclaration':
-						addToScope( node );
+						addToScope(node);
 						break;
 
 					case 'MemberExpression':
-						if ( envDepth === 0 && node.object.type === 'ThisExpression' ) {
+						if (envDepth === 0 && node.object.type === 'ThisExpression') {
 							throw new Error('`this` at the top level is undefined');
 						}
-						!node.computed && ( node.property._skip = true );
+						!node.computed && (node.property._skip = true);
 						break;
 
 					case 'Property':
@@ -1124,7 +1141,7 @@
 						break;
 
 					case 'TemplateLiteral':
-						templateLiteralRanges.push([ node.start, node.end ]);
+						templateLiteralRanges.push([node.start, node.end]);
 						break;
 
 					case 'ThisExpression':
@@ -1132,16 +1149,24 @@
 							node._topLevel = true;
 						}
 						break;
+
+					case 'AssignmentExpression':
+						assignTo(node.left);
+						break;
+
+					case 'UpdateExpression':
+						assignTo(node.argument);
+						break;
 				}
 			},
-			leave: function ( node ) {
-				switch ( node.type ) {
+			leave: function (node) {
+				switch (node.type) {
 					case 'FunctionExpression':
 					case 'FunctionDeclaration':
 
 						envDepth -= 1;
 
-						// fallthrough
+					// fallthrough
 
 					case 'ArrowFunctionExpression':
 
@@ -1156,23 +1181,34 @@
 			}
 		});
 
-		function addToScope ( declarator ) {
+		function assignTo(node) {
+			if (trackAssignments && node.type === 'Identifier' && node.name === trackAssignments.name) {
+				// This is possibly somewhat hacky. Open to alternative approaches...
+				// It will yield false positives if `foo` in `export default foo` is shadowed
+				(trackAssignments._assignments || (trackAssignments._assignments = [])).push({
+					scope: scope,
+					node: node
+				});
+			}
+		}
+
+		function addToScope(declarator) {
 			var name = declarator.id.name;
 
-			scope.add( name );
-			declared[ name ] = true;
+			scope.add(name);
+			declared[name] = true;
 		}
 
-		function addToBlockScope ( declarator ) {
+		function addToBlockScope(declarator) {
 			var name = declarator.id.name;
 
-			blockScope.add( name );
-			declared[ name ] = true;
+			blockScope.add(name);
+			declared[name] = true;
 		}
 
 		ast._scope = scope;
 		ast._blockScope = blockScope;
-		ast._topLevelNames = ast._scope.names.concat( ast._blockScope.names );
+		ast._topLevelNames = ast._scope.names.concat(ast._blockScope.names);
 		ast._topLevelFunctionNames = topLevelFunctionNames;
 		ast._declared = declared;
 		ast._templateLiteralRanges = templateLiteralRanges;
@@ -1180,66 +1216,66 @@
 
 	/**
 	 * Inspects a module and discovers/categorises import & export declarations
-	 * @param {object} mod - the module object
-	 * @param {string} source - the module's original source code
 	 * @param {object} ast - the result of parsing `source` with acorn
-	 * @returns {array} - [ imports, exports ]
+	 * @param {string} source - the module's original source code
+	 * @returns {object} - { imports, exports, defaultExport }
 	 */
-	function findImportsAndExports ( mod, source, ast ) {
-		var imports = [], exports = [], previousDeclaration;
+	var ast_findImportsAndExports = findImportsAndExports;
 
-		ast.body.forEach( function(node ) {
+	function findImportsAndExports(ast, source) {
+		var imports = [];
+		var exports = [];
+		var defaultExport = undefined;
+		var previousDeclaration = undefined;
+
+		ast.body.forEach(function (node) {
 			var passthrough, declaration;
 
-			if ( previousDeclaration ) {
+			if (previousDeclaration) {
 				previousDeclaration.next = node.start;
 
-				if ( node.type !== 'EmptyStatement' ) {
+				if (node.type !== 'EmptyStatement') {
 					previousDeclaration = null;
 				}
 			}
 
-			if ( node.type === 'ImportDeclaration' ) {
-				declaration = processImport( node );
-				imports.push( declaration );
-			}
+			if (node.type === 'ImportDeclaration') {
+				declaration = processImport(node);
+				imports.push(declaration);
+			} else if (node.type === 'ExportDefaultDeclaration') {
+				declaration = processDefaultExport(node, source);
+				exports.push(declaration);
 
-			else if ( node.type === 'ExportDefaultDeclaration' ) {
-				declaration = processDefaultExport( node, source );
-				exports.push( declaration );
-
-				if ( mod.defaultExport ) {
-					throw new Error( 'Duplicate default exports' );
+				if (defaultExport) {
+					throw new Error('Duplicate default exports');
 				}
-				mod.defaultExport = declaration;
-			}
+				defaultExport = declaration;
+			} else if (node.type === 'ExportNamedDeclaration') {
+				declaration = processExport(node, source);
+				exports.push(declaration);
 
-			else if ( node.type === 'ExportNamedDeclaration' ) {
-				declaration = processExport( node, source );
-				exports.push( declaration );
-
-				if ( node.source ) {
+				if (node.source) {
 					// it's both an import and an export, e.g.
 					// `export { foo } from './bar';
-					passthrough = processImport( node, true );
-					imports.push( passthrough );
+					passthrough = processImport(node, true);
+					imports.push(passthrough);
 
 					declaration.passthrough = passthrough;
 				}
 			}
 
-			if ( declaration ) {
+			if (declaration) {
 				previousDeclaration = declaration;
 			}
 		});
 
 		// catch any trailing semicolons
-		if ( previousDeclaration ) {
+		if (previousDeclaration) {
 			previousDeclaration.next = source.length;
 			previousDeclaration.isFinal = true;
 		}
 
-		return [ imports, exports ];
+		return { imports: imports, exports: exports, defaultExport: defaultExport };
 	}
 
 	/**
@@ -1248,7 +1284,7 @@
 	 * @param {boolean} passthrough - `true` if this is an `export { foo } from 'bar'`-style declaration
 	 * @returns {object}
 	 */
-	function processImport ( node, passthrough ) {
+	function processImport(node, passthrough) {
 		var x = {
 			module: null, // used by bundler - filled in later
 			node: node,
@@ -1257,38 +1293,40 @@
 			passthrough: !!passthrough,
 
 			path: node.source.value,
-			specifiers: node.specifiers.map( function(s ) {
-				if ( s.type === 'ImportNamespaceSpecifier' ) {
+			specifiers: node.specifiers.map(function (s) {
+				if (s.type === 'ImportNamespaceSpecifier') {
 					return {
 						isBatch: true,
 						name: s.local.name, // TODO is this line necessary?
-						as: s.local.name
+						as: s.local.name,
+						origin: null // filled in later by bundler
 					};
 				}
 
-				if ( s.type === 'ImportDefaultSpecifier' ) {
+				if (s.type === 'ImportDefaultSpecifier') {
 					return {
 						isDefault: true,
 						name: 'default',
-						as: s.local.name
+						as: s.local.name,
+						origin: null
 					};
 				}
 
 				return {
-					name: ( !!passthrough ? s.exported : s.imported ).name,
-					as: s.local.name
+					name: (!!passthrough ? s.exported : s.imported).name,
+					as: s.local.name,
+					origin: null
 				};
 			})
 		};
 
 		// TODO have different types of imports - batch, default, named
-		if ( x.specifiers.length === 0 ) {
+		if (x.specifiers.length === 0) {
 			x.isEmpty = true;
-		} else if ( x.specifiers.length === 1 && x.specifiers[0].isDefault ) {
+		} else if (x.specifiers.length === 1 && x.specifiers[0].isDefault) {
 			x.isDefault = true;
 			x.as = x.specifiers[0].as;
-
-		} else if ( x.specifiers.length === 1 && x.specifiers[0].isBatch ) {
+		} else if (x.specifiers.length === 1 && x.specifiers[0].isBatch) {
 			x.isBatch = true;
 			x.as = x.specifiers[0].name;
 		} else {
@@ -1298,50 +1336,43 @@
 		return x;
 	}
 
-	function processDefaultExport ( node, source ) {
+	function processDefaultExport(node, source) {
+		var d = node.declaration;
+
 		var result = {
-			isDefault: true,
 			node: node,
+			isDefault: true,
 			start: node.start,
-			end: node.end
+			end: node.end,
+			value: source.slice(d.start, d.end),
+			valueStart: d.start,
+			hasDeclaration: null,
+			type: null,
+			name: null
 		};
 
-		var d = node.declaration;
-
-		if ( d.type === 'FunctionExpression' ) {
-			// Case 1: `export default function () {...}`
-			result.hasDeclaration = true; // TODO remove in favour of result.type
-			result.type = 'anonFunction';
-		}
-
-		else if ( d.type === 'FunctionDeclaration' ) {
-			// Case 2: `export default function foo () {...}`
-			result.hasDeclaration = true; // TODO remove in favour of result.type
-			result.type = 'namedFunction';
-			result.name = d.id.name;
-		}
+		// possible declaration types:
+		//   * FunctionExpression  - `export default function () {...}`
+		//   * FunctionDeclaration - `export default function foo () {...}`
+		//   * ClassExpression     - `export default class {...}`
+		//   * ClassDeclaration    - `export default class Foo {...}`
+		var match = /^(Function|Class)(Declaration)?/.exec(d.type);
 
-		else if ( d.type === 'ClassExpression' ) {
-			// Case 3: `export default class {...}`
-			result.hasDeclaration = true; // TODO remove in favour of result.type
-			result.type = 'anonClass';
-		}
+		if (match) {
+			result.hasDeclaration = true;
+			result.type = (match[2] ? 'named' : 'anon') + match[1];
 
-		else if ( d.type === 'ClassDeclaration' ) {
-			// Case 4: `export default class Foo {...}`
-			result.hasDeclaration = true; // TODO remove in favour of result.type
-			result.type = 'namedClass';
-			result.name = d.id.name;
+			if (match[2]) {
+				result.name = d.id.name;
+			}
 		}
 
+		// if no match, we have an expression like `export default whatever`
 		else {
 			result.type = 'expression';
 			result.name = 'default';
 		}
 
-		result.value = source.slice( d.start, d.end );
-		result.valueStart = d.start;
-
 		return result;
 	}
 
@@ -1351,36 +1382,40 @@
 	 * @param {string} source - the original source code
 	 * @returns {object}
 	 */
-	function processExport ( node, source ) {
-		var result, d;
-
-		result = {
+	function processExport(node, source) {
+		var result = {
 			node: node,
 			start: node.start,
-			end: node.end
+			end: node.end,
+			value: null,
+			valueStart: null,
+			hasDeclaration: null,
+			type: null,
+			name: null,
+			specifiers: null
 		};
 
-		if ( d = node.declaration ) {
-			result.value = source.slice( d.start, d.end );
+		var d = node.declaration;
+
+		if (d) {
+			result.hasDeclaration = true;
+			result.value = source.slice(d.start, d.end);
 			result.valueStart = d.start;
 
 			// Case 1: `export var foo = 'bar'`
-			if ( d.type === 'VariableDeclaration' ) {
-				result.hasDeclaration = true; // TODO remove in favour of result.type
+			if (d.type === 'VariableDeclaration') {
 				result.type = 'varDeclaration';
 				result.name = d.declarations[0].id.name;
 			}
 
 			// Case 2: `export function foo () {...}`
-			else if ( d.type === 'FunctionDeclaration' ) {
-				result.hasDeclaration = true; // TODO remove in favour of result.type
+			else if (d.type === 'FunctionDeclaration') {
 				result.type = 'namedFunction';
 				result.name = d.id.name;
 			}
 
 			// Case 3: `export class Foo {...}`
-			else if ( d.type === 'ClassDeclaration' ) {
-				result.hasDeclaration = true; // TODO remove in favour of result.type
+			else if (d.type === 'ClassDeclaration') {
 				result.type = 'namedClass';
 				result.name = d.id.name;
 			}
@@ -1389,8 +1424,9 @@
 		// Case 9: `export { foo, bar };`
 		else {
 			result.type = 'named';
-			result.specifiers = node.specifiers.map( function(s ) {
+			result.specifiers = node.specifiers.map(function (s) {
 				return {
+					origin: null, // filled in later by bundler
 					name: s.local.name,
 					as: s.exported.name
 				};
@@ -1403,44 +1439,44 @@
 	var hasOwnProp = Object.prototype.hasOwnProperty;
 	var utils_hasOwnProp = hasOwnProp;
 
-	function getUnscopedNames ( mod ) {
-		var unscoped = [], importedNames, scope;
+	var ast_getUnscopedNames = getUnscopedNames;
+	function getUnscopedNames(mod) {
+		var unscoped = [],
+		    importedNames,
+		    scope;
 
-		function imported ( name ) {
-			if ( !importedNames ) {
+		function imported(name) {
+			if (!importedNames) {
 				importedNames = {};
-				mod.imports.forEach( function(i ) {
-					!i.passthrough && i.specifiers.forEach( function(s ) {
-						importedNames[ s.as ] = true;
+				mod.imports.forEach(function (i) {
+					!i.passthrough && i.specifiers.forEach(function (s) {
+						importedNames[s.as] = true;
 					});
 				});
 			}
-			return utils_hasOwnProp.call( importedNames, name );
+			return utils_hasOwnProp.call(importedNames, name);
 		}
 
-		walk( mod.ast, {
-			enter: function ( node ) {
+		ast_walk(mod.ast, {
+			enter: function (node) {
 				// we're only interested in references, not property names etc
-				if ( node._skip ) return this.skip();
+				if (node._skip) return this.skip();
 
-				if ( node._scope ) {
+				if (node._scope) {
 					scope = node._scope;
 				}
 
-				if ( node.type === 'Identifier' &&
-						 !scope.contains( node.name ) &&
-						 !imported( node.name ) &&
-						 !~unscoped.indexOf( node.name ) ) {
-					unscoped.push( node.name );
+				if (node.type === 'Identifier' && !scope.contains(node.name) && !imported(node.name) && ! ~unscoped.indexOf(node.name)) {
+					unscoped.push(node.name);
 				}
 			},
 
-			leave: function ( node ) {
-				if ( node.type === 'Program' ) {
+			leave: function (node) {
+				if (node.type === 'Program') {
 					return;
 				}
 
-				if ( node._scope ) {
+				if (node._scope) {
 					scope = scope.parent;
 				}
 			}
@@ -1449,62 +1485,66 @@
 		return unscoped;
 	}
 
-	function disallowConflictingImports ( imports ) {
+	var utils_disallowConflictingImports = disallowConflictingImports;
+	function disallowConflictingImports(imports) {
 		var usedNames = {};
 
-		imports.forEach( function(x ) {
-			if ( x.passthrough ) return;
+		imports.forEach(function (x) {
+			if (x.passthrough) return;
 
-			if ( x.as ) {
-				checkName( x.as );
+			if (x.as) {
+				checkName(x.as);
 			} else {
-				x.specifiers.forEach( checkSpecifier );
+				x.specifiers.forEach(checkSpecifier);
 			}
 		});
 
-		function checkSpecifier ( s ) {
-			checkName( s.as );
+		function checkSpecifier(s) {
+			checkName(s.as);
 		}
 
-		function checkName ( name ) {
-			if ( utils_hasOwnProp.call( usedNames, name ) ) {
-				throw new SyntaxError( (("Duplicated import ('" + name) + "')") );
+		function checkName(name) {
+			if (utils_hasOwnProp.call(usedNames, name)) {
+				throw new SyntaxError('Duplicated import (\'' + name + '\')');
 			}
 
-			usedNames[ name ] = true;
+			usedNames[name] = true;
 		}
 	}
 
-	var RESERVED = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield'.split( ' ' );
-	var INVALID_CHAR = /[^a-zA-Z0-9_$]/g;
-	var INVALID_LEADING_CHAR = /[^a-zA-Z_$]/;
-
 	/**
 	 * Generates a sanitized (i.e. valid identifier) name from a module ID
 	 * @param {string} id - a module ID, or part thereof
 	 * @returns {string}
 	 */
-	function sanitize ( name ) {
-		name = name.replace( INVALID_CHAR, '_' );
+	var utils_sanitize = sanitize;
 
-		if ( INVALID_LEADING_CHAR.test( name[0] ) || ~RESERVED.indexOf( name ) ) {
-			name = ("_" + name);
+	var RESERVED = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield'.split(' ');
+	var INVALID_CHAR = /[^a-zA-Z0-9_$]/g;
+	var INVALID_LEADING_CHAR = /[^a-zA-Z_$]/;
+	function sanitize(name) {
+		name = name.replace(INVALID_CHAR, '_');
+
+		if (INVALID_LEADING_CHAR.test(name[0]) || ~RESERVED.indexOf(name)) {
+			name = '_' + name;
 		}
 
 		return name;
 	}
 
 	var pathSplitRE = /\/|\\/;
-	function splitPath ( path ) {
-		return path.split( pathSplitRE );
+	function splitPath(path) {
+		return path.split(pathSplitRE);
 	}
 
-	var SOURCEMAPPINGURL_REGEX = /^# sourceMappingURL=/;
+	var getModule = getStandaloneModule;
 
-	function getStandaloneModule ( options ) {
-		var code, ast;
+	var SOURCEMAPPINGURL_REGEX = /^# sourceMappingURL=/;
+	function getStandaloneModule(options) {
+		var code = undefined,
+		    ast = undefined;
 
-		if ( typeof options.source === 'object' ) {
+		if (typeof options.source === 'object') {
 			code = options.source.code;
 			ast = options.source.ast;
 		} else {
@@ -1514,199 +1554,211 @@
 		var toRemove = [];
 
 		var mod = {
-			body: new magic_string( code ),
-			ast: ast || ( acorn.parse( code, {
+			body: new magic_string(code),
+			ast: ast || acorn.parse(code, {
 				ecmaVersion: 6,
 				sourceType: 'module',
-				onComment: function ( block, text, start, end ) {
+				onComment: function (block, text, start, end) {
 					// sourceMappingURL comments should be removed
-					if ( !block && SOURCEMAPPINGURL_REGEX.test( text ) ) {
+					if (!block && SOURCEMAPPINGURL_REGEX.test(text)) {
 						toRemove.push({ start: start, end: end });
 					}
 				}
-			}))
+			})
 		};
 
-		toRemove.forEach( function(end)  {var start = end.start, end = end.end;return mod.body.remove( start, end )} );
+		toRemove.forEach(function (_ref) {
+			var start = _ref.start;
+			var end = _ref.end;
+			return mod.body.remove(start, end);
+		});
 
-		var imports = (exports = findImportsAndExports( mod, code, mod.ast ))[0], exports = exports[1];
+		var _findImportsAndExports = ast_findImportsAndExports(mod.ast, code);
 
-		disallowConflictingImports( imports );
+		var imports = _findImportsAndExports.imports;
+		var exports = _findImportsAndExports.exports;
+		var defaultExport = _findImportsAndExports.defaultExport;
+
+		utils_disallowConflictingImports(imports);
 
 		mod.imports = imports;
 		mod.exports = exports;
+		mod.defaultExport = defaultExport;
 
 		var conflicts = {};
 
-		if ( options.strict ) {
-			annotateAst( mod.ast );
+		if (options.strict) {
+			annotate(mod.ast, {
+				trackAssignments: null
+			});
 
 			// TODO there's probably an easier way to get this array
-			Object.keys( mod.ast._declared ).concat( getUnscopedNames( mod ) ).forEach( function(n ) {
+			Object.keys(mod.ast._declared).concat(ast_getUnscopedNames(mod)).forEach(function (n) {
 				conflicts[n] = true;
 			});
 		}
 
-		determineImportNames( imports, options.getModuleName, conflicts );
+		determineImportNames(imports, options.getModuleName, conflicts);
 
 		return mod;
 	}
 
-	function determineImportNames ( imports, userFn, usedNames ) {
+	function determineImportNames(imports, userFn, usedNames) {
 		var nameById = {};
 		var inferredNames = {};
 
-		imports.forEach( function(x ) {
+		imports.forEach(function (x) {
 			var moduleId = x.path;
-			var name;
+			var name = undefined;
 
 			moduleId = x.path;
 
 			// use existing value
-			if ( utils_hasOwnProp.call( nameById, moduleId ) ) {
-				x.name = nameById[ moduleId ];
+			if (utils_hasOwnProp.call(nameById, moduleId)) {
+				x.name = nameById[moduleId];
 				return;
 			}
 
 			// if user supplied a function, defer to it
-			if ( userFn && ( name = userFn( moduleId ) ) ) {
-				name = sanitize( name );
+			if (userFn && (name = userFn(moduleId))) {
+				name = utils_sanitize(name);
 
-				if ( utils_hasOwnProp.call( usedNames, name ) ) {
+				if (utils_hasOwnProp.call(usedNames, name)) {
 					// TODO write a test for this
-					throw new Error( (("Naming collision: module " + moduleId) + (" cannot be called " + name) + "") );
+					throw new Error('Naming collision: module ' + moduleId + ' cannot be called ' + name);
 				}
-			}
-
-			else {
-				var parts = splitPath( moduleId );
-				var i;
+			} else {
+				var parts = splitPath(moduleId);
+				var i = undefined;
 				var prefix = '';
-				var candidate;
+				var candidate = undefined;
 
 				do {
 					i = parts.length;
-					while ( i-- > 0 ) {
-						candidate = prefix + sanitize( parts.slice( i ).join( '__' ) );
+					while (i-- > 0) {
+						candidate = prefix + utils_sanitize(parts.slice(i).join('__'));
 
-						if ( !utils_hasOwnProp.call( usedNames, candidate ) ) {
+						if (!utils_hasOwnProp.call(usedNames, candidate)) {
 							name = candidate;
 							break;
 						}
 					}
 
 					prefix += '_';
-				} while ( !name );
+				} while (!name);
 			}
 
-			usedNames[ name ] = true;
-			nameById[ moduleId ] = name;
+			usedNames[name] = true;
+			nameById[moduleId] = name;
 
 			x.name = name;
 		});
 
 		// use inferred names for default imports, wherever they
 		// don't clash with path-based names
-		imports.forEach( function(x ) {
-			if ( x.as && !utils_hasOwnProp.call( usedNames, x.as ) ) {
-				inferredNames[ x.path ] = x.as;
+		imports.forEach(function (x) {
+			if (x.as && !utils_hasOwnProp.call(usedNames, x.as)) {
+				inferredNames[x.path] = x.as;
 			}
 		});
 
-		imports.forEach( function(x ) {
-			if ( utils_hasOwnProp.call( inferredNames, x.path ) ) {
-				x.name = inferredNames[ x.path ];
+		imports.forEach(function (x) {
+			if (utils_hasOwnProp.call(inferredNames, x.path)) {
+				x.name = inferredNames[x.path];
 			}
 		});
 	}
 
-	function transformExportDeclaration ( declaration, body ) {
-		if ( !declaration ) {
+	var utils_transformExportDeclaration = transformExportDeclaration;
+
+	function transformExportDeclaration(declaration, body) {
+		if (!declaration) {
 			return;
 		}
 
-		var exportedValue;
+		var exportedValue = undefined;
 
-		switch ( declaration.type ) {
+		switch (declaration.type) {
 			case 'namedFunction':
 			case 'namedClass':
-				body.remove( declaration.start, declaration.valueStart );
+				body.remove(declaration.start, declaration.valueStart);
 				exportedValue = declaration.name;
 				break;
 
 			case 'anonFunction':
 			case 'anonClass':
-				if ( declaration.isFinal ) {
-					body.replace( declaration.start, declaration.valueStart, 'return ' );
+				if (declaration.isFinal) {
+					body.replace(declaration.start, declaration.valueStart, 'return ');
 				} else {
-					body.replace( declaration.start, declaration.valueStart, 'var __export = ' );
+					body.replace(declaration.start, declaration.valueStart, 'var __export = ');
 					exportedValue = '__export';
 				}
 
 				// add semi-colon, if necessary
 				// TODO body.original is an implementation detail of magic-string - there
 				// should probably be an API for this sort of thing
-				if ( body.original[ declaration.end - 1 ] !== ';' ) {
-					body.insert( declaration.end, ';' );
+				if (body.original[declaration.end - 1] !== ';') {
+					body.insert(declaration.end, ';');
 				}
 
 				break;
 
 			case 'expression':
-				body.remove( declaration.start, declaration.next );
+				body.remove(declaration.start, declaration.next);
 				exportedValue = declaration.value;
 				break;
 
 			default:
-				throw new Error( (("Unexpected export type '" + (declaration.type)) + "'") );
+				throw new Error('Unexpected export type \'' + declaration.type + '\'');
 		}
 
-		if ( exportedValue ) {
-			body.append( (("\nreturn " + exportedValue) + ";") );
+		if (exportedValue) {
+			body.append('\nreturn ' + exportedValue + ';');
 		}
 	}
 
-	var ABSOLUTE_PATH = /^(?:[A-Z]:)?[\/\\]/i;
+	var utils_packageResult = packageResult;
 
-	var utils_packageResult__warned = {};
+	var ABSOLUTE_PATH = /^(?:[A-Z]:)?[\/\\]/i;
 
-	function packageResult ( bundleOrModule, body, options, methodName, isBundle ) {
+	var warned = {};
+	function packageResult(bundleOrModule, body, options, methodName, isBundle) {
 		// wrap output
-		if ( options.banner ) body.prepend( options.banner );
-		if ( options.footer ) body.append( options.footer );
+		if (options.banner) body.prepend(options.banner);
+		if (options.footer) body.append(options.footer);
 
 		var code = body.toString();
-		var map;
+		var map = undefined;
 
-		if ( !!options.sourceMap ) {
-			if ( options.sourceMap !== 'inline' && !options.sourceMapFile ) {
-				throw new Error( 'You must provide `sourceMapFile` option' );
+		if (!!options.sourceMap) {
+			if (options.sourceMap !== 'inline' && !options.sourceMapFile) {
+				throw new Error('You must provide `sourceMapFile` option');
 			}
 
-			if ( !isBundle && !options.sourceMapSource ) {
-				throw new Error( 'You must provide `sourceMapSource` option' );
+			if (!isBundle && !options.sourceMapSource) {
+				throw new Error('You must provide `sourceMapSource` option');
 			}
 
-			var sourceMapFile;
-			if ( options.sourceMap === 'inline' ) {
+			var sourceMapFile = undefined;
+			if (options.sourceMap === 'inline') {
 				sourceMapFile = null;
 			} else {
-				sourceMapFile = ABSOLUTE_PATH.test( options.sourceMapFile ) ? options.sourceMapFile : './' + splitPath( options.sourceMapFile ).pop();
+				sourceMapFile = ABSOLUTE_PATH.test(options.sourceMapFile) ? options.sourceMapFile : './' + splitPath(options.sourceMapFile).pop();
 			}
 
-			if ( isBundle ) {
-				markBundleSourcemapLocations( bundleOrModule );
+			if (isBundle) {
+				markBundleSourcemapLocations(bundleOrModule);
 			} else {
-				markModuleSourcemapLocations( bundleOrModule );
+				markModuleSourcemapLocations(bundleOrModule);
 			}
 
 			map = body.generateMap({
 				includeContent: true,
 				file: sourceMapFile,
-				source: ( sourceMapFile && !isBundle ) ? utils_packageResult__getRelativePath( sourceMapFile, options.sourceMapSource ) : null
+				source: sourceMapFile && !isBundle ? utils_packageResult__getRelativePath(sourceMapFile, options.sourceMapSource) : null
 			});
 
-			if ( options.sourceMap === 'inline' ) {
+			if (options.sourceMap === 'inline') {
 				code += '\n//# sourceMa' + 'ppingURL=' + map.toUrl();
 				map = null;
 			} else {
@@ -1720,9 +1772,9 @@
 			code: code,
 			map: map,
 			toString: function () {
-				if ( !utils_packageResult__warned[ methodName ] ) {
-					console.log( (("Warning: esperanto." + methodName) + "() returns an object with a 'code' property. You should use this instead of using the returned value directly") );
-					utils_packageResult__warned[ methodName ] = true;
+				if (!warned[methodName]) {
+					console.log('Warning: esperanto.' + methodName + '() returns an object with a \'code\' property. You should use this instead of using the returned value directly');
+					warned[methodName] = true;
 				}
 
 				return code;
@@ -1730,157 +1782,183 @@
 		};
 	}
 
-	function utils_packageResult__getRelativePath ( from, to ) {
+	function utils_packageResult__getRelativePath(from, to) {
 		var fromParts, toParts, i;
 
-		fromParts = splitPath( from );
-		toParts = splitPath( to );
+		fromParts = splitPath(from);
+		toParts = splitPath(to);
 
 		fromParts.pop(); // get dirname
 
-		while ( fromParts[0] === '.' ) {
+		while (fromParts[0] === '.') {
 			fromParts.shift();
 		}
 
-		while ( fromParts[0] === toParts[0] ) {
+		while (fromParts[0] === toParts[0]) {
 			fromParts.shift();
 			toParts.shift();
 		}
 
-		if ( fromParts.length ) {
+		if (fromParts.length) {
 			i = fromParts.length;
-			while ( i-- ) fromParts[i] = '..';
+			while (i--) fromParts[i] = '..';
 
-			return fromParts.concat( toParts ).join( '/' );
+			return fromParts.concat(toParts).join('/');
 		} else {
-			toParts.unshift( '.' );
-			return toParts.join( '/' );
+			toParts.unshift('.');
+			return toParts.join('/');
 		}
 	}
 
-	function markBundleSourcemapLocations ( bundle ) {
-		bundle.modules.forEach( function(mod ) {
-			walk( mod.ast, {
-				enter: function(node ) {
-					mod.body.addSourcemapLocation( node.start );
+	function markBundleSourcemapLocations(bundle) {
+		bundle.modules.forEach(function (mod) {
+			ast_walk(mod.ast, {
+				enter: function (node) {
+					mod.body.addSourcemapLocation(node.start);
 				}
 			});
 		});
 	}
 
-	function markModuleSourcemapLocations ( mod ) {
-		walk( mod.ast, {
-			enter: function(node ) {
-				mod.body.addSourcemapLocation( node.start );
+	function markModuleSourcemapLocations(mod) {
+		ast_walk(mod.ast, {
+			enter: function (node) {
+				mod.body.addSourcemapLocation(node.start);
 			}
 		});
 	}
 
-	function resolveId ( importPath, importerPath ) {
+	/**
+	 * Resolves an importPath relative to the module that is importing it
+	 * @param {string} importPath - the (possibly relative) path of an imported module
+	 * @param {string} importerPath - the (relative to `base`) path of the importing module
+	 * @returns {string}
+	 */
+	var utils_resolveId = resolveId;
+
+	function resolveId(importPath, importerPath) {
 		var resolved, importerParts, importParts;
 
-		if ( importPath[0] !== '.' ) {
+		if (importPath[0] !== '.') {
 			resolved = importPath;
 		} else {
-			importerParts = splitPath( importerPath );
-			importParts = splitPath( importPath );
+			importerParts = splitPath(importerPath);
+			importParts = splitPath(importPath);
 
-			if ( importParts[0] === '.' ) {
+			if (importParts[0] === '.') {
 				importParts.shift();
 			}
 
 			importerParts.pop(); // get dirname
-			while ( importParts[0] === '..' ) {
+			while (importParts[0] === '..') {
 				importParts.shift();
 				importerParts.pop();
 			}
 
-			while ( importParts[0] === '.' ) {
+			while (importParts[0] === '.') {
 				importParts.shift();
 			}
 
-			resolved = importerParts.concat( importParts ).join( '/' );
+			resolved = importerParts.concat(importParts).join('/');
 		}
 
 		return resolved;
 	}
 
-	function resolveAgainst ( importerPath ) {
-		return function ( importPath ) {
-			return resolveId( importPath, importerPath );
+	function resolveAgainst(importerPath) {
+		return function (importPath) {
+			return resolveId(importPath, importerPath);
 		};
 	}
 
-	function getImportSummary (name) {var imports = name.imports, absolutePaths = name.absolutePaths, name = name.name;
+	var amd_getImportSummary = getImportSummary;
+	function getImportSummary(_ref) {
+		var imports = _ref.imports;
+		var absolutePaths = _ref.absolutePaths;
+		var name = _ref.name;
+
 		var paths = [];
 		var names = [];
 		var seen = {};
 		var placeholders = 0;
 
-		imports.forEach( function(x ) {
+		imports.forEach(function (x) {
 			var path = x.id || x.path; // TODO unify these
 
-			if ( !seen[ path ] ) {
-				seen[ path ] = true;
+			if (!seen[path]) {
+				seen[path] = true;
 
-				paths.push( path );
+				paths.push(path);
 
 				// TODO x could be an external module, or an internal one.
 				// they have different shapes, resulting in the confusing
 				// code below
-				if ( ( x.needsDefault || x.needsNamed ) || ( x.specifiers && x.specifiers.length ) ) {
-					while ( placeholders ) {
-						names.push( (("__dep" + (names.length)) + "__") );
+				if (x.needsDefault || x.needsNamed || x.specifiers && x.specifiers.length) {
+					while (placeholders) {
+						names.push('__dep' + names.length + '__');
 						placeholders--;
 					}
-					names.push( x.name );
+					names.push(x.name);
 				} else {
 					placeholders++;
 				}
 			}
 		});
 
-		var ids = absolutePaths ? paths.map( function(relativePath ) {return resolveId( relativePath, name )} ) : paths.slice();
+		var ids = absolutePaths ? paths.map(function (relativePath) {
+			return utils_resolveId(relativePath, name);
+		}) : paths.slice();
 
 		return { ids: ids, paths: paths, names: names };
 	}
 
-	function processName ( name ) {
-		return name ? quote( name ) + ', ' : '';
+	var amd_processName = processName;
+	function processName(name) {
+		return name ? quote(name) + ', ' : '';
 	}
 
-	function processIds ( ids ) {
-		return ids.length ? '[' + ids.map( quote ).join( ', ' ) + '], ' : '';
+	var amd_processIds = processIds;
+	function processIds(ids) {
+		return ids.length ? '[' + ids.map(quote).join(', ') + '], ' : '';
 	}
 
-	function amdIntro (useStrict) {var name = useStrict.name, imports = useStrict.imports, hasExports = useStrict.hasExports, indentStr = useStrict.indentStr, absolutePaths = useStrict.absolutePaths, useStrict = useStrict.useStrict;
-		var ids = (names = getImportSummary({ name: name, imports: imports, absolutePaths: absolutePaths })).ids, names = names.names;
+	var amd_amdIntro = amdIntro;
+	function amdIntro(_ref) {
+		var name = _ref.name;
+		var imports = _ref.imports;
+		var hasExports = _ref.hasExports;
+		var indentStr = _ref.indentStr;
+		var absolutePaths = _ref.absolutePaths;
+		var useStrict = _ref.useStrict;
+
+		var _getImportSummary = amd_getImportSummary({ name: name, imports: imports, absolutePaths: absolutePaths });
+
+		var ids = _getImportSummary.ids;
+		var names = _getImportSummary.names;
 
-		if ( hasExports ) {
-			ids.unshift( 'exports' );
-			names.unshift( 'exports' );
+		if (hasExports) {
+			ids.unshift('exports');
+			names.unshift('exports');
 		}
 
-		var intro = (("\
-\ndefine(" + (processName(name))) + ("" + (processIds(ids))) + ("function (" + (names.join( ', ' ))) + ") {\
-\n\
-\n");
+		var intro = '\ndefine(' + amd_processName(name) + '' + amd_processIds(ids) + 'function (' + names.join(', ') + ') {\n\n';
 
-		if ( useStrict ) {
-			intro += (("" + indentStr) + "'use strict';\n\n");
+		if (useStrict) {
+			intro += '' + indentStr + '\'use strict\';\n\n';
 		}
 
 		return intro;
 	}
 
-	function defaultsMode_amd__amd ( mod, options ) {
-		mod.imports.forEach( function(x ) {
-			mod.body.remove( x.start, x.next );
+	var defaultsMode_amd = defaultsMode_amd__amd;
+	function defaultsMode_amd__amd(mod, options) {
+		mod.imports.forEach(function (x) {
+			mod.body.remove(x.start, x.next);
 		});
 
-		transformExportDeclaration( mod.exports[0], mod.body );
+		utils_transformExportDeclaration(mod.exports[0], mod.body);
 
-		var intro = amdIntro({
+		var intro = amd_amdIntro({
 			name: options.amdName,
 			imports: mod.imports,
 			absolutePaths: options.absolutePaths,
@@ -1888,121 +1966,118 @@
 			useStrict: options.useStrict !== false
 		});
 
-		mod.body.trim()
-			.indent()
-			.prepend( intro )
-			.trim()
-			.append( '\n\n});' );
+		mod.body.trim().indent().prepend(intro).trim().append('\n\n});');
 
-		return packageResult( mod, mod.body, options, 'toAmd' );
+		return utils_packageResult(mod, mod.body, options, 'toAmd');
 	}
 
-	function defaultsMode_cjs__cjs ( mod, options ) {
+	var defaultsMode_cjs = defaultsMode_cjs__cjs;
+	function defaultsMode_cjs__cjs(mod, options) {
 		var seen = {};
 
-		mod.imports.forEach( function(x ) {
-			if ( !utils_hasOwnProp.call( seen, x.path ) ) {
-				var replacement = x.isEmpty ? (("" + (req(x.path))) + ";") : (("var " + (x.as)) + (" = " + (req(x.path))) + ";");
-				mod.body.replace( x.start, x.end, replacement );
+		mod.imports.forEach(function (x) {
+			if (!utils_hasOwnProp.call(seen, x.path)) {
+				var replacement = x.isEmpty ? '' + req(x.path) + ';' : 'var ' + x.as + ' = ' + req(x.path) + ';';
+				mod.body.replace(x.start, x.end, replacement);
 
-				seen[ x.path ] = true;
+				seen[x.path] = true;
 			} else {
-				mod.body.remove( x.start, x.next );
+				mod.body.remove(x.start, x.next);
 			}
 		});
 
 		var exportDeclaration = mod.exports[0];
 
-		if ( exportDeclaration ) {
-			switch ( exportDeclaration.type ) {
+		if (exportDeclaration) {
+			switch (exportDeclaration.type) {
 				case 'namedFunction':
 				case 'namedClass':
-					mod.body.remove( exportDeclaration.start, exportDeclaration.valueStart );
-					mod.body.replace( exportDeclaration.end, exportDeclaration.end, (("\nmodule.exports = " + (exportDeclaration.node.declaration.id.name)) + ";") );
+					mod.body.remove(exportDeclaration.start, exportDeclaration.valueStart);
+					mod.body.replace(exportDeclaration.end, exportDeclaration.end, '\nmodule.exports = ' + exportDeclaration.name + ';');
 					break;
 
 				default:
-					mod.body.replace( exportDeclaration.start, exportDeclaration.valueStart, 'module.exports = ' );
+					mod.body.replace(exportDeclaration.start, exportDeclaration.valueStart, 'module.exports = ');
 					break;
 			}
 		}
 
-		if ( options.useStrict !== false ) {
-			mod.body.prepend( "'use strict';\n\n" ).trimLines();
+		if (options.useStrict !== false) {
+			mod.body.prepend('\'use strict\';\n\n').trimLines();
 		}
 
-		return packageResult( mod, mod.body, options, 'toCjs' );
+		return utils_packageResult(mod, mod.body, options, 'toCjs');
 	}
 
-	function umdIntro (useStrict) {var amdName = useStrict.amdName, name = useStrict.name, hasExports = useStrict.hasExports, imports = useStrict.imports, absolutePaths = useStrict.absolutePaths, externalDefaults = useStrict.externalDefaults, indentStr = useStrict.indentStr, strict = useStrict.strict, useStrict = useStrict.useStrict;
-		var useStrictPragma = useStrict ? (" 'use strict';") : '';
-		var intro;
+	var umd_umdIntro = umdIntro;
+	function umdIntro(_ref) {
+		var amdName = _ref.amdName;
+		var name = _ref.name;
+		var hasExports = _ref.hasExports;
+		var imports = _ref.imports;
+		var absolutePaths = _ref.absolutePaths;
+		var externalDefaults = _ref.externalDefaults;
+		var indentStr = _ref.indentStr;
+		var strict = _ref.strict;
+		var useStrict = _ref.useStrict;
 
-		if ( !hasExports && !imports.length ) {
-			intro =
-				(("(function (factory) {\
-\n				!(typeof exports === 'object' && typeof module !== 'undefined') &&\
-\n				typeof define === 'function' && define.amd ? define(" + (processName(amdName))) + ("factory) :\
-\n				factory()\
-\n			}(function () {" + useStrictPragma) + "\
-\n\
-\n			");
-		}
+		var useStrictPragma = useStrict ? ' \'use strict\';' : '';
+		var intro = undefined;
 
-		else {
-			var ids = (names = getImportSummary({ imports: imports, name: amdName, absolutePaths: absolutePaths })).ids, paths = names.paths, names = names.names;
+		if (!hasExports && !imports.length) {
+			intro = '(function (factory) {\n\t\t\t\t!(typeof exports === \'object\' && typeof module !== \'undefined\') &&\n\t\t\t\ttypeof define === \'function\' && define.amd ? define(' + amd_processName(amdName) + 'factory) :\n\t\t\t\tfactory()\n\t\t\t}(function () {' + useStrictPragma + '\n\n\t\t\t';
+		} else {
+			var _getImportSummary = amd_getImportSummary({ imports: imports, name: amdName, absolutePaths: absolutePaths });
+
+			var ids = _getImportSummary.ids;
+			var paths = _getImportSummary.paths;
+			var names = _getImportSummary.names;
 
-			var amdExport, cjsExport, globalExport, defaultsBlock;
+			var amdExport = undefined,
+			    cjsExport = undefined,
+			    globalExport = undefined,
+			    defaultsBlock = undefined;
 
-			if ( strict ) {
-				cjsExport = (("factory(" + (( hasExports ? [ 'exports' ] : [] ).concat( paths.map( req ) ).join( ', ' ))) + ")");
-				var globalDeps = ( hasExports ? [ (("(global." + name) + " = {})") ] : [] ).concat( names.map( globalify ) ).join( ', ' );
-				globalExport = (("factory(" + globalDeps) + ")");
+			if (strict) {
+				cjsExport = 'factory(' + (hasExports ? ['exports'] : []).concat(paths.map(req)).join(', ') + ')';
+				var globalDeps = (hasExports ? ['(global.' + name + ' = {})'] : []).concat(names.map(globalify)).join(', ');
+				globalExport = 'factory(' + globalDeps + ')';
 
-				if ( hasExports ) {
-					ids.unshift( 'exports' );
-					names.unshift( 'exports' );
+				if (hasExports) {
+					ids.unshift('exports');
+					names.unshift('exports');
 				}
 
-				amdExport = (("define(" + (processName(amdName))) + ("" + (processIds(ids))) + "factory)");
+				amdExport = 'define(' + amd_processName(amdName) + '' + amd_processIds(ids) + 'factory)';
 				defaultsBlock = '';
-				if ( externalDefaults && externalDefaults.length > 0 ) {
-					defaultsBlock = externalDefaults.map( function(x )
-						{return '\t' + ( x.needsNamed ? (("var " + (x.name)) + "__default") : x.name ) +
-							((" = ('default' in " + (x.name)) + (" ? " + (x.name)) + ("['default'] : " + (x.name)) + ");")}
-				).join('\n') + '\n\n';
+				if (externalDefaults && externalDefaults.length > 0) {
+					defaultsBlock = externalDefaults.map(function (x) {
+						return '\t' + (x.needsNamed ? 'var ' + x.name + '__default' : x.name) + (' = (\'default\' in ' + x.name + ' ? ' + x.name + '[\'default\'] : ' + x.name + ');');
+					}).join('\n') + '\n\n';
 				}
 			} else {
-				amdExport = (("define(" + (processName(amdName))) + ("" + (processIds(ids))) + "factory)");
-				cjsExport = ( hasExports ? 'module.exports = ' : '' ) + (("factory(" + (paths.map( req ).join( ', ' ))) + ")");
-				globalExport = ( hasExports ? (("global." + name) + " = ") : '' ) + (("factory(" + (names.map( globalify ).join( ', ' ))) + ")");
+				amdExport = 'define(' + amd_processName(amdName) + '' + amd_processIds(ids) + 'factory)';
+				cjsExport = (hasExports ? 'module.exports = ' : '') + ('factory(' + paths.map(req).join(', ') + ')');
+				globalExport = (hasExports ? 'global.' + name + ' = ' : '') + ('factory(' + names.map(globalify).join(', ') + ')');
 
 				defaultsBlock = '';
 			}
 
-			intro =
-				(("(function (global, factory) {\
-\n				typeof exports === 'object' && typeof module !== 'undefined' ? " + cjsExport) + (" :\
-\n				typeof define === 'function' && define.amd ? " + amdExport) + (" :\
-\n				" + globalExport) + ("\
-\n			}(this, function (" + (names.join( ', ' ))) + (") {" + useStrictPragma) + ("\
-\n\
-\n			" + defaultsBlock) + "");
-
+			intro = '(function (global, factory) {\n\t\t\t\ttypeof exports === \'object\' && typeof module !== \'undefined\' ? ' + cjsExport + ' :\n\t\t\t\ttypeof define === \'function\' && define.amd ? ' + amdExport + ' :\n\t\t\t\t' + globalExport + '\n\t\t\t}(this, function (' + names.join(', ') + ') {' + useStrictPragma + '\n\n\t\t\t' + defaultsBlock;
 		}
 
-		return intro.replace( /^\t\t\t/gm, '' ).replace( /\t/g, indentStr );
+		return intro.replace(/^\t\t\t/gm, '').replace(/\t/g, indentStr);
 	}
 
-	var EsperantoError = function ( message, data ) {
+	var EsperantoError = function (message, data) {
 		var prop;
 
 		this.message = message;
-		this.stack = (new Error()).stack;
+		this.stack = new Error().stack;
 
-		for ( prop in data ) {
-			if ( data.hasOwnProperty( prop ) ) {
-				this[ prop ] = data[ prop ];
+		for (prop in data) {
+			if (data.hasOwnProperty(prop)) {
+				this[prop] = data[prop];
 			}
 		}
 	};
@@ -2013,22 +2088,24 @@
 
 	var utils_EsperantoError = EsperantoError;
 
-	function requireName ( options ) {
-		if ( !options.name ) {
-			throw new utils_EsperantoError( 'You must supply a `name` option for UMD modules', {
+	var umd_requireName = requireName;
+	function requireName(options) {
+		if (!options.name) {
+			throw new utils_EsperantoError('You must supply a `name` option for UMD modules', {
 				code: 'MISSING_NAME'
 			});
 		}
 	}
 
-	function defaultsMode_umd__umd ( mod, options ) {
-		requireName( options );
+	var defaultsMode_umd = defaultsMode_umd__umd;
+	function defaultsMode_umd__umd(mod, options) {
+		umd_requireName(options);
 
-		mod.imports.forEach( function(x ) {
-			mod.body.remove( x.start, x.next );
+		mod.imports.forEach(function (x) {
+			mod.body.remove(x.start, x.next);
 		});
 
-		var intro = umdIntro({
+		var intro = umd_umdIntro({
 			hasExports: mod.exports.length > 0,
 			imports: mod.imports,
 			amdName: options.amdName,
@@ -2038,56 +2115,60 @@
 			useStrict: options.useStrict !== false
 		});
 
-		transformExportDeclaration( mod.exports[0], mod.body );
+		utils_transformExportDeclaration(mod.exports[0], mod.body);
 
-		mod.body.indent().prepend( intro ).trimLines().append( '\n\n}));' );
+		mod.body.indent().prepend(intro).trimLines().append('\n\n}));');
 
-		return packageResult( mod, mod.body, options, 'toUmd' );
+		return utils_packageResult(mod, mod.body, options, 'toUmd');
 	}
 
 	var defaultsMode = {
-		amd: defaultsMode_amd__amd,
-		cjs: defaultsMode_cjs__cjs,
-		umd: defaultsMode_umd__umd
+		amd: defaultsMode_amd,
+		cjs: defaultsMode_cjs,
+		umd: defaultsMode_umd
 	};
 
-	function gatherImports ( imports ) {
+	var utils_gatherImports = gatherImports;
+
+	function gatherImports(imports) {
 		var chains = {};
 		var identifierReplacements = {};
 
-		imports.forEach( function(x ) {
-			x.specifiers.forEach( function(s ) {
-				if ( s.isBatch ) {
+		imports.forEach(function (x) {
+			x.specifiers.forEach(function (s) {
+				if (s.isBatch) {
 					return;
 				}
 
 				var name = s.as;
-				var replacement = x.name + ( s.isDefault ? ("['default']") : ("." + (s.name)) );
+				var replacement = x.name + (s.isDefault ? "['default']" : "." + s.name);
 
-				if ( !x.passthrough ) {
-					identifierReplacements[ name ] = replacement;
+				if (!x.passthrough) {
+					identifierReplacements[name] = replacement;
 				}
 
-				chains[ name ] = replacement;
+				chains[name] = replacement;
 			});
 		});
 
-		return [ chains, identifierReplacements ];
+		return [chains, identifierReplacements];
 	}
 
-	function getExportNames ( exports ) {
+	var utils_getExportNames = getExportNames;
+
+	function getExportNames(exports) {
 		var result = {};
 
-		exports.forEach( function(x ) {
-			if ( x.isDefault ) return;
+		exports.forEach(function (x) {
+			if (x.isDefault) return;
 
-			if ( x.hasDeclaration ) {
-				result[ x.name ] = x.name;
+			if (x.hasDeclaration) {
+				result[x.name] = x.name;
 				return;
 			}
 
-			x.specifiers.forEach( function(s ) {
-				result[ s.name ] = s.as;
+			x.specifiers.forEach(function (s) {
+				result[s.name] = s.as;
 			});
 		});
 
@@ -2102,128 +2183,136 @@
 	 * @param {array} imports - the array of imports
 	 * @returns {array} [ importedBindings, importedNamespaces ]
 	 */
-	function getReadOnlyIdentifiers ( imports ) {
-		var importedBindings = {}, importedNamespaces = {};
+	var utils_getReadOnlyIdentifiers = getReadOnlyIdentifiers;
+
+	function getReadOnlyIdentifiers(imports) {
+		var importedBindings = {},
+		    importedNamespaces = {};
 
-		imports.forEach( function(x ) {
-			if ( x.passthrough ) return;
+		imports.forEach(function (x) {
+			if (x.passthrough) return;
 
-			x.specifiers.forEach( function(s ) {
-				if ( s.isBatch ) {
-					importedNamespaces[ s.as ] = true;
+			x.specifiers.forEach(function (s) {
+				if (s.isBatch) {
+					importedNamespaces[s.as] = true;
 				} else {
-					importedBindings[ s.as ] = true;
+					importedBindings[s.as] = true;
 				}
 			});
 		});
 
-		return [ importedBindings, importedNamespaces ];
+		return [importedBindings, importedNamespaces];
 	}
 
+	var ast_disallowIllegalReassignment = disallowIllegalReassignment;
 	var bindingMessage = 'Cannot reassign imported binding ',
-		namespaceMessage = 'Cannot reassign imported binding of namespace ';
+	    namespaceMessage = 'Cannot reassign imported binding of namespace ';
+	function disallowIllegalReassignment(node, importedBindings, importedNamespaces, scope) {
+		var assignee = undefined,
+		    isNamespaceAssignment = undefined;
 
-	function disallowIllegalReassignment ( node, importedBindings, importedNamespaces, scope ) {
-		var assignee, isNamespaceAssignment;
-
-		if ( node.type === 'AssignmentExpression' ) {
+		if (node.type === 'AssignmentExpression') {
 			assignee = node.left;
-		} else if ( node.type === 'UpdateExpression' ) {
+		} else if (node.type === 'UpdateExpression') {
 			assignee = node.argument;
 		} else {
 			return; // not an assignment
 		}
 
-		if ( assignee.type === 'MemberExpression' ) {
+		if (assignee.type === 'MemberExpression') {
 			assignee = assignee.object;
 			isNamespaceAssignment = true;
 		}
 
-		if ( assignee.type !== 'Identifier' ) {
+		if (assignee.type !== 'Identifier') {
 			return; // not assigning to a binding
 		}
 
 		var name = assignee.name;
 
-		if ( utils_hasOwnProp.call( isNamespaceAssignment ? importedNamespaces : importedBindings, name ) && !scope.contains( name ) ) {
-			throw new Error( ( isNamespaceAssignment ? namespaceMessage : bindingMessage ) + '`' + name + '`' );
+		if (utils_hasOwnProp.call(isNamespaceAssignment ? importedNamespaces : importedBindings, name) && !scope.contains(name)) {
+			throw new Error((isNamespaceAssignment ? namespaceMessage : bindingMessage) + '`' + name + '`');
 		}
 	}
 
-	function replaceIdentifiers ( body, node, identifierReplacements, scope ) {
+	var ast_replaceIdentifiers = replaceIdentifiers;
+	function replaceIdentifiers(body, node, identifierReplacements, scope) {
 		var name = node.name;
-		var replacement = utils_hasOwnProp.call( identifierReplacements, name ) && identifierReplacements[ name ];
+		var replacement = utils_hasOwnProp.call(identifierReplacements, name) && identifierReplacements[name];
 
 		// TODO unchanged identifiers shouldn't have got this far -
 		// remove the `replacement !== name` safeguard once that's the case
-		if ( replacement && replacement !== name && !scope.contains( name, true ) ) {
+		if (replacement && replacement !== name && !scope.contains(name, true)) {
 			// rewrite
-			body.replace( node.start, node.end, replacement );
+			body.replace(node.start, node.end, replacement);
 		}
 	}
 
-	function rewriteExportAssignments ( body, node, parent, exports, scope, capturedUpdates ) {
-		var assignee;
+	var ast_rewriteExportAssignments = rewriteExportAssignments;
+	function rewriteExportAssignments(body, node, parent, exports, scope, capturedUpdates) {
+		var assignee = undefined;
 
-		if ( node.type === 'AssignmentExpression' ) {
+		if (node.type === 'AssignmentExpression') {
 			assignee = node.left;
-		} else if ( node.type === 'UpdateExpression' ) {
+		} else if (node.type === 'UpdateExpression') {
 			assignee = node.argument;
 		} else {
 			return; // not an assignment
 		}
 
-		if ( assignee.type !== 'Identifier' ) {
+		if (assignee.type !== 'Identifier') {
 			return;
 		}
 
 		var name = assignee.name;
 
-		if ( scope.contains( name, true ) ) {
+		if (scope.contains(name, true)) {
 			return; // shadows an export
 		}
 
-		if ( exports && utils_hasOwnProp.call( exports, name ) ) {
-			var exportAs = exports[ name ];
+		if (exports && utils_hasOwnProp.call(exports, name)) {
+			var exportAs = exports[name];
 
-			if ( !!capturedUpdates ) {
+			if (!!capturedUpdates) {
 				capturedUpdates.push({ name: name, exportAs: exportAs });
 				return;
 			}
 
 			// special case - increment/decrement operators
-			if ( node.operator === '++' || node.operator === '--' ) {
-				var prefix = ("");
-				var suffix = ((", exports." + exportAs) + (" = " + name) + "");
-				if ( parent.type !== 'ExpressionStatement' ) {
-					if ( !node.prefix ) {
-						suffix += ((", " + name) + (" " + (node.operator === '++' ? '-' : '+')) + " 1");
+			if (node.operator === '++' || node.operator === '--') {
+				var prefix = '';
+				var suffix = ', exports.' + exportAs + ' = ' + name;
+				if (parent.type !== 'ExpressionStatement') {
+					if (!node.prefix) {
+						suffix += ', ' + name + ' ' + (node.operator === '++' ? '-' : '+') + ' 1';
 					}
-					prefix += ("( ");
-					suffix += (" )");
+					prefix += '( ';
+					suffix += ' )';
 				}
-				body.insert( node.start, prefix );
-				body.insert( node.end, suffix );
+				body.insert(node.start, prefix);
+				body.insert(node.end, suffix);
 			} else {
-				body.insert( node.start, (("exports." + exportAs) + " = ") );
+				body.insert(node.start, 'exports.' + exportAs + ' = ');
 			}
 		}
 	}
 
-	function traverseAst ( ast, body, identifierReplacements, importedBindings, importedNamespaces, exportNames ) {
+	var traverse = traverseAst;
+
+	function traverseAst(ast, body, identifierReplacements, importedBindings, importedNamespaces, exportNames) {
 		var scope = ast._scope;
 		var blockScope = ast._blockScope;
 		var capturedUpdates = null;
 		var previousCapturedUpdates = null;
 
-		walk( ast, {
-			enter: function ( node, parent ) {
+		ast_walk(ast, {
+			enter: function (node, parent) {
 				// we're only interested in references, not property names etc
-				if ( node._skip ) return this.skip();
+				if (node._skip) return this.skip();
 
-				if ( node._scope ) {
+				if (node._scope) {
 					scope = node._scope;
-				} else if ( node._blockScope ) {
+				} else if (node._blockScope) {
 					blockScope = node._blockScope;
 				}
 
@@ -2233,101 +2322,110 @@
 				// normally would) because that would be syntactically invalid. Instead,
 				// we capture the change and update the export (and any others) after the
 				// variable declaration
-				if ( node.type === 'VariableDeclaration' ) {
+				if (node.type === 'VariableDeclaration') {
 					previousCapturedUpdates = capturedUpdates;
 					capturedUpdates = [];
 					return;
 				}
 
-				disallowIllegalReassignment( node, importedBindings, importedNamespaces, scope );
+				ast_disallowIllegalReassignment(node, importedBindings, importedNamespaces, scope);
 
 				// Rewrite assignments to exports inside functions, to keep bindings live.
 				// This call may mutate `capturedUpdates`, which is used elsewhere
-				if ( scope !== ast._scope ) {
-					rewriteExportAssignments( body, node, parent, exportNames, scope, capturedUpdates );
+				if (scope !== ast._scope) {
+					ast_rewriteExportAssignments(body, node, parent, exportNames, scope, capturedUpdates);
 				}
 
-				if ( node.type === 'Identifier' && parent.type !== 'FunctionExpression' ) {
-					replaceIdentifiers( body, node, identifierReplacements, scope );
+				if (node.type === 'Identifier' && parent.type !== 'FunctionExpression') {
+					ast_replaceIdentifiers(body, node, identifierReplacements, scope);
 				}
 
 				// Replace top-level this with undefined ES6 8.1.1.5.4
-				if ( node.type === 'ThisExpression' && node._topLevel ) {
-					body.replace( node.start, node.end, 'undefined' );
+				if (node.type === 'ThisExpression' && node._topLevel) {
+					body.replace(node.start, node.end, 'undefined');
 				}
 			},
 
-			leave: function ( node ) {
+			leave: function (node) {
 				// Special case - see above
-				if ( node.type === 'VariableDeclaration' ) {
-					if ( capturedUpdates.length ) {
-						body.insert( node.end, capturedUpdates.map( exportCapturedUpdate ).join( '' ) );
+				if (node.type === 'VariableDeclaration') {
+					if (capturedUpdates.length) {
+						body.insert(node.end, capturedUpdates.map(exportCapturedUpdate).join(''));
 					}
 
 					capturedUpdates = previousCapturedUpdates;
 				}
 
-				if ( node._scope ) {
+				if (node._scope) {
 					scope = scope.parent;
-				} else if ( node._blockScope ) {
+				} else if (node._blockScope) {
 					blockScope = blockScope.parent;
 				}
 			}
 		});
 	}
 
-	function exportCapturedUpdate ( c ) {
-		return ((" exports." + (c.exportAs)) + (" = " + (c.name)) + ";");
+	function exportCapturedUpdate(c) {
+		return ' exports.' + c.exportAs + ' = ' + c.name + ';';
 	}
 
-	function transformBody ( mod, body, options ) {
-		var chains = (identifierReplacements = gatherImports( mod.imports ))[0], identifierReplacements = identifierReplacements[1];
-		var exportNames = getExportNames( mod.exports );
+	var utils_transformBody = transformBody;
+
+	function transformBody(mod, body, options) {
+		var _gatherImports = utils_gatherImports(mod.imports);
+
+		var chains = _gatherImports[0];
+		var identifierReplacements = _gatherImports[1];
+
+		var exportNames = utils_getExportNames(mod.exports);
+
+		var _getReadOnlyIdentifiers = utils_getReadOnlyIdentifiers(mod.imports);
 
-		var importedBindings = (importedNamespaces = getReadOnlyIdentifiers( mod.imports ))[0], importedNamespaces = importedNamespaces[1];
+		var importedBindings = _getReadOnlyIdentifiers[0];
+		var importedNamespaces = _getReadOnlyIdentifiers[1];
 
 		// ensure no conflict with `exports`
-		identifierReplacements.exports = deconflict( 'exports', mod.ast._declared );
+		identifierReplacements.exports = deconflict('exports', mod.ast._declared);
 
-		traverseAst( mod.ast, body, identifierReplacements, importedBindings, importedNamespaces, exportNames );
+		traverse(mod.ast, body, identifierReplacements, importedBindings, importedNamespaces, exportNames);
 
 		// Remove import statements from the body of the module
-		mod.imports.forEach( function(x ) {
-			body.remove( x.start, x.next );
+		mod.imports.forEach(function (x) {
+			body.remove(x.start, x.next);
 		});
 
 		// Prepend require() statements (CommonJS output only)
-		if ( options.header ) {
-			body.prepend( options.header + '\n\n' );
+		if (options.header) {
+			body.prepend(options.header + '\n\n');
 		}
 
 		// Remove export statements (but keep declarations)
-		mod.exports.forEach( function(x ) {
-			if ( x.isDefault ) {
-				if ( /^named/.test( x.type ) ) {
+		mod.exports.forEach(function (x) {
+			if (x.isDefault) {
+				if (/^named/.test(x.type)) {
 					// export default function answer () { return 42; }
-					body.remove( x.start, x.valueStart );
-					body.insert( x.end, (("\nexports['default'] = " + (x.name)) + ";") );
+					body.remove(x.start, x.valueStart);
+					body.insert(x.end, '\nexports[\'default\'] = ' + x.name + ';');
 				} else {
 					// everything else
-					body.replace( x.start, x.valueStart, 'exports[\'default\'] = ' );
+					body.replace(x.start, x.valueStart, 'exports[\'default\'] = ');
 				}
-			}
-
-			else {
-				switch ( x.type ) {
+			} else {
+				switch (x.type) {
 					case 'varDeclaration': // export var answer = 42; (or let)
-					case 'namedFunction':  // export function answer () {...}
-					case 'namedClass':     // export class answer {...}
-						body.remove( x.start, x.valueStart );
+					case 'namedFunction': // export function answer () {...}
+					case 'namedClass':
+						// export class answer {...}
+						body.remove(x.start, x.valueStart);
 						break;
 
-					case 'named':          // export { foo, bar };
-						body.remove( x.start, x.next );
+					case 'named':
+						// export { foo, bar };
+						body.remove(x.start, x.next);
 						break;
 
 					default:
-						body.replace( x.start, x.valueStart, 'exports[\'default\'] = ' );
+						body.replace(x.start, x.valueStart, 'exports[\'default\'] = ');
 				}
 			}
 		});
@@ -2336,50 +2434,51 @@
 		var earlyExports = [];
 		var lateExports = [];
 
-		Object.keys( exportNames ).forEach( function(name ) {
-			var exportAs = exportNames[ name ];
+		Object.keys(exportNames).forEach(function (name) {
+			var exportAs = exportNames[name];
 
-			if ( chains.hasOwnProperty( name ) ) {
+			if (chains.hasOwnProperty(name)) {
 				// special case - a binding from another module
-				if ( !options._evilES3SafeReExports ) {
-					earlyExports.push( (("Object.defineProperty(exports, '" + exportAs) + ("', { enumerable: true, get: function () { return " + (chains[name])) + "; }});") );
+				if (!options._evilES3SafeReExports) {
+					earlyExports.push('Object.defineProperty(exports, \'' + exportAs + '\', { enumerable: true, get: function () { return ' + chains[name] + '; }});');
 				} else {
-					lateExports.push( (("exports." + exportAs) + (" = " + (chains[name])) + ";") );
+					lateExports.push('exports.' + exportAs + ' = ' + chains[name] + ';');
 				}
-			} else if ( ~mod.ast._topLevelFunctionNames.indexOf( name ) ) {
+			} else if (~mod.ast._topLevelFunctionNames.indexOf(name)) {
 				// functions should be exported early, in
 				// case of cyclic dependencies
-				earlyExports.push( (("exports." + exportAs) + (" = " + name) + ";") );
+				earlyExports.push('exports.' + exportAs + ' = ' + name + ';');
 			} else {
-				lateExports.push( (("exports." + exportAs) + (" = " + name) + ";") );
+				lateExports.push('exports.' + exportAs + ' = ' + name + ';');
 			}
 		});
 
 		// Function exports should be exported immediately after 'use strict'
-		if ( earlyExports.length ) {
-			body.trim().prepend( earlyExports.join( '\n' ) + '\n\n' );
+		if (earlyExports.length) {
+			body.trim().prepend(earlyExports.join('\n') + '\n\n');
 		}
 
 		// Everything else should be exported at the end
-		if ( lateExports.length ) {
-			body.trim().append( '\n\n' + lateExports.join( '\n' ) );
+		if (lateExports.length) {
+			body.trim().append('\n\n' + lateExports.join('\n'));
 		}
 
-		if ( options.intro && options.outro ) {
-			body.indent().prepend( options.intro ).trimLines().append( options.outro );
+		if (options.intro && options.outro) {
+			body.indent().prepend(options.intro).trimLines().append(options.outro);
 		}
 	}
 
-	function deconflict ( name, declared ) {
-		while ( utils_hasOwnProp.call( declared, name ) ) {
+	function deconflict(name, declared) {
+		while (utils_hasOwnProp.call(declared, name)) {
 			name = '_' + name;
 		}
 
 		return name;
 	}
 
-	function strictMode_amd__amd ( mod, options ) {
-		var intro = amdIntro({
+	var strictMode_amd = strictMode_amd__amd;
+	function strictMode_amd__amd(mod, options) {
+		var intro = amd_amdIntro({
 			name: options.amdName,
 			absolutePaths: options.absolutePaths,
 			imports: mod.imports,
@@ -2388,47 +2487,49 @@
 			useStrict: options.useStrict !== false
 		});
 
-		transformBody( mod, mod.body, {
+		utils_transformBody(mod, mod.body, {
 			intro: intro,
 			outro: '\n\n});',
 			_evilES3SafeReExports: options._evilES3SafeReExports
 		});
 
-		return packageResult( mod, mod.body, options, 'toAmd' );
+		return utils_packageResult(mod, mod.body, options, 'toAmd');
 	}
 
-	function strictMode_cjs__cjs ( mod, options ) {
+	var strictMode_cjs = strictMode_cjs__cjs;
+	function strictMode_cjs__cjs(mod, options) {
 		var seen = {};
 
 		// Create block of require statements
-		var importBlock = mod.imports.map( function(x ) {
-			if ( !utils_hasOwnProp.call( seen, x.path ) ) {
-				seen[ x.path ] = true;
+		var importBlock = mod.imports.map(function (x) {
+			if (!utils_hasOwnProp.call(seen, x.path)) {
+				seen[x.path] = true;
 
-				if ( x.isEmpty ) {
-					return (("" + (req(x.path))) + ";");
+				if (x.isEmpty) {
+					return '' + req(x.path) + ';';
 				}
 
-				return (("var " + (x.name)) + (" = " + (req(x.path))) + ";");
+				return 'var ' + x.name + ' = ' + req(x.path) + ';';
 			}
-		}).filter( Boolean ).join( '\n' );
+		}).filter(Boolean).join('\n');
 
-		transformBody( mod, mod.body, {
+		utils_transformBody(mod, mod.body, {
 			header: importBlock,
 			_evilES3SafeReExports: options._evilES3SafeReExports
 		});
 
-		if ( options.useStrict !== false ) {
-			mod.body.prepend( "'use strict';\n\n" ).trimLines();
+		if (options.useStrict !== false) {
+			mod.body.prepend('\'use strict\';\n\n').trimLines();
 		}
 
-		return packageResult( mod, mod.body, options, 'toCjs' );
+		return utils_packageResult(mod, mod.body, options, 'toCjs');
 	}
 
-	function strictMode_umd__umd ( mod, options ) {
-		requireName( options );
+	var strictMode_umd = strictMode_umd__umd;
+	function strictMode_umd__umd(mod, options) {
+		umd_requireName(options);
 
-		var intro = umdIntro({
+		var intro = umd_umdIntro({
 			hasExports: mod.exports.length > 0,
 			imports: mod.imports,
 			amdName: options.amdName,
@@ -2439,19 +2540,19 @@
 			useStrict: options.useStrict !== false
 		});
 
-		transformBody( mod, mod.body, {
+		utils_transformBody(mod, mod.body, {
 			intro: intro,
 			outro: '\n\n}));',
 			_evilES3SafeReExports: options._evilES3SafeReExports
 		});
 
-		return packageResult( mod, mod.body, options, 'toUmd' );
+		return utils_packageResult(mod, mod.body, options, 'toUmd');
 	}
 
 	var strictMode = {
-		amd: strictMode_amd__amd,
-		cjs: strictMode_cjs__cjs,
-		umd: strictMode_umd__umd
+		amd: strictMode_amd,
+		cjs: strictMode_cjs,
+		umd: strictMode_umd
 	};
 
 	// TODO rewrite with named imports/exports
@@ -2460,50 +2561,53 @@
 		strictMode: strictMode
 	};
 
-	function builders_defaultsMode_amd__amd ( bundle, options ) {
-		var defaultName = bundle.entryModule.identifierReplacements.default;
-		if ( defaultName ) {
-			bundle.body.append( (("\n\nreturn " + defaultName) + ";") );
+	var builders_defaultsMode_amd = builders_defaultsMode_amd__amd;
+	function builders_defaultsMode_amd__amd(bundle, options) {
+		var defaultName = bundle.entryModule.identifierReplacements['default'];
+		if (defaultName) {
+			bundle.body.append('\n\nreturn ' + defaultName + ';');
 		}
 
-		var intro = amdIntro({
+		var intro = amd_amdIntro({
 			name: options.amdName,
 			imports: bundle.externalModules,
 			indentStr: bundle.body.getIndentString(),
 			useStrict: options.useStrict !== false
 		});
 
-		bundle.body.indent().prepend( intro ).trimLines().append( '\n\n});' );
-		return packageResult( bundle, bundle.body, options, 'toAmd', true );
+		bundle.body.indent().prepend(intro).trimLines().append('\n\n});');
+		return utils_packageResult(bundle, bundle.body, options, 'toAmd', true);
 	}
 
-	function builders_defaultsMode_cjs__cjs ( bundle, options ) {
-		var importBlock = bundle.externalModules.map( function(x ) {
-			return (("var " + (x.name)) + (" = " + (req(x.id))) + ";");
-		}).join( '\n' );
+	var builders_defaultsMode_cjs = builders_defaultsMode_cjs__cjs;
+	function builders_defaultsMode_cjs__cjs(bundle, options) {
+		var importBlock = bundle.externalModules.map(function (x) {
+			return 'var ' + x.name + ' = ' + req(x.id) + ';';
+		}).join('\n');
 
-		if ( importBlock ) {
-			bundle.body.prepend( importBlock + '\n\n' );
+		if (importBlock) {
+			bundle.body.prepend(importBlock + '\n\n');
 		}
 
-		var defaultName = bundle.entryModule.identifierReplacements.default;
-		if ( defaultName ) {
-			bundle.body.append( (("\n\nmodule.exports = " + defaultName) + ";") );
+		var defaultName = bundle.entryModule.identifierReplacements['default'];
+		if (defaultName) {
+			bundle.body.append('\n\nmodule.exports = ' + defaultName + ';');
 		}
 
-		if ( options.useStrict !== false ) {
-			bundle.body.prepend("'use strict';\n\n").trimLines();
+		if (options.useStrict !== false) {
+			bundle.body.prepend('\'use strict\';\n\n').trimLines();
 		}
 
-		return packageResult( bundle, bundle.body, options, 'toCjs', true );
+		return utils_packageResult(bundle, bundle.body, options, 'toCjs', true);
 	}
 
-	function builders_defaultsMode_umd__umd ( bundle, options ) {
-		requireName( options );
+	var builders_defaultsMode_umd = builders_defaultsMode_umd__umd;
+	function builders_defaultsMode_umd__umd(bundle, options) {
+		umd_requireName(options);
 
 		var entry = bundle.entryModule;
 
-		var intro = umdIntro({
+		var intro = umd_umdIntro({
 			hasExports: entry.exports.length > 0,
 			imports: bundle.externalModules,
 			amdName: options.amdName,
@@ -2512,49 +2616,53 @@
 			useStrict: options.useStrict !== false
 		});
 
-		if ( entry.defaultExport ) {
-			bundle.body.append( (("\n\nreturn " + (entry.identifierReplacements.default)) + ";") );
+		if (entry.defaultExport) {
+			bundle.body.append('\n\nreturn ' + entry.identifierReplacements['default'] + ';');
 		}
 
-		bundle.body.indent().prepend( intro ).trimLines().append('\n\n}));');
+		bundle.body.indent().prepend(intro).trimLines().append('\n\n}));');
 
-		return packageResult( bundle, bundle.body, options, 'toUmd', true );
+		return utils_packageResult(bundle, bundle.body, options, 'toUmd', true);
 	}
 
 	var builders_defaultsMode = {
-		amd: builders_defaultsMode_amd__amd,
-		cjs: builders_defaultsMode_cjs__cjs,
-		umd: builders_defaultsMode_umd__umd
+		amd: builders_defaultsMode_amd,
+		cjs: builders_defaultsMode_cjs,
+		umd: builders_defaultsMode_umd
 	};
 
-	function getExportBlock ( entry ) {
-		var name = entry.identifierReplacements.default;
-		return (("exports['default'] = " + name) + ";");
+	var utils_getExportBlock = getExportBlock;
+
+	function getExportBlock(entry) {
+		var name = entry.identifierReplacements["default"];
+		return "exports['default'] = " + name + ";";
 	}
 
-	function builders_strictMode_amd__amd ( bundle, options ) {
-		var externalDefaults = bundle.externalModules.filter( builders_strictMode_amd__needsDefault );
+	var builders_strictMode_amd = builders_strictMode_amd__amd;
+
+	function builders_strictMode_amd__amd(bundle, options) {
+		var externalDefaults = bundle.externalModules.filter(builders_strictMode_amd__needsDefault);
 		var entry = bundle.entryModule;
 
-		if ( externalDefaults.length ) {
-			var defaultsBlock = externalDefaults.map( function(x ) {
+		if (externalDefaults.length) {
+			var defaultsBlock = externalDefaults.map(function (x) {
 				// Case 1: default is used, and named is not
-				if ( !x.needsNamed ) {
-					return (("" + (x.name)) + (" = ('default' in " + (x.name)) + (" ? " + (x.name)) + ("['default'] : " + (x.name)) + ");");
+				if (!x.needsNamed) {
+					return '' + x.name + ' = (\'default\' in ' + x.name + ' ? ' + x.name + '[\'default\'] : ' + x.name + ');';
 				}
 
 				// Case 2: both default and named are used
-				return (("var " + (x.name)) + ("__default = ('default' in " + (x.name)) + (" ? " + (x.name)) + ("['default'] : " + (x.name)) + ");");
-			}).join( '\n' );
+				return 'var ' + x.name + '__default = (\'default\' in ' + x.name + ' ? ' + x.name + '[\'default\'] : ' + x.name + ');';
+			}).join('\n');
 
-			bundle.body.prepend( defaultsBlock + '\n\n' );
+			bundle.body.prepend(defaultsBlock + '\n\n');
 		}
 
-		if ( entry.defaultExport ) {
-			bundle.body.append( '\n\n' + getExportBlock( entry ) );
+		if (entry.defaultExport) {
+			bundle.body.append('\n\n' + utils_getExportBlock(entry));
 		}
 
-		var intro = amdIntro({
+		var intro = amd_amdIntro({
 			name: options.amdName,
 			imports: bundle.externalModules,
 			hasExports: entry.exports.length,
@@ -2562,53 +2670,54 @@
 			useStrict: options.useStrict !== false
 		});
 
-		bundle.body.indent().prepend( intro ).trimLines().append( '\n\n});' );
-		return packageResult( bundle, bundle.body, options, 'toAmd', true );
+		bundle.body.indent().prepend(intro).trimLines().append('\n\n});');
+		return utils_packageResult(bundle, bundle.body, options, 'toAmd', true);
 	}
 
-	function builders_strictMode_amd__needsDefault ( externalModule ) {
+	function builders_strictMode_amd__needsDefault(externalModule) {
 		return externalModule.needsDefault;
 	}
 
-	function builders_strictMode_cjs__cjs ( bundle, options ) {
+	var builders_strictMode_cjs = builders_strictMode_cjs__cjs;
+	function builders_strictMode_cjs__cjs(bundle, options) {
 		var entry = bundle.entryModule;
 
-		var importBlock = bundle.externalModules.map( function(x ) {
-			var statement = (("var " + (x.name)) + (" = " + (req(x.id))) + ";");
+		var importBlock = bundle.externalModules.map(function (x) {
+			var statement = 'var ' + x.name + ' = ' + req(x.id) + ';';
 
-			if ( x.needsDefault ) {
-				statement += '\n' +
-					( x.needsNamed ? (("var " + (x.name)) + "__default") : x.name ) +
-					((" = ('default' in " + (x.name)) + (" ? " + (x.name)) + ("['default'] : " + (x.name)) + ");");
+			if (x.needsDefault) {
+				statement += '\n' + (x.needsNamed ? 'var ' + x.name + '__default' : x.name) + (' = (\'default\' in ' + x.name + ' ? ' + x.name + '[\'default\'] : ' + x.name + ');');
 			}
 
 			return statement;
-		}).join( '\n' );
+		}).join('\n');
 
-		if ( importBlock ) {
-			bundle.body.prepend( importBlock + '\n\n' );
+		if (importBlock) {
+			bundle.body.prepend(importBlock + '\n\n');
 		}
 
-		if ( entry.defaultExport ) {
-			bundle.body.append( '\n\n' + getExportBlock( entry ) );
+		if (entry.defaultExport) {
+			bundle.body.append('\n\n' + utils_getExportBlock(entry));
 		}
 
-		if ( options.useStrict !== false ) {
-			bundle.body.prepend("'use strict';\n\n").trimLines();
+		if (options.useStrict !== false) {
+			bundle.body.prepend('\'use strict\';\n\n').trimLines();
 		}
 
-		return packageResult( bundle, bundle.body, options, 'toCjs', true );
+		return utils_packageResult(bundle, bundle.body, options, 'toCjs', true);
 	}
 
-	function builders_strictMode_umd__umd ( bundle, options ) {
-		requireName( options );
+	var builders_strictMode_umd = builders_strictMode_umd__umd;
+
+	function builders_strictMode_umd__umd(bundle, options) {
+		umd_requireName(options);
 
 		var entry = bundle.entryModule;
 
-		var intro = umdIntro({
+		var intro = umd_umdIntro({
 			hasExports: entry.exports.length > 0,
 			imports: bundle.externalModules,
-			externalDefaults: bundle.externalModules.filter( builders_strictMode_umd__needsDefault ),
+			externalDefaults: bundle.externalModules.filter(builders_strictMode_umd__needsDefault),
 			amdName: options.amdName,
 			name: options.name,
 			indentStr: bundle.body.getIndentString(),
@@ -2616,23 +2725,23 @@
 			useStrict: options.useStrict !== false
 		});
 
-		if ( entry.defaultExport ) {
-			bundle.body.append( '\n\n' + getExportBlock( entry ) );
+		if (entry.defaultExport) {
+			bundle.body.append('\n\n' + utils_getExportBlock(entry));
 		}
 
-		bundle.body.indent().prepend( intro ).trimLines().append('\n\n}));');
+		bundle.body.indent().prepend(intro).trimLines().append('\n\n}));');
 
-		return packageResult( bundle, bundle.body, options, 'toUmd', true );
+		return utils_packageResult(bundle, bundle.body, options, 'toUmd', true);
 	}
 
-	function builders_strictMode_umd__needsDefault ( externalModule ) {
+	function builders_strictMode_umd__needsDefault(externalModule) {
 		return externalModule.needsDefault;
 	}
 
 	var builders_strictMode = {
-		amd: builders_strictMode_amd__amd,
-		cjs: builders_strictMode_cjs__cjs,
-		umd: builders_strictMode_umd__umd
+		amd: builders_strictMode_amd,
+		cjs: builders_strictMode_cjs,
+		umd: builders_strictMode_umd
 	};
 
 	// TODO rewrite with named imports/exports
@@ -2641,139 +2750,151 @@
 		strictMode: builders_strictMode
 	};
 
-	function concat ( bundle, options ) {
+	var builders_concat = concat;
+	function concat(bundle, options) {
 		// This bundle must be self-contained - no imports or exports
-		if ( bundle.externalModules.length || bundle.entryModule.exports.length ) {
-			throw new Error( (("bundle.concat() can only be used with bundles that have no imports/exports (imports: [" + (bundle.externalModules.map(function(x){return x.id}).join(', '))) + ("], exports: [" + (bundle.entryModule.exports.join(', '))) + "])") );
+		if (bundle.externalModules.length || bundle.entryModule.exports.length) {
+			throw new Error('bundle.concat() can only be used with bundles that have no imports/exports (imports: [' + bundle.externalModules.map(function (x) {
+				return x.id;
+			}).join(', ') + '], exports: [' + bundle.entryModule.exports.join(', ') + '])');
 		}
 
 		// TODO test these options
-		var intro = 'intro' in options ? options.intro : ("(function () { 'use strict';\n\n");
+		var intro = 'intro' in options ? options.intro : '(function () { \'use strict\';\n\n';
 		var outro = 'outro' in options ? options.outro : '\n\n})();';
-		var indent;
+		var indent = undefined;
 
-		if ( !( 'indent' in options ) || options.indent === true ) {
+		if (!('indent' in options) || options.indent === true) {
 			indent = bundle.body.getIndentString();
 		} else {
 			indent = options.indent || '';
 		}
 
-		bundle.body.trimLines().indent( indent ).prepend( intro ).append( outro );
+		bundle.body.trimLines().indent(indent).prepend(intro).append(outro);
 
-		return packageResult( bundle, bundle.body, options, 'toString', true );
+		return utils_packageResult(bundle, bundle.body, options, 'toString', true);
 	}
 
-	var esperanto__deprecateMessage = 'options.defaultOnly has been deprecated, and is now standard behaviour. To use named imports/exports, pass `strict: true`.';
-	var esperanto__alreadyWarned = false;
+	var deprecateMessage = 'options.defaultOnly has been deprecated, and is now standard behaviour. To use named imports/exports, pass `strict: true`.';
+	var alreadyWarned = false;
 
-	function transpileMethod ( format ) {
-		return function ( source ) {var options = arguments[1];if(options === void 0)options = {};
-			var mod = getStandaloneModule({
+	function transpileMethod(format) {
+		return function (source) {
+			var options = arguments[1] === undefined ? {} : arguments[1];
+
+			var mod = getModule({
 				source: source,
 				getModuleName: options.getModuleName,
 				strict: options.strict
 			});
 
-			if ( 'defaultOnly' in options && !esperanto__alreadyWarned ) {
+			if ('defaultOnly' in options && !alreadyWarned) {
 				// TODO link to a wiki page explaining this, or something
-				console.log( esperanto__deprecateMessage );
-				esperanto__alreadyWarned = true;
+				console.log(deprecateMessage);
+				alreadyWarned = true;
 			}
 
-			if ( options.absolutePaths && !options.amdName ) {
-				throw new Error( 'You must specify an `amdName` in order to use the `absolutePaths` option' );
+			if (options.absolutePaths && !options.amdName) {
+				throw new Error('You must specify an `amdName` in order to use the `absolutePaths` option');
 			}
 
-			var builder;
+			var builder = undefined;
 
-			if ( !options.strict ) {
+			if (!options.strict) {
 				// ensure there are no named imports/exports. TODO link to a wiki page...
-				if ( hasNamedImports( mod ) || hasNamedExports( mod ) ) {
-					throw new Error( 'You must be in strict mode (pass `strict: true`) to use named imports or exports' );
+				if (utils_hasNamedImports(mod) || utils_hasNamedExports(mod)) {
+					throw new Error('You must be in strict mode (pass `strict: true`) to use named imports or exports');
 				}
 
-				builder = moduleBuilders.defaultsMode[ format ];
+				builder = moduleBuilders.defaultsMode[format];
 			} else {
-				builder = moduleBuilders.strictMode[ format ];
+				builder = moduleBuilders.strictMode[format];
 			}
 
-			return builder( mod, options );
+			return builder(mod, options);
 		};
 	}
 
-	var esperanto = {
-		toAmd: transpileMethod( 'amd' ),
-		toCjs: transpileMethod( 'cjs' ),
-		toUmd: transpileMethod( 'umd' ),
+	var toAmd = transpileMethod('amd');
+	var toCjs = transpileMethod('cjs');
+	var toUmd = transpileMethod('umd');function bundle(options) {
+		return getBundle(options).then(function (bundle) {
+			return {
+				imports: bundle.externalModules.map(function (mod) {
+					return mod.id;
+				}),
+				exports: flattenExports(bundle.entryModule.exports),
+
+				toAmd: function (options) {
+					return transpile('amd', options);
+				},
+				toCjs: function (options) {
+					return transpile('cjs', options);
+				},
+				toUmd: function (options) {
+					return transpile('umd', options);
+				},
+
+				concat: function (options) {
+					return builders_concat(bundle, options || {});
+				}
+			};
 
-		bundle: function ( options ) {
-			return getBundle( options ).then( function ( bundle ) {
-				return {
-					imports: bundle.externalModules.map( function(mod ) {return mod.id} ),
-					exports: flattenExports( bundle.entryModule.exports ),
+			function transpile(format) {
+				var options = arguments[1] === undefined ? {} : arguments[1];
 
-					toAmd: function(options ) {return transpile( 'amd', options )},
-					toCjs: function(options ) {return transpile( 'cjs', options )},
-					toUmd: function(options ) {return transpile( 'umd', options )},
+				if ('defaultOnly' in options && !alreadyWarned) {
+					// TODO link to a wiki page explaining this, or something
+					console.log(deprecateMessage);
+					alreadyWarned = true;
+				}
 
-					concat: function(options ) {return concat( bundle, options || {} )}
-				};
+				var builder = undefined;
 
-				function transpile ( format ) {var options = arguments[1];if(options === void 0)options = {};
-					if ( 'defaultOnly' in options && !esperanto__alreadyWarned ) {
-						// TODO link to a wiki page explaining this, or something
-						console.log( esperanto__deprecateMessage );
-						esperanto__alreadyWarned = true;
+				if (!options.strict) {
+					// ensure there are no named imports/exports
+					if (utils_hasNamedExports(bundle.entryModule)) {
+						throw new Error('Entry module can only have named exports in strict mode (pass `strict: true`)');
 					}
 
-					var builder;
-
-					if ( !options.strict ) {
-						// ensure there are no named imports/exports
-						if ( hasNamedExports( bundle.entryModule ) ) {
-							throw new Error( 'Entry module can only have named exports in strict mode (pass `strict: true`)' );
-						}
-
-						bundle.modules.forEach( function(mod ) {
-							mod.imports.forEach( function(x ) {
-								if ( x.module.isExternal && ( !x.isDefault && !x.isBatch ) ) {
-									throw new Error( 'You can only have named external imports in strict mode (pass `strict: true`)' );
-								}
-							});
+					bundle.modules.forEach(function (mod) {
+						mod.imports.forEach(function (x) {
+							if (x.module.isExternal && (!x.isDefault && !x.isBatch)) {
+								throw new Error('You can only have named external imports in strict mode (pass `strict: true`)');
+							}
 						});
+					});
 
-						builder = bundleBuilders.defaultsMode[ format ];
-					} else {
-						builder = bundleBuilders.strictMode[ format ];
-					}
-
-					return builder( bundle, options );
+					builder = bundleBuilders.defaultsMode[format];
+				} else {
+					builder = bundleBuilders.strictMode[format];
 				}
-			});
-		}
-	};
-
-	function flattenExports ( exports ) {
-		var flattened = [];
 
-		exports.forEach( function(x ) {
-			if ( x.isDefault ) {
-				flattened.push( 'default' );
+				return builder(bundle, options);
 			}
+		});
+	}
 
-			else if ( x.name ) {
-				flattened.push( x.name );
-			}
+	function flattenExports(exports) {
+		var flattened = [];
 
-			else if ( x.specifiers ) {
-				flattened.push.apply( flattened, x.specifiers.map( getName ) );
+		exports.forEach(function (x) {
+			if (x.isDefault) {
+				flattened.push('default');
+			} else if (x.name) {
+				flattened.push(x.name);
+			} else if (x.specifiers) {
+				flattened.push.apply(flattened, x.specifiers.map(getName));
 			}
 		});
 
 		return flattened;
 	}
 
-	return esperanto;
+	exports.bundle = bundle;
+	exports.toAmd = toAmd;
+	exports.toCjs = toCjs;
+	exports.toUmd = toUmd;
 
 }));
-//# sourceMappingURL=/Users/tricknotes/src/github.com/esperantojs/esperanto/test/.gobble-build/02-esperantoBundle/1/esperanto.browser.js.map
+//# sourceMappingURL=/Users/tricknotes/src/github.com/esperantojs/esperanto/.gobble-build/03-esperantoBundle/1/esperanto.browser.js.map