esperanto-source 0.6.31 → 0.6.32

data/vendor/esperanto.js

@@ -1,5 +1,5 @@
 /*
-	esperanto.js v0.6.30 - 2015-04-26
+	esperanto.js v0.6.32 - 2015-05-07
 	http://esperantojs.org
 
 	Released under the MIT License.
@@ -9,11 +9,9 @@
 
 var acorn = require('acorn');
 var MagicString = require('magic-string');
-var path = require('path');
+var _path = require('path');
 var sander = require('sander');
 
-var hasOwnProp = Object.prototype.hasOwnProperty;
-
 function hasNamedImports ( mod ) {
 	var i = mod.imports.length;
 
@@ -38,29 +36,29 @@ function walk ( ast, leave) {var enter = leave.enter, leave = leave.leave;
 	visit( ast, null, enter, leave );
 }
 
-var walk__context = {
-	skip: function()  {return walk__context.shouldSkip = true}
+var ast_walk__context = {
+	skip: function()  {return ast_walk__context.shouldSkip = true}
 };
 
-var walk__childKeys = {};
+var ast_walk__childKeys = {};
 
-var walk__toString = Object.prototype.toString;
+var ast_walk__toString = Object.prototype.toString;
 
 function isArray ( thing ) {
-	return walk__toString.call( thing ) === '[object Array]';
+	return ast_walk__toString.call( thing ) === '[object Array]';
 }
 
 function visit ( node, parent, enter, leave ) {
 	if ( !node ) return;
 
 	if ( enter ) {
-		walk__context.shouldSkip = false;
-		enter.call( walk__context, node, parent );
-		if ( walk__context.shouldSkip ) return;
+		ast_walk__context.shouldSkip = false;
+		enter.call( ast_walk__context, node, parent );
+		if ( ast_walk__context.shouldSkip ) return;
 	}
 
-	var keys = walk__childKeys[ node.type ] || (
-		walk__childKeys[ node.type ] = Object.keys( node ).filter( function(key ) {return typeof node[ key ] === 'object'} )
+	var keys = ast_walk__childKeys[ node.type ] || (
+		ast_walk__childKeys[ node.type ] = Object.keys( node ).filter( function(key ) {return typeof node[ key ] === 'object'} )
 	);
 
 	var key, value, i, j;
@@ -349,7 +347,7 @@ function findImportsAndExports ( mod, source, ast ) {
  */
 function processImport ( node, passthrough ) {
 	var x = {
-		id: null, // used by bundler - filled in later
+		module: null, // used by bundler - filled in later
 		node: node,
 		start: node.start,
 		end: node.end,
@@ -499,6 +497,9 @@ function processExport ( node, source ) {
 	return result;
 }
 
+var hasOwnProp = Object.prototype.hasOwnProperty;
+var utils_hasOwnProp = hasOwnProp;
+
 function getUnscopedNames ( mod ) {
 	var unscoped = [], importedNames, scope;
 
@@ -511,7 +512,7 @@ function getUnscopedNames ( mod ) {
 				});
 			});
 		}
-		return hasOwnProp.call( importedNames, name );
+		return utils_hasOwnProp.call( importedNames, name );
 	}
 
 	walk( mod.ast, {
@@ -563,7 +564,7 @@ function disallowConflictingImports ( imports ) {
 	}
 
 	function checkName ( name ) {
-		if ( hasOwnProp.call( usedNames, name ) ) {
+		if ( utils_hasOwnProp.call( usedNames, name ) ) {
 			throw new SyntaxError( (("Duplicated import ('" + name) + "')") );
 		}
 
@@ -659,7 +660,7 @@ function determineImportNames ( imports, userFn, usedNames ) {
 		moduleId = x.path;
 
 		// use existing value
-		if ( hasOwnProp.call( nameById, moduleId ) ) {
+		if ( utils_hasOwnProp.call( nameById, moduleId ) ) {
 			x.name = nameById[ moduleId ];
 			return;
 		}
@@ -668,7 +669,7 @@ function determineImportNames ( imports, userFn, usedNames ) {
 		if ( userFn && ( name = userFn( moduleId ) ) ) {
 			name = sanitize( name );
 
-			if ( 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) + "") );
 			}
@@ -685,7 +686,7 @@ function determineImportNames ( imports, userFn, usedNames ) {
 				while ( i-- > 0 ) {
 					candidate = prefix + sanitize( parts.slice( i ).join( '__' ) );
 
-					if ( !hasOwnProp.call( usedNames, candidate ) ) {
+					if ( !utils_hasOwnProp.call( usedNames, candidate ) ) {
 						name = candidate;
 						break;
 					}
@@ -704,13 +705,13 @@ function determineImportNames ( imports, userFn, usedNames ) {
 	// use inferred names for default imports, wherever they
 	// don't clash with path-based names
 	imports.forEach( function(x ) {
-		if ( x.as && !hasOwnProp.call( usedNames, x.as ) ) {
+		if ( x.as && !utils_hasOwnProp.call( usedNames, x.as ) ) {
 			inferredNames[ x.path ] = x.as;
 		}
 	});
 
 	imports.forEach( function(x ) {
-		if ( hasOwnProp.call( inferredNames, x.path ) ) {
+		if ( utils_hasOwnProp.call( inferredNames, x.path ) ) {
 			x.name = inferredNames[ x.path ];
 		}
 	});
@@ -751,7 +752,7 @@ function resolveAgainst ( importerPath ) {
 	};
 }
 
-function sortModules ( entry, moduleLookup ) {
+function sortModules ( entry ) {
 	var seen = {};
 	var ordered = [];
 	var swapPairs = [];
@@ -760,12 +761,12 @@ function sortModules ( entry, moduleLookup ) {
 		seen[ mod.id ] = true;
 
 		mod.imports.forEach( function(x ) {
-			var imported = moduleLookup[ x.id ];
+			var imported = x.module;
 
-			if ( !imported ) return;
+			if ( imported.isExternal || imported.isSkipped ) return;
 
 			// ignore modules we've already included
-			if ( hasOwnProp.call( seen, imported.id ) ) {
+			if ( utils_hasOwnProp.call( seen, imported.id ) ) {
 				if ( shouldSwap( imported, mod ) ) {
 					swapPairs.push([ imported, mod ]);
 				}
@@ -794,15 +795,15 @@ function sortModules ( entry, moduleLookup ) {
 
 function shouldSwap ( a, b ) {
 	// if these modules don't import each other, abort
-	if ( !( sortModules__imports( a, b ) && sortModules__imports( b, a ) ) ) return;
+	if ( !( utils_sortModules__imports( a, b ) && utils_sortModules__imports( b, a ) ) ) return;
 
 	return usesAtTopLevel( b, a ) && !usesAtTopLevel( a, b );
 }
 
-function sortModules__imports ( a, b ) {
+function utils_sortModules__imports ( a, b ) {
 	var i = a.imports.length;
 	while ( i-- ) {
-		if ( a.imports[i].id === b.id ) {
+		if ( a.imports[i].module === b ) {
 			return true;
 		}
 	}
@@ -814,7 +815,7 @@ function usesAtTopLevel ( a, b ) {
 	// find out which bindings a imports from b
 	var i = a.imports.length;
 	while ( i-- ) {
-		if ( a.imports[i].id === b.id ) {
+		if ( a.imports[i].module === b ) {
 			bindings.push.apply( bindings, a.imports[i].specifiers.map( function(x ) {return x.as} ) );
 		}
 	}
@@ -849,18 +850,16 @@ function resolveChains ( modules, moduleLookup ) {
 		var origin = {};
 
 		mod.imports.forEach( function(x ) {
+			var imported = x.module;
+
 			x.specifiers.forEach( function(s ) {
 				if ( s.isBatch ) {
-					// if this is an internal module, we need to tell that module that
-					// it needs to export an object full of getters
-					if ( hasOwnProp.call( moduleLookup, x.id ) ) {
-						moduleLookup[ x.id ]._exportsNamespace = true;
-					}
-
+					// tell that module that it needs to export an object full of getters
+					imported._exportsNamespace = true;
 					return; // TODO can batch imports be chained?
 				}
 
-				origin[ s.as ] = (("" + (x.id)) + ("@" + (s.name)) + "");
+				origin[ s.as ] = (("" + (s.name)) + ("@" + (imported.id)) + "");
 			});
 		});
 
@@ -868,14 +867,49 @@ function resolveChains ( modules, moduleLookup ) {
 			if ( !x.specifiers ) return;
 
 			x.specifiers.forEach( function(s ) {
-				if ( hasOwnProp.call( origin, s.name ) ) {
-					chains[ (("" + (mod.id)) + ("@" + (s.name)) + "") ] = origin[ s.name ];
+				if ( utils_hasOwnProp.call( origin, s.name ) ) {
+					chains[ (("" + (s.name)) + ("@" + (mod.id)) + "") ] = origin[ s.name ];
 				}
 			});
 		});
 	});
 
-	return chains;
+	// Second pass - assigning origins to specifiers
+	modules.forEach( function(mod ) {
+		mod.imports.forEach( function(x ) {
+			var imported = x.module;
+
+			x.specifiers.forEach( function(s ) {
+				if ( s.isBatch ) {
+					return; // TODO can batch imports be chained?
+				}
+
+				setOrigin( s, (("" + (s.name)) + ("@" + (imported.id)) + ""), chains, moduleLookup );
+			});
+		});
+
+		mod.exports.forEach( function(x ) {
+			if ( !x.specifiers ) return;
+
+			x.specifiers.forEach( function(s ) {
+				setOrigin( s, (("" + (s.name)) + ("@" + (mod.id)) + ""), chains, moduleLookup );
+			});
+		});
+	});
+}
+
+function setOrigin ( specifier, hash, chains, moduleLookup ) {
+	var isChained;
+
+	while ( utils_hasOwnProp.call( chains, hash ) ) {
+		hash = chains[ hash ];
+		isChained = true;
+	}
+
+	if ( isChained ) {
+		var name = (moduleId = hash.split( '@' ))[0], moduleId = moduleId[1];
+		specifier.origin = { module: moduleLookup[ moduleId ], name: name };
+	}
 }
 
 // from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
@@ -906,8 +940,8 @@ function getUniqueNames ( bundle ) {
 	// infer names from default imports - e.g. with `import _ from './utils'`,
 	// use '_' instead of generating a name from 'utils'
 	function inferName ( x ) {
-		if ( x.isDefault && !hasOwnProp.call( names, x.id ) && !hasOwnProp.call( used, x.as ) ) {
-			names[ x.id ] = x.as;
+		if ( x.isDefault && !utils_hasOwnProp.call( names, x.module.id ) && !utils_hasOwnProp.call( used, x.as ) ) {
+			names[ x.module.id ] = x.as;
 			used[ x.as ] = true;
 		}
 	}
@@ -919,7 +953,7 @@ function getUniqueNames ( bundle ) {
 	// introducing conflicts
 	modules.concat( externalModules ).forEach( function(mod ) {
 		// is this already named?
-		if ( hasOwnProp.call( names, mod.id ) ) {
+		if ( utils_hasOwnProp.call( names, mod.id ) ) {
 			mod.name = names[ mod.id ];
 			return;
 		}
@@ -931,12 +965,12 @@ function getUniqueNames ( bundle ) {
 		while ( i-- ) {
 			name = sanitize( parts.slice( i ).join( '_' ) );
 
-			if ( !hasOwnProp.call( used, name ) ) {
+			if ( !utils_hasOwnProp.call( used, name ) ) {
 				break;
 			}
 		}
 
-		while ( hasOwnProp.call( used, name ) ) {
+		while ( utils_hasOwnProp.call( used, name ) ) {
 			name = '_' + name;
 		}
 
@@ -950,9 +984,9 @@ function getUniqueNames ( bundle ) {
 function populateExternalModuleImports ( bundle ) {
 	bundle.modules.forEach( function(mod ) {
 		mod.imports.forEach( function(x ) {
-			var externalModule = bundle.externalModuleLookup[ x.id ];
+			var externalModule = x.module;
 
-			if ( !externalModule ) {
+			if ( !externalModule.isExternal ) {
 				return;
 			}
 
@@ -1007,7 +1041,7 @@ function topLevelScopeConflicts ( bundle ) {
 
 		// merge this module's top scope with bundle top scope
 		names.forEach( function(name ) {
-			if ( hasOwnProp.call( inBundle, name ) ) {
+			if ( utils_hasOwnProp.call( inBundle, name ) ) {
 				conflicts[ name ] = true;
 			} else {
 				inBundle[ name ] = true;
@@ -1031,11 +1065,11 @@ function populateIdentifierReplacements ( bundle ) {
 			var result;
 
 			if ( x.hasDeclaration && x.name ) {
-				result = hasOwnProp.call( conflicts, x.name ) || otherModulesDeclare( mod, x.name ) ?
+				result = utils_hasOwnProp.call( conflicts, x.name ) || otherModulesDeclare( mod, x.name ) ?
 					(("" + (mod.name)) + ("__" + (x.name)) + "") :
 					x.name;
 			} else {
-				result = hasOwnProp.call( conflicts, mod.name ) || ( x.value !== mod.name && ~mod.ast._topLevelNames.indexOf( mod.name )) || otherModulesDeclare( mod, mod.name ) ?
+				result = utils_hasOwnProp.call( conflicts, mod.name ) || ( x.value !== mod.name && ~mod.ast._topLevelNames.indexOf( mod.name )) || otherModulesDeclare( mod, mod.name ) ?
 					(("" + (mod.name)) + "__default") :
 					mod.name;
 			}
@@ -1050,63 +1084,55 @@ function populateIdentifierReplacements ( bundle ) {
 		var moduleIdentifiers = mod.identifierReplacements;
 
 		mod.ast._topLevelNames.forEach( function(n ) {
-			moduleIdentifiers[n] = hasOwnProp.call( conflicts, n ) ?
+			moduleIdentifiers[n] = utils_hasOwnProp.call( conflicts, n ) ?
 				(("" + (mod.name)) + ("__" + n) + "") :
 				n;
 		});
 
 		mod.imports.forEach( function(x ) {
-			var externalModule;
-
 			if ( x.passthrough ) {
 				return;
 			}
 
-			externalModule = hasOwnProp.call( bundle.externalModuleLookup, x.id ) && bundle.externalModuleLookup[ x.id ];
+			var imported = x.module;
 
 			x.specifiers.forEach( function(s ) {
-				var moduleId, mod, moduleName, specifierName, replacement, hash, isChained, separatorIndex;
-
-				moduleId = x.id;
+				var replacement;
 
 				if ( s.isBatch ) {
-					replacement = ( bundle.moduleLookup[ moduleId ] || bundle.externalModuleLookup[ moduleId ] ).name;
+					replacement = x.module.name;
 				}
 
 				else {
-					specifierName = s.name;
-
-					// If this is a chained import, get the origin
-					hash = (("" + moduleId) + ("@" + specifierName) + "");
-					while ( hasOwnProp.call( bundle.chains, hash ) ) {
-						hash = bundle.chains[ hash ];
-						isChained = true;
-					}
+					var mod;
+					var specifierName;
 
-					if ( isChained ) {
-						separatorIndex = hash.indexOf( '@' );
-						moduleId = hash.substr( 0, separatorIndex );
-						specifierName = hash.substring( separatorIndex + 1 );
+					if ( s.origin ) {
+						// chained bindings
+						mod = s.origin.module;
+						specifierName = s.origin.name;
+					} else {
+						mod = imported;
+						specifierName = s.name;
 					}
 
-					mod = ( bundle.moduleLookup[ moduleId ] || bundle.externalModuleLookup[ moduleId ] );
-					moduleName = mod && mod.name;
+					var moduleName = mod && mod.name;
 
 					if ( specifierName === 'default' ) {
 						// if it's an external module, always use __default if the
 						// bundle also uses named imports
-						if ( !!externalModule ) {
-							replacement = externalModule.needsNamed ? (("" + moduleName) + "__default") : moduleName;
+						if ( imported.isExternal ) {
+							replacement = imported.needsNamed ? (("" + moduleName) + "__default") : moduleName;
 						}
 
 						// TODO We currently need to check for the existence of `mod`, because modules
 						// can be skipped. Would be better to replace skipped modules with dummies
 						// - see https://github.com/Rich-Harris/esperanto/issues/32
-						else if ( mod ) {
+						else if ( mod && !mod.isSkipped ) {
 							replacement = mod.identifierReplacements.default;
 						}
-					} else if ( !externalModule ) {
-						replacement = hasOwnProp.call( conflicts, specifierName ) ?
+					} else if ( !imported.isExternal ) {
+						replacement = utils_hasOwnProp.call( conflicts, specifierName ) ?
 							(("" + moduleName) + ("__" + specifierName) + "") :
 							specifierName;
 					} else {
@@ -1132,7 +1158,7 @@ function populateIdentifierReplacements ( bundle ) {
 				continue;
 			}
 
-			if ( hasOwnProp.call( otherMod.ast._declared, replacement ) ) {
+			if ( utils_hasOwnProp.call( otherMod.ast._declared, replacement ) ) {
 				return true;
 			}
 		}
@@ -1145,29 +1171,32 @@ function resolveExports ( bundle ) {
 	bundle.entryModule.exports.forEach( function(x ) {
 		if ( x.specifiers ) {
 			x.specifiers.forEach( function(s ) {
-				var hash = (("" + (bundle.entryModule.id)) + ("@" + (s.name)) + "");
+				var module;
+				var name;
 
-				while ( bundle.chains[ hash ] ) {
-					hash = bundle.chains[ hash ];
+				if ( s.origin ) {
+					module = s.origin.module;
+					name = s.origin.name;
+				} else {
+					module = bundle.entryModule;
+					name = s.name;
 				}
 
-				var moduleId = (name = hash.split( '@' ))[0], name = name[1];
-
-				addExport( moduleId, name, s.name );
+				addExport( module, name, s.name );
 			});
 		}
 
 		else if ( !x.isDefault && x.name ) {
-			addExport( bundle.entry, x.name, x.name );
+			addExport( bundle.entryModule, x.name, x.name );
 		}
 	});
 
-	function addExport ( moduleId, name, as ) {
-		if ( !bundleExports[ moduleId ] ) {
-			bundleExports[ moduleId ] = {};
+	function addExport ( module, name, as ) {
+		if ( !bundleExports[ module.id ] ) {
+			bundleExports[ module.id ] = {};
 		}
 
-		bundleExports[ moduleId ][ name ] = as;
+		bundleExports[ module.id ][ name ] = as;
 	}
 
 	return bundleExports;
@@ -1224,14 +1253,14 @@ function disallowIllegalReassignment ( node, importedBindings, importedNamespace
 
 	var name = assignee.name;
 
-	if ( hasOwnProp.call( isNamespaceAssignment ? importedNamespaces : importedBindings, name ) && !scope.contains( 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 name = node.name;
-	var replacement = 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
@@ -1262,7 +1291,7 @@ function rewriteExportAssignments ( body, node, parent, exports, scope, captured
 		return; // shadows an export
 	}
 
-	if ( exports && hasOwnProp.call( exports, name ) ) {
+	if ( exports && utils_hasOwnProp.call( exports, name ) ) {
 		var exportAs = exports[ name ];
 
 		if ( !!capturedUpdates ) {
@@ -1359,11 +1388,11 @@ function exportCapturedUpdate ( c ) {
 	return ((" exports." + (c.exportAs)) + (" = " + (c.name)) + ";");
 }
 
-function transformBody__transformBody ( bundle, mod, body ) {
+function combine_transformBody__transformBody ( bundle, mod, body ) {
 	var identifierReplacements = mod.identifierReplacements;
 	var importedBindings = (importedNamespaces = getReadOnlyIdentifiers( mod.imports ))[0], importedNamespaces = importedNamespaces[1];
 
-	var exportNames = hasOwnProp.call( bundle.exports, mod.id ) && bundle.exports[ mod.id ];
+	var exportNames = utils_hasOwnProp.call( bundle.exports, mod.id ) && bundle.exports[ mod.id ];
 
 	traverseAst( mod.ast, body, identifierReplacements, importedBindings, importedNamespaces, exportNames );
 
@@ -1401,7 +1430,7 @@ function transformBody__transformBody ( bundle, mod, body ) {
 				if ( name === identifierReplacements.default ) {
 					body.remove( x.start, x.end );
 				} else {
-					var original = hasOwnProp.call( identifierReplacements, name ) ? identifierReplacements[ name ] : name;
+					var original = utils_hasOwnProp.call( identifierReplacements, name ) ? identifierReplacements[ name ] : name;
 					body.replace( x.start, x.end, (("var " + (identifierReplacements.default)) + (" = " + original) + ";") );
 				}
 			}
@@ -1493,22 +1522,22 @@ function combine ( bundle ) {
 	bundle.modules.forEach( function(mod ) {
 		// verify that this module doesn't import non-exported identifiers
 		mod.imports.forEach( function(x ) {
-			var importedModule = bundle.moduleLookup[ x.id ];
+			var imported = x.module;
 
-			if ( !importedModule || x.isBatch ) {
+			if ( imported.isExternal || imported.isSkipped || x.isBatch ) {
 				return;
 			}
 
 			x.specifiers.forEach( function(s ) {
-				if ( !importedModule.doesExport[ s.name ] ) {
-					throw new Error( (("Module '" + (importedModule.id)) + ("' does not export '" + (s.name)) + ("' (imported by '" + (mod.id)) + "')") );
+				if ( !imported.doesExport[ s.name ] ) {
+					throw new Error( (("Module '" + (imported.id)) + ("' does not export '" + (s.name)) + ("' (imported by '" + (mod.id)) + "')") );
 				}
 			});
 		});
 
 		bundle.body.addSource({
-			filename: path.resolve( bundle.base, mod.relativePath ),
-			content: transformBody__transformBody( bundle, mod, mod.body ),
+			filename: mod.path,
+			content: combine_transformBody__transformBody( bundle, mod, mod.body ),
 			indentExclusionRanges: mod.ast._templateLiteralRanges
 		});
 	});
@@ -1581,7 +1610,7 @@ function getModule ( mod ) {
 	return mod;
 }
 
-var getBundle__Promise = sander.Promise;
+var bundler_getBundle__Promise = sander.Promise;
 
 function getBundle ( options ) {
 	var entry = options.entry.replace( /\.js$/, '' );
@@ -1591,7 +1620,7 @@ function getBundle ( options ) {
 	var promiseByPath = {};
 	var skip = options.skip;
 	var names = options.names;
-	var base = ( options.base ? path.resolve( options.base ) : process.cwd() ) + '/';
+	var base = ( options.base ? _path.resolve( options.base ) : process.cwd() ) + '/';
 	var externalModules = [];
 	var externalModuleLookup = {};
 
@@ -1599,27 +1628,31 @@ function getBundle ( options ) {
 		entry = entry.substring( base.length );
 	}
 
-	return resolvePath( base, userModules, entry, null ).then( function(relativePath ) {
-		return fetchModule( entry, relativePath ).then( function()  {
-			var entryModule = moduleLookup[ entry ];
-			modules = sortModules( entryModule, moduleLookup );
-
-			var bundle = {
-				entry: entry,
-				entryModule: entryModule,
-				base: base,
-				modules: modules,
-				moduleLookup: moduleLookup,
-				externalModules: externalModules,
-				externalModuleLookup: externalModuleLookup,
-				skip: skip,
-				names: names,
-				chains: resolveChains( modules, moduleLookup )
-			};
+	// resolve user module paths
+	options.modules && Object.keys( options.modules ).forEach( function(relativePath ) {
+		userModules[ _path.resolve( base, relativePath ) ] = options.modules[ relativePath ];
+	});
 
-			combine( bundle );
+	var cyclicalModules = [];
+
+	return resolvePath( base, userModules, entry, null ).then( function(absolutePath ) {
+		return fetchModule( entry, absolutePath ).then( function(entryModule ) {
+			return bundler_getBundle__Promise.all( cyclicalModules ).then( function()  {
+				modules = sortModules( entryModule );
+
+				var bundle = {
+					entryModule: entryModule,
+					modules: modules,
+					externalModules: externalModules,
+					names: names
+				};
+
+				resolveChains( modules, moduleLookup );
+				combine( bundle );
+
+				return bundle;
+			});
 
-			return bundle;
 		});
 	}, function ( err ) {
 		if ( err.code === 'ENOENT' ) {
@@ -1629,13 +1662,11 @@ function getBundle ( options ) {
 		throw err;
 	});
 
-	function fetchModule ( moduleId, relativePath ) {
-		var absolutePath = path.resolve( base, relativePath );
-
-		if ( !hasOwnProp.call( promiseByPath, relativePath ) ) {
-			promiseByPath[ relativePath ] = (
-				hasOwnProp.call( userModules, relativePath ) ?
-					getBundle__Promise.resolve( userModules[ relativePath ] ) :
+	function fetchModule ( moduleId, absolutePath ) {
+		if ( !utils_hasOwnProp.call( promiseByPath, absolutePath ) ) {
+			promiseByPath[ absolutePath ] = (
+				utils_hasOwnProp.call( userModules, absolutePath ) ?
+					bundler_getBundle__Promise.resolve( userModules[ absolutePath ] ) :
 					sander.readFile( absolutePath ).then( String )
 			).then( function ( source ) {
 				var code, ast;
@@ -1662,41 +1693,62 @@ function getBundle ( options ) {
 					path: absolutePath,
 					code: code,
 					ast: ast,
-					relativePath: relativePath
+
+					// TODO should not need this
+					relativePath: _path.relative( base, absolutePath )
 				});
 
 				modules.push( module );
 				moduleLookup[ moduleId ] = module;
 
 				var promises = module.imports.map( function(x ) {
-					x.id = resolveId( x.path, module.relativePath );
+					// TODO remove this, use x.module instead. more flexible, no lookups involved
+					var id = resolveId( x.path, module.relativePath );
 
-					if ( x.id === moduleId ) {
+					if ( id === moduleId ) {
 						throw new Error( 'A module (' + moduleId + ') cannot import itself' );
 					}
 
 					// Some modules can be skipped
-					if ( skip && ~skip.indexOf( x.id ) ) {
-						return;
+					if ( skip && ~skip.indexOf( id ) ) {
+						var skippedModule = {
+							id: id,
+							isSkipped: true
+						};
+
+						x.module = skippedModule;
+						return skippedModule;
 					}
 
-					return resolvePath( base, userModules, x.id, absolutePath, options.resolvePath ).then( function(relativePath ) {
-						// short-circuit cycles
-						if ( hasOwnProp.call( promiseByPath, relativePath ) ) {
+					return resolvePath( base, userModules, id, absolutePath, options.resolvePath ).then( function(absolutePath ) {
+						var promise = utils_hasOwnProp.call( promiseByPath, absolutePath ) && promiseByPath[ absolutePath ];
+						var cyclical = !!promise;
+
+						if ( cyclical ) {
+							// ensure all modules are set before we
+							// create the bundle...
+							cyclicalModules.push(
+								promise.then( function(module ) {return x.module = module} )
+							);
+
+							// ...then short-circuit
 							return;
 						}
 
-						return fetchModule( x.id, relativePath );
+						return fetchModule( id, absolutePath ).then( function(module ) {return x.module = module} );
 					}, function handleError ( err ) {
 						if ( err.code === 'ENOENT' ) {
 							// Most likely an external module
-							if ( !hasOwnProp.call( externalModuleLookup, x.id ) ) {
+							if ( !utils_hasOwnProp.call( externalModuleLookup, id ) ) {
 								var externalModule = {
-									id: x.id
+									id: id,
+									isExternal: true
 								};
 
+								x.module = externalModule;
+
 								externalModules.push( externalModule );
-								externalModuleLookup[ x.id ] = externalModule;
+								externalModuleLookup[ id ] = externalModule;
 							}
 						} else {
 							throw err;
@@ -1704,11 +1756,12 @@ function getBundle ( options ) {
 					} );
 				});
 
-				return getBundle__Promise.all( promises );
+				return bundler_getBundle__Promise.all( promises )
+					.then( function()  {return module} );
 			});
 		}
 
-		return promiseByPath[ relativePath ];
+		return promiseByPath[ absolutePath ];
 	}
 }
 
@@ -1716,9 +1769,9 @@ function resolvePath ( base, userModules, moduleId, importerPath, resolver ) {
 	var noExt = moduleId.replace( /\.js$/, '' );
 
 	return tryPath( base, noExt + '.js', userModules )
-		.catch( function()  {return tryPath( base, noExt + path.sep + 'index.js', userModules )} )
+		.catch( function()  {return tryPath( base, noExt + _path.sep + 'index.js', userModules )} )
 		.catch( function ( err ) {
-			var resolvedPromise = resolver && getBundle__Promise.resolve( resolver( moduleId, importerPath ) );
+			var resolvedPromise = resolver && bundler_getBundle__Promise.resolve( resolver( moduleId, importerPath ) );
 
 			if ( resolvedPromise ) {
 				return resolvedPromise.then( function(resolvedPath ) {
@@ -1729,7 +1782,7 @@ function resolvePath ( base, userModules, moduleId, importerPath, resolver ) {
 						throw err;
 					}
 
-					return sander.stat( resolvedPath ).then( function()  {return resolvedPath} );
+					return sander.stat( resolvedPath ).then( function()  {return _path.resolve( base, resolvedPath )} );
 				});
 			} else {
 				throw err;
@@ -1738,10 +1791,12 @@ function resolvePath ( base, userModules, moduleId, importerPath, resolver ) {
 }
 
 function tryPath ( base, filename, userModules ) {
-	if ( hasOwnProp.call( userModules, filename ) ) {
-		return getBundle__Promise.resolve( filename );
+	var absolutePath = _path.resolve( base, filename );
+
+	if ( utils_hasOwnProp.call( userModules, absolutePath ) ) {
+		return bundler_getBundle__Promise.resolve( absolutePath );
 	}
-	return sander.stat( base, filename ).then( function()  {return filename} );
+	return sander.stat( absolutePath ).then( function()  {return absolutePath} );
 }
 
 function isThenable ( obj ) {
@@ -1796,7 +1851,7 @@ function transformExportDeclaration ( declaration, body ) {
 
 var ABSOLUTE_PATH = /^(?:[A-Z]:)?[\/\\]/i;
 
-var packageResult__warned = {};
+var utils_packageResult__warned = {};
 
 function packageResult ( bundleOrModule, body, options, methodName, isBundle ) {
 	// wrap output
@@ -1848,9 +1903,9 @@ function packageResult ( bundleOrModule, body, options, methodName, isBundle ) {
 		code: code,
 		map: map,
 		toString: function () {
-			if ( !packageResult__warned[ methodName ] ) {
+			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") );
-				packageResult__warned[ methodName ] = true;
+				utils_packageResult__warned[ methodName ] = true;
 			}
 
 			return code;
@@ -1966,7 +2021,7 @@ function amdIntro (useStrict) {var name = useStrict.name, imports = useStrict.im
 	return intro;
 }
 
-function amd__amd ( mod, options ) {
+function defaultsMode_amd__amd ( mod, options ) {
 	mod.imports.forEach( function(x ) {
 		mod.body.remove( x.start, x.next );
 	});
@@ -1990,11 +2045,11 @@ function amd__amd ( mod, options ) {
 	return packageResult( mod, mod.body, options, 'toAmd' );
 }
 
-function cjs__cjs ( mod, options ) {
+function defaultsMode_cjs__cjs ( mod, options ) {
 	var seen = {};
 
 	mod.imports.forEach( function(x ) {
-		if ( !hasOwnProp.call( seen, x.path ) ) {
+		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 );
 
@@ -2104,15 +2159,17 @@ EsperantoError.prototype = new Error();
 EsperantoError.prototype.constructor = EsperantoError;
 EsperantoError.prototype.name = 'EsperantoError';
 
+var utils_EsperantoError = EsperantoError;
+
 function requireName ( options ) {
 	if ( !options.name ) {
-		throw new EsperantoError( 'You must supply a `name` option for UMD modules', {
+		throw new utils_EsperantoError( 'You must supply a `name` option for UMD modules', {
 			code: 'MISSING_NAME'
 		});
 	}
 }
 
-function umd__umd ( mod, options ) {
+function defaultsMode_umd__umd ( mod, options ) {
 	requireName( options );
 
 	mod.imports.forEach( function(x ) {
@@ -2137,9 +2194,9 @@ function umd__umd ( mod, options ) {
 }
 
 var defaultsMode = {
-	amd: amd__amd,
-	cjs: cjs__cjs,
-	umd: umd__umd
+	amd: defaultsMode_amd__amd,
+	cjs: defaultsMode_cjs__cjs,
+	umd: defaultsMode_umd__umd
 };
 
 function gatherImports ( imports ) {
@@ -2276,7 +2333,7 @@ function utils_transformBody__transformBody ( mod, body, options ) {
 }
 
 function deconflict ( name, declared ) {
-	while ( hasOwnProp.call( declared, name ) ) {
+	while ( utils_hasOwnProp.call( declared, name ) ) {
 		name = '_' + name;
 	}
 
@@ -2307,7 +2364,7 @@ function strictMode_cjs__cjs ( mod, options ) {
 
 	// Create block of require statements
 	var importBlock = mod.imports.map( function(x ) {
-		if ( !hasOwnProp.call( seen, x.path ) ) {
+		if ( !utils_hasOwnProp.call( seen, x.path ) ) {
 			seen[ x.path ] = true;
 
 			if ( x.isEmpty ) {
@@ -2365,7 +2422,7 @@ var moduleBuilders = {
 	strictMode: strictMode
 };
 
-function defaultsMode_amd__amd ( bundle, options ) {
+function builders_defaultsMode_amd__amd ( bundle, options ) {
 	var defaultName = bundle.entryModule.identifierReplacements.default;
 	if ( defaultName ) {
 		bundle.body.append( (("\n\nreturn " + defaultName) + ";") );
@@ -2382,7 +2439,7 @@ function defaultsMode_amd__amd ( bundle, options ) {
 	return packageResult( bundle, bundle.body, options, 'toAmd', true );
 }
 
-function defaultsMode_cjs__cjs ( bundle, options ) {
+function builders_defaultsMode_cjs__cjs ( bundle, options ) {
 	var importBlock = bundle.externalModules.map( function(x ) {
 		return (("var " + (x.name)) + (" = " + (req(x.id))) + ";");
 	}).join( '\n' );
@@ -2403,7 +2460,7 @@ function defaultsMode_cjs__cjs ( bundle, options ) {
 	return packageResult( bundle, bundle.body, options, 'toCjs', true );
 }
 
-function defaultsMode_umd__umd ( bundle, options ) {
+function builders_defaultsMode_umd__umd ( bundle, options ) {
 	requireName( options );
 
 	var entry = bundle.entryModule;
@@ -2427,9 +2484,9 @@ function defaultsMode_umd__umd ( bundle, options ) {
 }
 
 var builders_defaultsMode = {
-	amd: defaultsMode_amd__amd,
-	cjs: defaultsMode_cjs__cjs,
-	umd: defaultsMode_umd__umd
+	amd: builders_defaultsMode_amd__amd,
+	cjs: builders_defaultsMode_cjs__cjs,
+	umd: builders_defaultsMode_umd__umd
 };
 
 function getExportBlock ( entry ) {
@@ -2641,7 +2698,7 @@ var esperanto = {
 
 					bundle.modules.forEach( function(mod ) {
 						mod.imports.forEach( function(x ) {
-							if ( hasOwnProp.call( bundle.externalModuleLookup, x.id ) && ( !x.isDefault && !x.isBatch ) ) {
+							if ( x.module.isExternal && ( !x.isDefault && !x.isBatch ) ) {
 								throw new Error( 'You can only have named external imports in strict mode (pass `strict: true`)' );
 							}
 						});
@@ -2678,4 +2735,5 @@ function flattenExports ( exports ) {
 	return flattened;
 }
 
-module.exports = esperanto;
+module.exports = esperanto;
+//# sourceMappingURL=/Users/tricknotes/src/github.com/esperantojs/esperanto/test/.gobble-build/01-esperantoBundle/1/esperanto.js.map