rollup/dist/rollup.js

'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var sander = require('sander');
var MagicString = require('magic-string');
MagicString = 'default' in MagicString ? MagicString['default'] : MagicString;
var acorn = require('acorn');

// TODO does this all work on windows?

var absolutePath = /^(?:\/|(?:[A-Za-z]:)?\\)/;

function isAbsolute(path) {
	return absolutePath.test(path);
}

function basename(path) {
	return path.split(/(\/|\\)/).pop();
}

function dirname(path) {
	var match = /(\/|\\)[^\/\\]*$/.exec(path);
	if (!match) return '.';

	var dir = path.slice(0, -match[0].length);

	// If `dir` is the empty string, we're at root.
	return dir ? dir : '/';
}

function extname(path) {
	var match = /\.[^\.]+$/.exec(path);
	if (!match) return '';
	return match[0];
}

function resolve() {
	for (var _len = arguments.length, paths = Array(_len), _key = 0; _key < _len; _key++) {
		paths[_key] = arguments[_key];
	}

	var resolvedParts = paths.shift().split(/[\/\\]/);

	paths.forEach(function (path) {
		if (isAbsolute(path)) {
			resolvedParts = path.split(/[\/\\]/);
		} else {
			var parts = path.split(/[\/\\]/);

			while (parts[0] && parts[0][0] === '.') {
				var part = parts.shift();
				if (part === '..') {
					resolvedParts.pop();
				} else if (part !== '.') {
					throw new Error('Unexpected path part (' + part + ')');
				}
			}

			resolvedParts.push.apply(resolvedParts, parts);
		}
	});

	return resolvedParts.join('/'); // TODO windows...
}

var keys = Object.keys;

function blank() {
	return Object.create(null);
}

function unixizePath(path) {
	return path.split(/[\/\\]/).join('/');
}

function getIndentString(magicString, options) {
	if (!('indent' in options) || options.indent === true) {
		return magicString.getIndentString();
	}

	return options.indent || '';
}

function badExports(option, keys) {
	throw new Error('\'' + option + '\' was specified for options.exports, but entry module has following exports: ' + keys.join(', '));
}

function getExportMode(bundle, exportMode) {
	var exportKeys = keys(bundle.entryModule.exports);

	if (exportMode === 'default') {
		if (exportKeys.length !== 1 || exportKeys[0] !== 'default') {
			badExports('default', exportKeys);
		}
	} else if (exportMode === 'none' && exportKeys.length) {
		badExports('none', exportKeys);
	}

	if (!exportMode || exportMode === 'auto') {
		if (exportKeys.length === 0) {
			exportMode = 'none';
		} else if (exportKeys.length === 1 && exportKeys[0] === 'default') {
			exportMode = 'default';
		} else {
			exportMode = 'named';
		}
	}

	if (!/(?:default|named|none)/.test(exportMode)) {
		throw new Error('options.exports must be \'default\', \'named\', \'none\', \'auto\', or left unspecified (defaults to \'auto\')');
	}

	return exportMode;
}

function getInteropBlock(bundle) {
	return bundle.externalModules.filter(function (module) {
		return module.needsDefault && module.needsNamed;
	}).map(function (module) {
		return 'var ' + module.name + '__default = \'default\' in ' + module.name + ' ? ' + module.name + '[\'default\'] : ' + module.name + ';';
	}).join('\n');
}

function getName(x) {
	return x.name;
}

function quoteId(x) {
	return '\'' + x.id + '\'';
}

function req(x) {
	return 'require(\'' + x.id + '\')';
}

function umd(bundle, magicString, _ref, options) {
	var exportMode = _ref.exportMode;
	var indentString = _ref.indentString;

	if (exportMode !== 'none' && !options.moduleName) {
		throw new Error('You must supply options.moduleName for UMD bundles');
	}

	var globalNames = options.globals || blank();

	var amdDeps = bundle.externalModules.map(quoteId);
	var cjsDeps = bundle.externalModules.map(req);
	var globalDeps = bundle.externalModules.map(function (module) {
		return 'global.' + (globalNames[module.id] || module.name);
	});

	var args = bundle.externalModules.map(getName);

	if (exportMode === 'named') {
		amdDeps.unshift('\'exports\'');
		cjsDeps.unshift('exports');
		globalDeps.unshift('(global.' + options.moduleName + ' = {})');

		args.unshift('exports');
	}

	var amdParams = (options.moduleId ? '[\'' + options.moduleId + '\'], ' : '') + (amdDeps.length ? '[' + amdDeps.join(', ') + '], ' : '');

	var cjsExport = exportMode === 'default' ? 'module.exports = ' : '';
	var defaultExport = exportMode === 'default' ? 'global.' + options.moduleName + ' = ' : '';

	var intro = ('(function (global, factory) {\n\t\t\ttypeof exports === \'object\' && typeof module !== \'undefined\' ? ' + cjsExport + 'factory(' + cjsDeps.join(', ') + ') :\n\t\t\ttypeof define === \'function\' && define.amd ? define(' + amdParams + 'factory) :\n\t\t\t' + defaultExport + 'factory(' + globalDeps + ');\n\t\t}(this, function (' + args + ') { \'use strict\';\n\n\t\t').replace(/^\t\t/gm, '').replace(/^\t/gm, magicString.getIndentString());

	// var foo__default = 'default' in foo ? foo['default'] : foo;
	var interopBlock = getInteropBlock(bundle);
	if (interopBlock) magicString.prepend(interopBlock + '\n\n');

	var exports = bundle.entryModule.exports;

	var exportBlock = undefined;

	if (exportMode === 'default') {
		var canonicalName = bundle.entryModule.getCanonicalName('default');
		exportBlock = 'return ' + canonicalName + ';';
	} else {
		exportBlock = bundle.toExport.map(function (name) {
			var canonicalName = bundle.entryModule.getCanonicalName(exports[name].localName);
			return 'exports.' + name + ' = ' + canonicalName + ';';
		}).join('\n');
	}

	if (exportBlock) {
		magicString.append('\n\n' + exportBlock);
	}

	return magicString.trim().indent(indentString).append('\n\n}));').prepend(intro);
}

function iife(bundle, magicString, _ref2, options) {
	var exportMode = _ref2.exportMode;
	var indentString = _ref2.indentString;

	var globalNames = options.globals || blank();

	var dependencies = bundle.externalModules.map(function (module) {
		return globalNames[module.id] || module.name;
	});

	var args = bundle.externalModules.map(getName);

	if (exportMode !== 'none' && !options.moduleName) {
		throw new Error('You must supply options.moduleName for IIFE bundles');
	}

	if (exportMode === 'named') {
		dependencies.unshift('(this.' + options.moduleName + ' = {})');
		args.unshift('exports');
	}

	var intro = '(function (' + args + ') { \'use strict\';\n\n';
	var outro = '\n\n})(' + dependencies + ');';

	// var foo__default = 'default' in foo ? foo['default'] : foo;
	var interopBlock = getInteropBlock(bundle);
	if (interopBlock) magicString.prepend(interopBlock + '\n\n');

	if (exportMode === 'default') {
		intro = 'var ' + options.moduleName + ' = ' + intro;
		magicString.append('\n\nreturn ' + bundle.entryModule.getCanonicalName('default') + ';');
	}

	// TODO named exports

	return magicString.indent(indentString).prepend(intro).append(outro);
}

function es6(bundle, magicString, _ref3, options) {
	var exportMode = _ref3.exportMode;

	var importBlock = bundle.externalModules.map(function (module) {
		var specifiers = [];

		if (module.needsDefault) {
			specifiers.push(module.importedByBundle.filter(function (declaration) {
				return declaration.name === 'default';
			})[0].localName);
		}

		if (module.needsAll) {
			specifiers.push('* as ' + module.importedByBundle.filter(function (declaration) {
				return declaration.name === '*';
			})[0].localName);
		}

		if (module.needsNamed) {
			specifiers.push('{ ' + module.importedByBundle.filter(function (declaration) {
				return !/^(default|\*)$/.test(declaration.name);
			}).map(function (_ref4) {
				var name = _ref4.name;
				var localName = _ref4.localName;
				return name === localName ? name : name + ' as ' + localName;
			}).join(', ') + ' }');
		}

		return specifiers.length ? 'import ' + specifiers.join(', ') + ' from \'' + module.id + '\';' : 'import \'' + module.id + '\';';
	}).join('\n');

	if (importBlock) {
		magicString.prepend(importBlock + '\n\n');
	}

	var exports = bundle.entryModule.exports;
	var exportBlock = keys(exports).map(function (exportedName) {
		var specifier = exports[exportedName];

		var canonicalName = bundle.entryModule.getCanonicalName(specifier.localName);

		if (exportedName === 'default') {
			return 'export default ' + canonicalName + ';';
		}

		return exportedName === canonicalName ? 'export { ' + exportedName + ' };' : 'export { ' + canonicalName + ' as ' + exportedName + ' };';
	}).join('\n');

	if (exportBlock) {
		magicString.append('\n\n' + exportBlock);
	}

	return magicString.trim();
}

function cjs(bundle, magicString, _ref5) {
	var exportMode = _ref5.exportMode;

	var intro = '\'use strict\';\n\n';

	// TODO handle empty imports, once they're supported
	var importBlock = bundle.externalModules.map(function (module) {
		var requireStatement = 'var ' + module.name + ' = require(\'' + module.id + '\');';

		if (module.needsDefault) {
			requireStatement += '\n' + (module.needsNamed ? 'var ' + module.name + '__default = ' : module.name + ' = ') + ('\'default\' in ' + module.name + ' ? ' + module.name + '[\'default\'] : ' + module.name + ';');
		}

		return requireStatement;
	}).join('\n');

	if (importBlock) {
		intro += importBlock + '\n\n';
	}

	magicString.prepend(intro);

	var exportBlock = undefined;
	if (exportMode === 'default' && bundle.entryModule.exports.default) {
		exportBlock = 'module.exports = ' + bundle.entryModule.getCanonicalName('default') + ';';
	} else if (exportMode === 'named') {
		exportBlock = bundle.toExport.map(function (key) {
			var specifier = bundle.entryModule.exports[key];
			var name = bundle.entryModule.getCanonicalName(specifier.localName);

			return 'exports.' + key + ' = ' + name + ';';
		}).join('\n');
	}

	if (exportBlock) {
		magicString.append('\n\n' + exportBlock);
	}

	return magicString;
}

function amd(bundle, magicString, _ref6, options) {
	var exportMode = _ref6.exportMode;
	var indentString = _ref6.indentString;

	var deps = bundle.externalModules.map(quoteId);
	var args = bundle.externalModules.map(getName);

	if (exportMode === 'named') {
		args.unshift('exports');
		deps.unshift('\'exports\'');
	}

	var params = (options.moduleId ? '[\'' + options.moduleId + '\'], ' : '') + (deps.length ? '[' + deps.join(', ') + '], ' : '');

	var intro = 'define(' + params + 'function (' + args.join(', ') + ') { \'use strict\';\n\n';

	// var foo__default = 'default' in foo ? foo['default'] : foo;
	var interopBlock = getInteropBlock(bundle);
	if (interopBlock) magicString.prepend(interopBlock + '\n\n');

	var exports = bundle.entryModule.exports;

	var exportBlock = undefined;

	if (exportMode === 'default') {
		exportBlock = 'return ' + bundle.entryModule.getCanonicalName('default') + ';';
	} else {
		exportBlock = bundle.toExport.map(function (name) {
			return 'exports.' + name + ' = ' + exports[name].localName + ';';
		}).join('\n');
	}

	if (exportBlock) magicString.append('\n\n' + exportBlock);

	return magicString.indent(indentString).append('\n\n});').prepend(intro);
}

var finalisers = { amd: amd, cjs: cjs, es6: es6, iife: iife, umd: umd };

var reservedWords = '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 enum await implements package protected static interface private public'.split(' ');
var builtins = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');

var blacklisted = blank();
reservedWords.concat(builtins).forEach(function (word) {
	return blacklisted[word] = true;
});

function makeLegalIdentifier(str) {
	str = str.replace(/[^$_a-zA-Z0-9]/g, '_');
	if (/\d/.test(str[0]) || blacklisted[str]) str = '_' + str;

	return str;
}

var shouldSkip = undefined;
var shouldAbort = undefined;

function walk(ast, _ref7) {
	var enter = _ref7.enter;
	var leave = _ref7.leave;

	shouldAbort = false;
	visit(ast, null, enter, leave);
}

var context = {
	skip: function () {
		return shouldSkip = true;
	},
	abort: function () {
		return shouldAbort = true;
	}
};

var childKeys = blank();

var toString = Object.prototype.toString;

function isArray(thing) {
	return toString.call(thing) === '[object Array]';
}

function visit(node, parent, enter, leave) {
	if (!node || shouldAbort) return;

	if (enter) {
		shouldSkip = false;
		enter.call(context, node, parent);
		if (shouldSkip || shouldAbort) return;
	}

	var keys = childKeys[node.type] || (childKeys[node.type] = Object.keys(node).filter(function (key) {
		return typeof node[key] === 'object';
	}));

	var key = undefined,
	    value = undefined,
	    i = undefined,
	    j = undefined;

	i = keys.length;
	while (i--) {
		key = keys[i];
		value = node[key];

		if (isArray(value)) {
			j = value.length;
			while (j--) {
				visit(value[j], node, enter, leave);
			}
		} else if (value && value.type) {
			visit(value, node, enter, leave);
		}
	}

	if (leave && !shouldAbort) {
		leave(node, parent);
	}
}

function sequence(arr, callback) {
	var len = arr.length;
	var results = new Array(len);

	var promise = sander.Promise.resolve();

	function next(i) {
		return promise.then(function () {
			return callback(arr[i], i);
		}).then(function (result) {
			return results[i] = result;
		});
	}

	var i = undefined;

	for (i = 0; i < len; i += 1) {
		promise = next(i);
	}

	return promise.then(function () {
		return results;
	});
}

function first(arr, fail, callback) {
	var len = arr.length;

	var promise = sander.Promise.reject(fail);

	function next(i) {
		return promise.catch(function () {
			return callback(arr[i], i);
		});
	}

	var i = undefined;

	for (i = 0; i < len; i += 1) {
		promise = next(i);
	}

	return promise;
}

function getLocation(source, charIndex) {
	var lines = source.split('\n');
	var len = lines.length;

	var lineStart = 0;
	var i = undefined;

	for (i = 0; i < len; i += 1) {
		var line = lines[i];
		var lineEnd = lineStart + line.length + 1; // +1 for newline

		if (lineEnd > charIndex) {
			return { line: i + 1, column: charIndex - lineStart };
		}

		lineStart = lineEnd;
	}

	throw new Error('Could not determine location of character');
}

var blockDeclarations = {
	'const': true,
	'let': true
};

var Scope = (function () {
	function Scope(options) {
		var _this = this;

		_classCallCheck(this, Scope);

		options = options || {};

		this.parent = options.parent;
		this.depth = this.parent ? this.parent.depth + 1 : 0;
		this.declarations = blank();
		this.isBlockScope = !!options.block;

		if (options.params) {
			options.params.forEach(function (param) {
				_this.declarations[param.name] = param;
			});
		}
	}

	// add ( name, isBlockDeclaration ) {
	// 	if ( !isBlockDeclaration && this.isBlockScope ) {
	// 		// it's a `var` or function declaration, and this
	// 		// is a block scope, so we need to go up
	// 		this.parent.add( name, isBlockDeclaration );
	// 	} else {
	// 		this.names.push( name );
	// 	}
	// }

	Scope.prototype.addDeclaration = function addDeclaration(name, declaration) {
		var isBlockDeclaration = declaration.type === 'VariableDeclaration' && blockDeclarations[declaration.kind];

		if (!isBlockDeclaration && this.isBlockScope) {
			// it's a `var` or function declaration, and this
			// is a block scope, so we need to go up
			this.parent.addDeclaration(name, declaration);
		} else {
			this.declarations[name] = declaration;
		}
	};

	Scope.prototype.contains = function contains(name) {
		return !!this.getDeclaration(name);
	};

	Scope.prototype.findDefiningScope = function findDefiningScope(name) {
		if (!!this.declarations[name]) {
			return this;
		}

		if (this.parent) {
			return this.parent.findDefiningScope(name);
		}

		return null;
	};

	Scope.prototype.getDeclaration = function getDeclaration(name) {
		return this.declarations[name] || this.parent && this.parent.getDeclaration(name);
	};

	return Scope;
})();

function isIife(node, parent) {
	return parent && parent.type === 'CallExpression' && node === parent.callee;
}

var Statement = (function () {
	function Statement(node, module, start, end) {
		_classCallCheck(this, Statement);

		this.node = node;
		this.module = module;
		this.start = start;
		this.end = end;
		this.next = null; // filled in later

		this.scope = new Scope();
		this.defines = blank();
		this.modifies = blank();
		this.dependsOn = blank();
		this.stronglyDependsOn = blank();

		this.isIncluded = false;

		this.isImportDeclaration = node.type === 'ImportDeclaration';
		this.isExportDeclaration = /^Export/.test(node.type);
	}

	Statement.prototype.analyse = function analyse() {
		var _this2 = this;

		if (this.isImportDeclaration) return; // nothing to analyse

		var scope = this.scope;

		walk(this.node, {
			enter: function (node, parent) {
				var newScope = undefined;

				switch (node.type) {
					case 'FunctionExpression':
					case 'FunctionDeclaration':
					case 'ArrowFunctionExpression':
						if (node.type === 'FunctionDeclaration') {
							scope.addDeclaration(node.id.name, node);
						}

						newScope = new Scope({
							parent: scope,
							params: node.params, // TODO rest params?
							block: false
						});

						// named function expressions - the name is considered
						// part of the function's scope
						if (node.type === 'FunctionExpression' && node.id) {
							newScope.addDeclaration(node.id.name, node);
						}

						break;

					case 'BlockStatement':
						if (!/Function/.test(parent.type)) {
							newScope = new Scope({
								parent: scope,
								block: true
							});
						}

						break;

					case 'CatchClause':
						newScope = new Scope({
							parent: scope,
							params: [node.param],
							block: true
						});

						break;

					case 'VariableDeclaration':
						node.declarations.forEach(function (declarator) {
							scope.addDeclaration(declarator.id.name, node);
						});
						break;

					case 'ClassDeclaration':
						scope.addDeclaration(node.id.name, node);
						break;
				}

				if (newScope) {
					Object.defineProperty(node, '_scope', { value: newScope });
					scope = newScope;
				}
			},
			leave: function (node) {
				if (node._scope) {
					scope = scope.parent;
				}
			}
		});

		// This allows us to track whether we're looking at code that will
		// be executed immediately (either outside a function, or immediately
		// inside an IIFE), for the purposes of determining whether dependencies
		// are strong or weak. It's not bulletproof, since it wouldn't catch...
		//
		//    var calledImmediately = function () {
		//      doSomethingWith( strongDependency );
		//    }
		//    calledImmediately();
		//
		// ...but it's better than nothing
		var depth = 0;

		if (!this.isImportDeclaration) {
			walk(this.node, {
				enter: function (node, parent) {
					if (node._scope) {
						if (!scope.isBlockScope && !isIife(node, parent)) depth += 1;
						scope = node._scope;
					}

					_this2.checkForReads(scope, node, parent, !depth);
					_this2.checkForWrites(scope, node);
				},
				leave: function (node, parent) {
					if (node._scope) {
						if (!scope.isBlockScope && !isIife(node, parent)) depth -= 1;
						scope = scope.parent;
					}
				}
			});
		}

		keys(scope.declarations).forEach(function (name) {
			_this2.defines[name] = true;
		});
	};

	Statement.prototype.checkForReads = function checkForReads(scope, node, parent, strong) {
		if (node.type === 'Identifier') {
			// disregard the `bar` in `foo.bar` - these appear as Identifier nodes
			if (parent.type === 'MemberExpression' && !parent.computed && node !== parent.object) {
				return;
			}

			// disregard the `bar` in { bar: foo }
			if (parent.type === 'Property' && node !== parent.value) {
				return;
			}

			// disregard the `bar` in `class Foo { bar () {...} }`
			if (parent.type === 'MethodDefinition') return;

			var definingScope = scope.findDefiningScope(node.name);

			if ((!definingScope || definingScope.depth === 0) && !this.defines[node.name]) {
				this.dependsOn[node.name] = true;
				if (strong) this.stronglyDependsOn[node.name] = true;
			}
		}
	};

	Statement.prototype.checkForWrites = function checkForWrites(scope, node) {
		var _this3 = this;

		var addNode = function (node, isAssignment) {
			var depth = 0; // determine whether we're illegally modifying a binding or namespace

			while (node.type === 'MemberExpression') {
				node = node.object;
				depth += 1;
			}

			// disallow assignments/updates to imported bindings and namespaces
			if (isAssignment) {
				var importSpecifier = _this3.module.imports[node.name];

				if (importSpecifier && !scope.contains(node.name)) {
					var minDepth = importSpecifier.name === '*' ? 2 : // cannot do e.g. `namespace.foo = bar`
					1; // cannot do e.g. `foo = bar`, but `foo.bar = bar` is fine

					if (depth < minDepth) {
						var err = new Error('Illegal reassignment to import \'' + node.name + '\'');
						err.file = _this3.module.id;
						err.loc = getLocation(_this3.module.magicString.toString(), node.start);
						throw err;
					}
				}

				// special case = `export default foo; foo += 1;` - we'll
				// need to assign a new variable so that the exported
				// value is not updated by the second statement
				if (_this3.module.exports.default && depth === 0 && _this3.module.exports.default.identifier === node.name) {
					// but only if this is a) inside a function body or
					// b) after the export declaration
					if (!!scope.parent || node.start > _this3.module.exports.default.statement.node.start) {
						_this3.module.exports.default.isModified = true;
					}
				}
			}

			if (node.type === 'Identifier') {
				_this3.modifies[node.name] = true;
			}
		};

		if (node.type === 'AssignmentExpression') {
			addNode(node.left, true);
		} else if (node.type === 'UpdateExpression') {
			addNode(node.argument, true);
		} else if (node.type === 'CallExpression') {
			node.arguments.forEach(function (arg) {
				return addNode(arg, false);
			});

			// `foo.bar()` is assumed to mutate foo
			if (node.callee.type === 'MemberExpression') {
				addNode(node.callee);
			}
		}
	};

	Statement.prototype.mark = function mark() {
		var _this4 = this;

		if (this.isIncluded) return; // prevent infinite loops
		this.isIncluded = true;

		var dependencies = Object.keys(this.dependsOn);

		return sequence(dependencies, function (name) {
			if (_this4.defines[name]) return; // TODO maybe exclude from `this.dependsOn` in the first place?
			return _this4.module.mark(name);
		});
	};

	Statement.prototype.replaceIdentifiers = function replaceIdentifiers(magicString, names, bundleExports) {
		var replacementStack = [names];
		var nameList = keys(names);

		var deshadowList = [];
		nameList.forEach(function (name) {
			var replacement = names[name];
			deshadowList.push(replacement.split('.')[0]);
		});

		var topLevel = true;
		var depth = 0;

		walk(this.node, {
			enter: function (node, parent) {
				var _this5 = this;

				if (node._skip) return this.skip();

				if (/^Function/.test(node.type)) depth += 1;

				// `this` is undefined at the top level of ES6 modules
				if (node.type === 'ThisExpression' && depth === 0) {
					magicString.overwrite(node.start, node.end, 'undefined');
				}

				// special case - variable declarations that need to be rewritten
				// as bundle exports
				if (topLevel) {
					if (node.type === 'VariableDeclaration') {
						// if this contains a single declarator, and it's one that
						// needs to be rewritten, we replace the whole lot
						var _name = node.declarations[0].id.name;
						if (node.declarations.length === 1 && bundleExports[_name]) {
							magicString.overwrite(node.start, node.declarations[0].id.end, bundleExports[_name]);
							node.declarations[0].id._skip = true;
						}

						// otherwise, we insert the `exports.foo = foo` after the declaration
						else {
							var exportInitialisers = node.declarations.map(function (declarator) {
								return declarator.id.name;
							}).filter(function (name) {
								return !!bundleExports[name];
							}).map(function (name) {
								return '\n' + bundleExports[name] + ' = ' + name + ';';
							}).join('');

							if (exportInitialisers) {
								// TODO clean this up
								try {
									magicString.insert(node.end, exportInitialisers);
								} catch (err) {
									magicString.append(exportInitialisers);
								}
							}
						}
					}
				}

				var scope = node._scope;

				if (scope) {
					var _ret = (function () {
						topLevel = false;

						var newNames = blank();
						var hasReplacements = undefined;

						// special case = function foo ( foo ) {...}
						if (node.id && names[node.id.name] && scope.declarations[node.id.name]) {
							magicString.overwrite(node.id.start, node.id.end, names[node.id.name]);
						}

						keys(names).forEach(function (name) {
							if (!scope.declarations[name]) {
								newNames[name] = names[name];
								hasReplacements = true;
							}
						});

						deshadowList.forEach(function (name) {
							if (~scope.declarations[name]) {
								// TODO is this right? no indexOf?
								newNames[name] = name + '$$'; // TODO better mechanism
								hasReplacements = true;
							}
						});

						if (!hasReplacements && depth > 0) {
							return {
								v: _this5.skip()
							};
						}

						names = newNames;
						replacementStack.push(newNames);
					})();

					if (typeof _ret === 'object') return _ret.v;
				}

				if (node.type !== 'Identifier') return;

				// if there's no replacement, or it's the same, there's nothing more to do
				var name = names[node.name];
				if (!name || name === node.name) return;

				// shorthand properties (`obj = { foo }`) need to be expanded
				if (parent.type === 'Property' && parent.shorthand) {
					magicString.insert(node.end, ': ' + name);
					parent.key._skip = true;
					parent.value._skip = true; // redundant, but defensive
					return;
				}

				// property names etc can be disregarded
				if (parent.type === 'MemberExpression' && !parent.computed && node !== parent.object) return;
				if (parent.type === 'Property' && node !== parent.value) return;
				if (parent.type === 'MethodDefinition' && node === parent.key) return;
				// TODO others...?

				// all other identifiers should be overwritten
				magicString.overwrite(node.start, node.end, name);
			},

			leave: function (node) {
				if (/^Function/.test(node.type)) depth -= 1;

				if (node._scope) {
					replacementStack.pop();
					names = replacementStack[replacementStack.length - 1];
				}
			}
		});

		return magicString;
	};

	return Statement;
})();

var emptyArrayPromise = sander.Promise.resolve([]);

function deconflict(name, names) {
	while (name in names) {
		name = '_' + name;
	}

	return name;
}

function isEmptyExportedVarDeclaration(node, module, allBundleExports, es6) {
	if (node.type !== 'VariableDeclaration' || node.declarations[0].init) return false;

	var name = node.declarations[0].id.name;
	var canonicalName = module.getCanonicalName(name, es6);

	return canonicalName in allBundleExports;
}

var Module = (function () {
	function Module(_ref8) {
		var id = _ref8.id;
		var source = _ref8.source;
		var bundle = _ref8.bundle;

		_classCallCheck(this, Module);

		this.source = source;

		this.bundle = bundle;
		this.id = id;

		// By default, `id` is the filename. Custom resolvers and loaders
		// can change that, but it makes sense to use it for the source filename
		this.magicString = new MagicString(source, {
			filename: id
		});

		this.suggestedNames = blank();
		this.comments = [];

		this.statements = this._parse();

		// imports and exports, indexed by ID
		this.imports = blank();
		this.exports = blank();

		this.exportAlls = blank();

		// array of all-export sources
		this.exportDelegates = [];

		this.canonicalNames = blank();

		this.definitions = blank();
		this.definitionPromises = blank();
		this.modifications = blank();

		this.analyse();
	}

	Module.prototype.addExport = function addExport(statement) {
		var _this6 = this;

		var node = statement.node;
		var source = node.source && node.source.value;

		// export default function foo () {}
		// export default foo;
		// export default 42;
		if (node.type === 'ExportDefaultDeclaration') {
			var isDeclaration = /Declaration$/.test(node.declaration.type);
			var isAnonymous = /(?:Class|Function)Expression$/.test(node.declaration.type);

			var declaredName = isDeclaration && node.declaration.id.name;
			var identifier = node.declaration.type === 'Identifier' && node.declaration.name;

			this.exports.default = {
				statement: statement,
				name: 'default',
				localName: declaredName || 'default',
				declaredName: declaredName,
				identifier: identifier,
				isDeclaration: isDeclaration,
				isAnonymous: isAnonymous,
				isModified: false // in case of `export default foo; foo = somethingElse`
			};
		}

		// export { foo, bar, baz }
		// export var foo = 42;
		// export function foo () {}
		else if (node.type === 'ExportNamedDeclaration') {
			if (node.specifiers.length) {
				// export { foo, bar, baz }
				node.specifiers.forEach(function (specifier) {
					var localName = specifier.local.name;
					var exportedName = specifier.exported.name;

					_this6.exports[exportedName] = {
						localName: localName,
						exportedName: exportedName
					};

					// export { foo } from './foo';
					if (source) {
						_this6.imports[localName] = {
							source: source,
							localName: localName,
							name: localName
						};
					}
				});
			} else {
				var declaration = node.declaration;

				var _name2 = undefined;

				if (declaration.type === 'VariableDeclaration') {
					// export var foo = 42
					_name2 = declaration.declarations[0].id.name;
				} else {
					// export function foo () {}
					_name2 = declaration.id.name;
				}

				this.exports[_name2] = {
					statement: statement,
					localName: _name2,
					expression: declaration
				};
			}
		}

		// Store `export * from '...'` statements in an array of delegates.
		// When an unknown import is encountered, we see if one of them can satisfy it.
		else {
			this.exportDelegates.push({
				statement: statement,
				source: source
			});
		}
	};

	Module.prototype.addImport = function addImport(statement) {
		var _this7 = this;

		var node = statement.node;
		var source = node.source.value;

		node.specifiers.forEach(function (specifier) {
			var isDefault = specifier.type === 'ImportDefaultSpecifier';
			var isNamespace = specifier.type === 'ImportNamespaceSpecifier';

			var localName = specifier.local.name;
			var name = isDefault ? 'default' : isNamespace ? '*' : specifier.imported.name;

			if (_this7.imports[localName]) {
				var err = new Error('Duplicated import \'' + localName + '\'');
				err.file = _this7.id;
				err.loc = getLocation(_this7.source, specifier.start);
				throw err;
			}

			_this7.imports[localName] = {
				source: source,
				name: name,
				localName: localName
			};
		});
	};

	Module.prototype.analyse = function analyse() {
		var _this8 = this;

		// discover this module's imports and exports
		this.statements.forEach(function (statement) {
			if (statement.isImportDeclaration) _this8.addImport(statement);else if (statement.isExportDeclaration) _this8.addExport(statement);

			statement.analyse();

			// consolidate names that are defined/modified in this module
			keys(statement.defines).forEach(function (name) {
				_this8.definitions[name] = statement;
			});

			keys(statement.modifies).forEach(function (name) {
				(_this8.modifications[name] || (_this8.modifications[name] = [])).push(statement);
			});
		});

		// if names are referenced that are neither defined nor imported
		// in this module, we assume that they're globals
		this.statements.forEach(function (statement) {
			keys(statement.dependsOn).forEach(function (name) {
				if (!_this8.definitions[name] && !_this8.imports[name]) {
					_this8.bundle.assumedGlobals[name] = true;
				}
			});
		});
	};

	Module.prototype.consolidateDependencies = function consolidateDependencies() {
		var _this9 = this;

		var strongDependencies = blank();

		this.statements.forEach(function (statement) {
			if (statement.isImportDeclaration && !statement.node.specifiers.length && !statement.module.isExternal) {
				// include module for its side-effects
				strongDependencies[statement.module.id] = statement.module; // TODO is this right? `statement.module` should be `this`, surely?
			}

			keys(statement.stronglyDependsOn).forEach(function (name) {
				if (statement.defines[name]) return;

				var exportAllDeclaration = _this9.exportAlls[name];

				if (exportAllDeclaration && exportAllDeclaration.module && !exportAllDeclaration.module.isExternal) {
					strongDependencies[exportAllDeclaration.module.id] = exportAllDeclaration.module;
					return;
				}

				var importDeclaration = _this9.imports[name];

				if (importDeclaration && importDeclaration.module && !importDeclaration.module.isExternal) {
					strongDependencies[importDeclaration.module.id] = importDeclaration.module;
				}
			});
		});

		var weakDependencies = blank();

		this.statements.forEach(function (statement) {
			keys(statement.dependsOn).forEach(function (name) {
				if (statement.defines[name]) return;

				var importDeclaration = _this9.imports[name];

				if (importDeclaration && importDeclaration.module && !importDeclaration.module.isExternal) {
					weakDependencies[importDeclaration.module.id] = importDeclaration.module;
				}
			});
		});

		return { strongDependencies: strongDependencies, weakDependencies: weakDependencies };
	};

	Module.prototype.findDefiningStatement = function findDefiningStatement(name) {
		if (this.definitions[name]) return this.definitions[name];

		// TODO what about `default`/`*`?

		var importDeclaration = this.imports[name];
		if (!importDeclaration) return null;

		return sander.Promise.resolve(importDeclaration.module || this.bundle.fetchModule(importDeclaration.source, this.id)).then(function (module) {
			importDeclaration.module = module;
			return module.findDefiningStatement(name);
		});
	};

	Module.prototype.findDeclaration = function findDeclaration(localName) {
		var importDeclaration = this.imports[localName];

		// name was defined by another module
		if (importDeclaration) {
			var _module = importDeclaration.module;

			if (_module.isExternal) return null;

			var exportDeclaration = _module.exports[importDeclaration.name];
			return _module.findDeclaration(exportDeclaration.localName);
		}

		// name was defined by this module, if any
		var i = this.statements.length;
		while (i--) {
			var declaration = this.statements[i].scope.declarations[localName];
			if (declaration) {
				return declaration;
			}
		}

		return null;
	};

	Module.prototype.getCanonicalName = function getCanonicalName(localName, es6) {
		// Special case
		if (localName === 'default' && (this.exports.default.isModified || !this.suggestedNames.default)) {
			var canonicalName = makeLegalIdentifier(this.id.replace(dirname(this.bundle.entryModule.id) + '/', '').replace(/\.js$/, ''));
			return deconflict(canonicalName, this.definitions);
		}

		if (this.suggestedNames[localName]) {
			localName = this.suggestedNames[localName];
		}

		var id = localName + (es6 ? '-es6' : ''); // TODO ugh this seems like a terrible hack

		if (!this.canonicalNames[id]) {
			var canonicalName = undefined;

			if (this.imports[localName]) {
				var importDeclaration = this.imports[localName];
				var _module2 = importDeclaration.module;

				if (importDeclaration.name === '*') {
					canonicalName = _module2.suggestedNames['*'];
				} else {
					var exporterLocalName = undefined;

					if (_module2.isExternal) {
						exporterLocalName = importDeclaration.name;
					} else {
						var exportDeclaration = _module2.exports[importDeclaration.name];

						// The export declaration of the particular name is known.
						if (exportDeclaration) {
							exporterLocalName = exportDeclaration.localName;
						} else {
							// export * from '...'
							exporterLocalName = importDeclaration.name;
						}
					}

					canonicalName = _module2.getCanonicalName(exporterLocalName, es6);
				}
			} else {
				canonicalName = localName;
			}

			this.canonicalNames[id] = canonicalName;
		}

		return this.canonicalNames[id];
	};

	Module.prototype.mark = function mark(name) {
		var _this10 = this;

		// shortcut cycles. TODO this won't work everywhere...
		if (this.definitionPromises[name]) {
			return emptyArrayPromise;
		}

		var promise = undefined;

		// The definition for this name is in a different module
		if (this.imports[name]) {
			(function () {
				var importDeclaration = _this10.imports[name];

				promise = _this10.bundle.fetchModule(importDeclaration.source, _this10.id).then(function (module) {
					importDeclaration.module = module;

					// suggest names. TODO should this apply to non default/* imports?
					if (importDeclaration.name === 'default') {
						// TODO this seems ropey
						var localName = importDeclaration.localName;
						var suggestion = _this10.suggestedNames[localName] || localName;

						// special case - the module has its own import by this name
						while (!module.isExternal && module.imports[suggestion]) {
							suggestion = '_' + suggestion;
						}

						module.suggestName('default', suggestion);
					} else if (importDeclaration.name === '*') {
						var localName = importDeclaration.localName;
						var suggestion = _this10.suggestedNames[localName] || localName;
						module.suggestName('*', suggestion);
						module.suggestName('default', suggestion + '__default');
					}

					if (module.isExternal) {
						if (importDeclaration.name === 'default') {
							module.needsDefault = true;
						} else if (importDeclaration.name === '*') {
							module.needsAll = true;
						} else {
							module.needsNamed = true;
						}

						module.importedByBundle.push(importDeclaration);
						return emptyArrayPromise;
					}

					if (importDeclaration.name === '*') {
						// we need to create an internal namespace
						if (! ~_this10.bundle.internalNamespaceModules.indexOf(module)) {
							_this10.bundle.internalNamespaceModules.push(module);
						}

						return module.markAllStatements();
					}

					var exportDeclaration = module.exports[importDeclaration.name];

					if (!exportDeclaration) {
						var _ret3 = (function () {
							var noExport = new Error('Module ' + module.id + ' does not export ' + importDeclaration.name + ' (imported by ' + _this10.id + ')');

							// See if there exists an export delegate that defines `name`.
							return {
								v: first(module.exportDelegates, noExport, function (declaration) {
									return module.bundle.fetchModule(declaration.source, module.id).then(function (submodule) {
										declaration.module = submodule;

										return submodule.mark(name).then(function (result) {
											if (!result.length) throw noExport;

											// It's found! This module exports `name` through declaration.
											// It is however not imported into this scope.
											module.exportAlls[name] = declaration;

											declaration.statement.dependsOn[name] = declaration.statement.stronglyDependsOn[name] = result;

											return result;
										});
									});
								})
							};
						})();

						if (typeof _ret3 === 'object') return _ret3.v;
					}

					exportDeclaration.isUsed = true;
					return module.mark(exportDeclaration.localName);
				});
			})();
		}

		// The definition is in this module
		else if (name === 'default' && this.exports.default.isDeclaration) {
			// We have something like `export default foo` - so we just start again,
			// searching for `foo` instead of default
			promise = this.mark(this.exports.default.name);
		} else {
			(function () {
				var statement = undefined;

				statement = name === 'default' ? _this10.exports.default.statement : _this10.definitions[name];
				promise = statement && !statement.isIncluded ? statement.mark() : emptyArrayPromise;

				// Special case - `export default foo; foo += 1` - need to be
				// vigilant about maintaining the correct order of the export
				// declaration. Otherwise, the export declaration will always
				// go at the end of the expansion, because the expansion of
				// `foo` will include statements *after* the declaration
				if (name === 'default' && _this10.exports.default.identifier && _this10.exports.default.isModified) {
					(function () {
						var defaultExportStatement = _this10.exports.default.statement;
						promise = promise.then(function (statements) {
							// remove the default export statement...
							// TODO could this be statements.pop()?
							statements.splice(statements.indexOf(defaultExportStatement), 1);

							var i = statements.length;
							var inserted = false;

							while (i--) {
								if (statements[i].module === _this10 && statements[i].index < defaultExportStatement.index) {
									statements.splice(i + 1, 0, defaultExportStatement);
									inserted = true;
									break;
								}
							}

							if (!inserted) statements.push(statement);
							return statements;
						});
					})();
				}
			})();
		}

		this.definitionPromises[name] = promise || emptyArrayPromise;
		return this.definitionPromises[name];
	};

	Module.prototype.markAllStatements = function markAllStatements(isEntryModule) {
		var _this11 = this;

		return sequence(this.statements, function (statement) {
			if (statement.isIncluded) return; // TODO can this happen? probably not...

			// skip import declarations...
			if (statement.isImportDeclaration) {
				// ...unless they're empty, in which case assume we're importing them for the side-effects
				// THIS IS NOT FOOLPROOF. Probably need /*rollup: include */ or similar
				if (!statement.node.specifiers.length) {
					return _this11.bundle.fetchModule(statement.node.source.value, _this11.id).then(function (module) {
						statement.module = module;
						if (module.isExternal) {
							return;
						}
						return module.markAllStatements();
					});
				}

				return;
			}

			// skip `export { foo, bar, baz }`...
			if (statement.node.type === 'ExportNamedDeclaration' && statement.node.specifiers.length) {
				// ...but ensure they are defined, if this is the entry module
				if (isEntryModule) {
					return statement.mark();
				}

				return;
			}

			// include everything else
			return statement.mark();
		});
	};

	// TODO rename this to parse, once https://github.com/rollup/rollup/issues/42 is fixed

	Module.prototype._parse = function _parse() {
		var _this12 = this;

		// Try to extract a list of top-level statements/declarations. If
		// the parse fails, attach file info and abort
		var ast = undefined;

		try {
			ast = acorn.parse(this.source, {
				ecmaVersion: 6,
				sourceType: 'module',
				onComment: function (block, text, start, end) {
					return _this12.comments.push({ block: block, text: text, start: start, end: end });
				}
			});
		} catch (err) {
			err.code = 'PARSE_ERROR';
			err.file = this.id; // see above - not necessarily true, but true enough
			throw err;
		}

		walk(ast, {
			enter: function (node) {
				_this12.magicString.addSourcemapLocation(node.start);
				_this12.magicString.addSourcemapLocation(node.end);
			}
		});

		var statements = [];
		var lastChar = 0;
		var commentIndex = 0;

		ast.body.forEach(function (node) {
			// special case - top-level var declarations with multiple declarators
			// should be split up. Otherwise, we may end up including code we
			// don't need, just because an unwanted declarator is included
			if (node.type === 'VariableDeclaration' && node.declarations.length > 1) {
				// remove the leading var/let/const
				_this12.magicString.remove(node.start, node.declarations[0].start);

				node.declarations.forEach(function (declarator, i) {
					var start = declarator.start;
					var end = declarator.end;

					var syntheticNode = {
						type: 'VariableDeclaration',
						kind: node.kind,
						start: start,
						end: end,
						declarations: [declarator],
						isSynthetic: true
					};

					var statement = new Statement(syntheticNode, _this12, start, end);
					statements.push(statement);
				});

				lastChar = node.end; // TODO account for trailing line comment
			} else {
				var comment = undefined;
				do {
					comment = _this12.comments[commentIndex];
					if (!comment) break;
					if (comment.start > node.start) break;
					commentIndex += 1;
				} while (comment.end < lastChar);

				var start = comment ? Math.min(comment.start, node.start) : node.start;
				var end = node.end; // TODO account for trailing line comment

				var statement = new Statement(node, _this12, start, end);
				statements.push(statement);

				lastChar = end;
			}
		});

		statements.forEach(function (statement, i) {
			var nextStatement = statements[i + 1];
			statement.next = nextStatement ? nextStatement.start : statement.end;
		});

		return statements;
	};

	Module.prototype.rename = function rename(name, replacement) {
		// TODO again, hacky...
		this.canonicalNames[name] = this.canonicalNames[name + '-es6'] = replacement;
	};

	Module.prototype.render = function render(allBundleExports, format) {
		var magicString = this.magicString.clone();

		var previousIndex = -1;
		var previousMargin = 0;

		this.statements.forEach(function (statement, i) {
			if (!statement.isIncluded) {
				magicString.remove(statement.start, statement.next);
				return;
			}

			// skip `export { foo, bar, baz }`
			if (statement.node.type === 'ExportNamedDeclaration') {
				// skip `export { foo, bar, baz }`
				if (statement.node.specifiers.length) {
					magicString.remove(statement.start, statement.next);
					return;
				};

				// skip `export var foo;` if foo is exported
				if (isEmptyExportedVarDeclaration(statement.node.declaration, statement.module, allBundleExports, format === 'es6')) {
					magicString.remove(statement.start, statement.next);
					return;
				}
			}

			// skip empty var declarations for exported bindings
			// (otherwise we're left with `exports.foo;`, which is useless)
			if (isEmptyExportedVarDeclaration(statement.node, statement.module, allBundleExports, format === 'es6')) {
				magicString.remove(statement.start, statement.next);
				return;
			}

			// split up/remove var declarations as necessary
			if (statement.node.isSynthetic) {
				magicString.insert(statement.start, statement.node.kind + ' ');
				magicString.overwrite(statement.end, statement.next, ';\n'); // TODO account for trailing newlines
			}

			var replacements = blank();
			var bundleExports = blank();

			keys(statement.dependsOn).concat(keys(statement.defines)).forEach(function (name) {
				var canonicalName = statement.module.getCanonicalName(name, format === 'es6');

				if (allBundleExports[canonicalName]) {
					bundleExports[name] = replacements[name] = allBundleExports[canonicalName];
				} else if (name !== canonicalName) {
					replacements[name] = canonicalName;
				}
			});

			statement.replaceIdentifiers(magicString, replacements, bundleExports);

			// modify exports as necessary
			if (statement.isExportDeclaration) {
				// remove `export` from `export var foo = 42`
				if (statement.node.type === 'ExportNamedDeclaration' && statement.node.declaration.type === 'VariableDeclaration') {
					magicString.remove(statement.node.start, statement.node.declaration.start);
				}

				// remove `export` from `export class Foo {...}` or `export default Foo`
				// TODO default exports need different treatment
				else if (statement.node.declaration.id) {
					magicString.remove(statement.node.start, statement.node.declaration.start);
				} else if (statement.node.type === 'ExportDefaultDeclaration') {
					var _module3 = statement.module;
					var canonicalName = _module3.getCanonicalName('default', format === 'es6');

					if (statement.node.declaration.type === 'Identifier' && canonicalName === _module3.getCanonicalName(statement.node.declaration.name, format === 'es6')) {
						magicString.remove(statement.start, statement.next);
						return;
					}

					// anonymous functions should be converted into declarations
					if (statement.node.declaration.type === 'FunctionExpression') {
						magicString.overwrite(statement.node.start, statement.node.declaration.start + 8, 'function ' + canonicalName);
					} else {
						magicString.overwrite(statement.node.start, statement.node.declaration.start, 'var ' + canonicalName + ' = ');
					}
				} else {
					throw new Error('Unhandled export');
				}
			}
		});

		return magicString.trim();
	};

	Module.prototype.suggestName = function suggestName(defaultOrBatch, suggestion) {
		// deconflict anonymous default exports with this module's definitions
		var shouldDeconflict = this.exports.default && this.exports.default.isAnonymous;

		if (shouldDeconflict) suggestion = deconflict(suggestion, this.definitions);

		if (!this.suggestedNames[defaultOrBatch]) {
			this.suggestedNames[defaultOrBatch] = makeLegalIdentifier(suggestion);
		}
	};

	return Module;
})();

var ExternalModule = (function () {
	function ExternalModule(id) {
		_classCallCheck(this, ExternalModule);

		this.id = id;
		this.name = null;

		this.isExternal = true;
		this.importedByBundle = [];

		this.canonicalNames = blank();
		this.suggestedNames = blank();

		this.needsDefault = false;

		// Invariant: needsNamed and needsAll are never both true at once.
		// Because an import with both a namespace and named import is invalid:
		//
		// 		import * as ns, { a } from '...'
		//
		this.needsNamed = false;
		this.needsAll = false;
	}

	ExternalModule.prototype.findDefiningStatement = function findDefiningStatement() {
		return null;
	};

	ExternalModule.prototype.getCanonicalName = function getCanonicalName(name, es6) {
		if (name === 'default') {
			return this.needsNamed && !es6 ? this.name + '__default' : this.name;
		}

		if (name === '*') {
			return this.name; // TODO is this correct in ES6?
		}

		return es6 ? this.canonicalNames[name] || name : this.name + '.' + name;
	};

	ExternalModule.prototype.rename = function rename(name, replacement) {
		this.canonicalNames[name] = replacement;
	};

	ExternalModule.prototype.suggestName = function suggestName(exportName, suggestion) {
		if (!this.suggestedNames[exportName]) {
			this.suggestedNames[exportName] = suggestion;
		}
	};

	return ExternalModule;
})();

function ensureArray(thing) {
	if (Array.isArray(thing)) return thing;
	if (thing == undefined) return [];
	return [thing];
}

function defaultResolver(importee, importer, options) {
	// absolute paths are left untouched
	if (isAbsolute(importee)) return importee;

	// if this is the entry point, resolve against cwd
	if (importer === undefined) return resolve(process.cwd(), importee);

	// we try to resolve external modules
	if (importee[0] !== '.') {
		// unless we want to keep it external, that is
		if (~options.external.indexOf(importee)) return null;

		return options.resolveExternal(importee, importer, options);
	}

	return resolve(dirname(importer), importee).replace(/\.js$/, '') + '.js';
}

function defaultExternalResolver(id, importer) {
	// for now, only node_modules is supported, and only jsnext:main
	var root = absolutePath.exec(importer)[0];
	var dir = dirname(importer);

	while (dir !== root) {
		var pkgPath = resolve(dir, 'node_modules', id, 'package.json');
		var pkgJson = undefined;

		try {
			pkgJson = sander.readFileSync(pkgPath).toString();
		} catch (err) {}

		if (pkgJson) {
			var pkg = undefined;

			try {
				pkg = JSON.parse(pkgJson);
			} catch (err) {
				throw new Error('Malformed JSON: ' + pkgPath);
			}

			var main = pkg['jsnext:main'];

			if (!main) {
				throw new Error('Package ' + id + ' does not have a jsnext:main field, and so cannot be included in your rollup. Try adding it as an external module instead (e.g. options.external = [\'' + id + '\']). See https://github.com/rollup/rollup/wiki/jsnext:main for more info');
			}

			return resolve(dirname(pkgPath), main).replace(/\.js$/, '') + '.js';
		}

		dir = dirname(dir);
	}

	throw new Error('Could not find package ' + id + ' (required by ' + importer + ')');
}

function defaultLoader(id, options) {
	// TODO support plugins e.g. !css and !json?
	var source = sander.readFileSync(id, { encoding: 'utf-8' });

	return options.transform.reduce(function (source, transformer) {
		return transformer(source, id);
	}, source);
}

var Bundle = (function () {
	function Bundle(options) {
		_classCallCheck(this, Bundle);

		this.entry = options.entry;
		this.entryModule = null;

		this.resolveId = options.resolveId || defaultResolver;
		this.load = options.load || defaultLoader;

		this.resolveOptions = {
			external: ensureArray(options.external),
			resolveExternal: options.resolveExternal || defaultExternalResolver
		};

		this.loadOptions = {
			transform: ensureArray(options.transform)
		};

		this.varExports = blank();
		this.toExport = null;

		this.modulePromises = blank();
		this.modules = [];

		this.statements = null;
		this.externalModules = [];
		this.internalNamespaceModules = [];
		this.assumedGlobals = blank();
	}

	Bundle.prototype.build = function build() {
		var _this13 = this;

		return this.fetchModule(this.entry, undefined).then(function (entryModule) {
			var defaultExport = entryModule.exports.default;

			_this13.entryModule = entryModule;

			if (defaultExport) {
				// `export default function foo () {...}` -
				// use the declared name for the export
				if (defaultExport.declaredName) {
					entryModule.suggestName('default', defaultExport.declaredName);
				}

				// `export default a + b` - generate an export name
				// based on the id of the entry module
				else {
					(function () {
						var defaultExportName = makeLegalIdentifier(basename(_this13.entryModule.id).slice(0, -extname(_this13.entryModule.id).length));

						// deconflict
						var topLevelNames = [];
						entryModule.statements.forEach(function (statement) {
							keys(statement.defines).forEach(function (name) {
								return topLevelNames.push(name);
							});
						});

						while (~topLevelNames.indexOf(defaultExportName)) {
							defaultExportName = '_' + defaultExportName;
						}

						entryModule.suggestName('default', defaultExportName);
					})();
				}
			}

			return entryModule.markAllStatements(true);
		}).then(function () {
			return _this13.markAllModifierStatements();
		}).then(function () {
			_this13.orderedModules = _this13.sort();
		});
	};

	Bundle.prototype.deconflict = function deconflict(es6) {
		var _this14 = this;

		var definers = blank();
		var conflicts = blank();

		// Assign names to external modules
		this.externalModules.forEach(function (module) {
			// TODO is this right?
			var name = makeLegalIdentifier(module.suggestedNames['*'] || module.suggestedNames.default || module.id);

			if (definers[name]) {
				conflicts[name] = true;
			} else {
				definers[name] = [];
			}

			definers[name].push(module);
			module.name = name;
			_this14.assumedGlobals[name] = true;
		});

		// Discover conflicts (i.e. two statements in separate modules both define `foo`)
		this.orderedModules.forEach(function (module) {
			module.statements.forEach(function (statement) {
				var names = keys(statement.defines);

				// with default exports that are expressions (`export default 42`),
				// we need to ensure that the name chosen for the expression does
				// not conflict
				if (statement.node.type === 'ExportDefaultDeclaration') {
					var _name3 = module.getCanonicalName('default', es6);

					var isProxy = statement.node.declaration && statement.node.declaration.type === 'Identifier';
					var shouldDeconflict = !isProxy || module.getCanonicalName(statement.node.declaration.name, es6) !== _name3;

					if (shouldDeconflict && ! ~names.indexOf(_name3)) {
						names.push(_name3);
					}
				}

				names.forEach(function (name) {
					if (definers[name]) {
						conflicts[name] = true;
					} else {
						definers[name] = [];
					}

					// TODO in good js, there shouldn't be duplicate definitions
					// per module... but some people write bad js
					definers[name].push(module);
				});
			});
		});

		// Ensure we don't conflict with globals
		keys(this.assumedGlobals).forEach(function (name) {
			if (definers[name]) {
				conflicts[name] = true;
			}
		});

		// Rename conflicting identifiers so they can live in the same scope
		keys(conflicts).forEach(function (name) {
			var modules = definers[name];

			if (!_this14.assumedGlobals[name]) {
				// the module closest to the entryModule gets away with
				// keeping things as they are, unless we have a conflict
				// with a global name
				modules.pop();
			}

			modules.forEach(function (module) {
				var replacement = getSafeName(name);
				module.rename(name, replacement);
			});
		});

		function getSafeName(name) {
			while (conflicts[name]) {
				name = '_' + name;
			}

			conflicts[name] = true;
			return name;
		}
	};

	Bundle.prototype.fetchModule = function fetchModule(importee, importer) {
		var _this15 = this;

		return sander.Promise.resolve(this.resolveId(importee, importer, this.resolveOptions)).then(function (id) {
			if (!id) {
				// external module
				if (!_this15.modulePromises[importee]) {
					var _module4 = new ExternalModule(importee);
					_this15.externalModules.push(_module4);
					_this15.modulePromises[importee] = sander.Promise.resolve(_module4);
				}

				return _this15.modulePromises[importee];
			}

			if (!_this15.modulePromises[id]) {
				_this15.modulePromises[id] = sander.Promise.resolve(_this15.load(id, _this15.loadOptions)).then(function (source) {
					var module = new Module({
						id: id,
						source: source,
						bundle: _this15
					});

					_this15.modules.push(module);

					return module;
				});
			}

			return _this15.modulePromises[id];
		});
	};

	Bundle.prototype.markAllModifierStatements = function markAllModifierStatements() {
		var _this16 = this;

		var settled = true;
		var promises = [];

		this.modules.forEach(function (module) {
			module.statements.forEach(function (statement) {
				if (statement.isIncluded) return;

				keys(statement.modifies).forEach(function (name) {
					var definingStatement = module.definitions[name];
					var exportDeclaration = module.exports[name] || module.exports.default && module.exports.default.identifier === name && module.exports.default;

					var shouldMark = definingStatement && definingStatement.isIncluded || exportDeclaration && exportDeclaration.isUsed;

					if (shouldMark) {
						settled = false;
						promises.push(statement.mark());
						return;
					}

					// special case - https://github.com/rollup/rollup/pull/40
					var importDeclaration = module.imports[name];
					if (!importDeclaration) return;

					var promise = sander.Promise.resolve(importDeclaration.module || _this16.fetchModule(importDeclaration.source, module.id)).then(function (module) {
						importDeclaration.module = module;
						var exportDeclaration = module.exports[importDeclaration.name];
						// TODO things like `export default a + b` don't apply here... right?
						return module.findDefiningStatement(exportDeclaration.localName);
					}).then(function (definingStatement) {
						if (!definingStatement) return;

						settled = false;
						return statement.mark();
					});

					promises.push(promise);
				});
			});
		});

		return sander.Promise.all(promises).then(function () {
			if (!settled) return _this16.markAllModifierStatements();
		});
	};

	Bundle.prototype.render = function render() {
		var _this17 = this;

		var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

		var format = options.format || 'es6';
		this.deconflict(format === 'es6');

		// If we have named exports from the bundle, and those exports
		// are assigned to *within* the bundle, we may need to rewrite e.g.
		//
		//   export let count = 0;
		//   export function incr () { count++ }
		//
		// might become...
		//
		//   exports.count = 0;
		//   function incr () {
		//     exports.count += 1;
		//   }
		//   exports.incr = incr;
		//
		// This doesn't apply if the bundle is exported as ES6!
		var allBundleExports = blank();

		if (format !== 'es6') {
			keys(this.entryModule.exports).forEach(function (key) {
				var exportDeclaration = _this17.entryModule.exports[key];

				var originalDeclaration = _this17.entryModule.findDeclaration(exportDeclaration.localName);

				if (originalDeclaration && originalDeclaration.type === 'VariableDeclaration') {
					var canonicalName = _this17.entryModule.getCanonicalName(exportDeclaration.localName, false);

					allBundleExports[canonicalName] = 'exports.' + key;
					_this17.varExports[key] = true;
				}
			});
		}

		// since we're rewriting variable exports, we want to
		// ensure we don't try and export them again at the bottom
		this.toExport = keys(this.entryModule.exports).filter(function (key) {
			return !_this17.varExports[key];
		});

		var magicString = new MagicString.Bundle({ separator: '\n\n' });

		this.orderedModules.forEach(function (module) {
			var source = module.render(allBundleExports, format);
			if (source.toString().length) {
				magicString.addSource(source);
			}
		});

		// prepend bundle with internal namespaces
		var indentString = magicString.getIndentString();
		var namespaceBlock = this.internalNamespaceModules.map(function (module) {
			var exportKeys = keys(module.exports);

			return 'var ' + module.getCanonicalName('*', format === 'es6') + ' = {\n' + exportKeys.map(function (key) {
				return indentString + 'get ' + key + ' () { return ' + module.getCanonicalName(key, format === 'es6') + '; }';
			}).join(',\n') + '\n};\n\n';
		}).join('');

		magicString.prepend(namespaceBlock);

		var finalise = finalisers[format];

		if (!finalise) {
			throw new Error('You must specify an output type - valid options are ' + keys(finalisers).join(', '));
		}

		magicString = finalise(this, magicString.trim(), {
			// Determine export mode - 'default', 'named', 'none'
			exportMode: getExportMode(this, options.exports),

			// Determine indentation
			indentString: getIndentString(magicString, options)
		}, options);

		var code = magicString.toString();
		var map = null;

		if (options.sourceMap) {
			var file = options.sourceMapFile || options.dest;
			map = magicString.generateMap({
				includeContent: true,
				file
				// TODO
				: file });

			map.sources = map.sources.map(unixizePath);
		}

		return { code: code, map: map };
	};

	Bundle.prototype.sort = function sort() {
		var seen = {};
		var ordered = [];
		var hasCycles = undefined;

		var strongDeps = {};
		var stronglyDependsOn = {};

		function visit(module) {
			seen[module.id] = true;

			var _module$consolidateDependencies = module.consolidateDependencies();

			var strongDependencies = _module$consolidateDependencies.strongDependencies;
			var weakDependencies = _module$consolidateDependencies.weakDependencies;

			strongDeps[module.id] = [];
			stronglyDependsOn[module.id] = {};

			keys(strongDependencies).forEach(function (id) {
				var imported = strongDependencies[id];

				strongDeps[module.id].push(imported);

				if (seen[id]) {
					// we need to prevent an infinite loop, and note that
					// we need to check for strong/weak dependency relationships
					hasCycles = true;
					return;
				}

				visit(imported);
			});

			keys(weakDependencies).forEach(function (id) {
				var imported = weakDependencies[id];

				if (seen[id]) {
					// we need to prevent an infinite loop, and note that
					// we need to check for strong/weak dependency relationships
					hasCycles = true;
					return;
				}

				visit(imported);
			});

			// add second (and third...) order dependencies
			function addStrongDependencies(dependency) {
				if (stronglyDependsOn[module.id][dependency.id]) return;

				stronglyDependsOn[module.id][dependency.id] = true;
				strongDeps[dependency.id].forEach(addStrongDependencies);
			}

			strongDeps[module.id].forEach(addStrongDependencies);

			ordered.push(module);
		}

		visit(this.entryModule);

		if (hasCycles) {
			var unordered = ordered;
			ordered = [];

			// unordered is actually semi-ordered, as [ fewer dependencies ... more dependencies ]
			unordered.forEach(function (module) {
				// ensure strong dependencies of `module` that don't strongly depend on `module` go first
				strongDeps[module.id].forEach(place);

				function place(dep) {
					if (!stronglyDependsOn[dep.id][module.id] && ! ~ordered.indexOf(dep)) {
						strongDeps[dep.id].forEach(place);
						ordered.push(dep);
					}
				}

				if (! ~ordered.indexOf(module)) {
					ordered.push(module);
				}
			});
		}

		return ordered;
	};

	return Bundle;
})();

var SOURCEMAPPING_URL = 'sourceMa';
SOURCEMAPPING_URL += 'ppingURL';

function rollup(options) {
	if (!options || !options.entry) {
		throw new Error('You must supply options.entry to rollup');
	}

	var bundle = new Bundle(options);

	return bundle.build().then(function () {
		return {
			generate: function (options) {
				return bundle.render(options);
			},
			write: function (options) {
				if (!options || !options.dest) {
					throw new Error('You must supply options.dest to bundle.write');
				}

				var dest = options.dest;

				var _bundle$render = bundle.render(options);

				var code = _bundle$render.code;
				var map = _bundle$render.map;

				var promises = [];

				if (options.sourceMap) {
					var url = undefined;

					if (options.sourceMap === 'inline') {
						url = map.toUrl();
					} else {
						url = basename(dest) + '.map';
						promises.push(sander.writeFile(dest + '.map', map.toString()));
					}

					code += '\n//# ' + SOURCEMAPPING_URL + '=' + url;
				}

				promises.push(sander.writeFile(dest, code));
				return Promise.all(promises);
			}
		};
	});
}

exports.rollup = rollup;

// noop
//# sourceMappingURL=rollup.js.map