rollup/dist/rollup.js

'use strict';

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

var keys = Object.keys;

var hasOwnProp = Object.prototype.hasOwnProperty;function has(obj, prop) {
	return hasOwnProp.call(obj, prop);
}

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

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 getName(x) {
	return x.name;
}

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

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

function isImportDeclaration(statement) {
	return statement.isImportDeclaration;
}

function isExportDeclaration(statement) {
	return statement.isExportDeclaration;
}

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 shouldSkip = undefined;
var shouldAbort = undefined;
function walk(ast, _ref) {
	var enter = _ref.enter;
	var leave = _ref.leave;

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

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

var childKeys = {};

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 Scope___classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Scope = (function () {
	function Scope(options) {
		Scope___classCallCheck(this, Scope);

		options = options || {};

		this.parent = options.parent;
		this.depth = this.parent ? this.parent.depth + 1 : 0;
		this.names = options.params || [];
		this.isBlockScope = !!options.block;
	}

	Scope.prototype.add = function 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.contains = function contains(name) {
		return !!this.findDefiningScope(name);
	};

	Scope.prototype.findDefiningScope = function findDefiningScope(name) {
		if (~this.names.indexOf(name)) {
			return this;
		}

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

		return null;
	};

	return Scope;
})();

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

var Statement__emptyArrayPromise = Promise.resolve([]);

var Statement = (function () {
	function Statement(node, magicString, module) {
		Statement___classCallCheck(this, Statement);

		this.node = node;
		this.module = module;
		this.magicString = magicString;

		this.scope = new Scope();
		this.defines = {};
		this.modifies = {};
		this.dependsOn = {};

		this.isIncluded = false;

		this.leadingComments = [];
		this.trailingComment = null;
		this.margin = [0, 0];

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

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

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

		var statement = this; // TODO use arrow functions instead
		var magicString = this.magicString;

		var scope = this.scope;

		function addToScope(declarator) {
			var name = declarator.id.name;
			scope.add(name, false);

			if (!scope.parent) {
				statement.defines[name] = true;
			}
		}

		function addToBlockScope(declarator) {
			var name = declarator.id.name;
			scope.add(name, true);

			if (!scope.parent) {
				statement.defines[name] = true;
			}
		}

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

				magicString.addSourcemapLocation(node.start);

				switch (node.type) {
					case 'FunctionExpression':
					case 'FunctionDeclaration':
					case 'ArrowFunctionExpression':
						var names = node.params.map(getName);

						if (node.type === 'FunctionDeclaration') {
							addToScope(node);
						} else if (node.type === 'FunctionExpression' && node.id) {
							names.push(node.id.name);
						}

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

						break;

					case 'BlockStatement':
						newScope = new Scope({
							parent: scope,
							block: true
						});

						break;

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

						break;

					case 'VariableDeclaration':
						node.declarations.forEach(node.kind === 'let' ? addToBlockScope : addToScope); // TODO const?
						break;

					case 'ClassDeclaration':
						addToScope(node);
						break;
				}

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

		if (!this.isImportDeclaration) {
			walk(this.node, {
				enter: function (node, parent) {
					if (node._scope) scope = node._scope;

					_this.checkForReads(scope, node, parent);
					_this.checkForWrites(scope, node);
				},
				leave: function (node) {
					if (node._scope) scope = scope.parent;
				}
			});
		}
	};

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

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

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

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

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

		var addNode = function (node, disallowImportReassignments) {
			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 (disallowImportReassignments) {
				var importSpecifier = _this2.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 = _this2.module.path;
						err.loc = getLocation(_this2.module.magicString.toString(), node.start);
						throw err;
					}
				}
			}

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

			_this2.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);
			});
		}
	};

	Statement.prototype.expand = function expand() {
		var _this3 = this;

		if (this.isIncluded) return Statement__emptyArrayPromise;
		this.isIncluded = true;

		var result = [];

		// We have a statement, and it hasn't been included yet. First, include
		// the statements it depends on
		var dependencies = Object.keys(this.dependsOn);

		return sequence(dependencies, function (name) {
			return _this3.module.define(name).then(function (definition) {
				result.push.apply(result, definition);
			});
		})

		// then include the statement itself
		.then(function () {
			result.push(_this3);
		})

		// then include any statements that could modify the
		// thing(s) this statement defines
		.then(function () {
			return sequence(keys(_this3.defines), function (name) {
				var modifications = has(_this3.module.modifications, name) && _this3.module.modifications[name];

				if (modifications) {
					return sequence(modifications, function (statement) {
						if (!statement.isIncluded) {
							return statement.expand().then(function (statements) {
								result.push.apply(result, statements);
							});
						}
					});
				}
			});
		})

		// the `result` is an array of statements needed to define `name`
		.then(function () {
			return result;
		});
	};

	Statement.prototype.replaceIdentifiers = function replaceIdentifiers(names) {
		var magicString = this.magicString.clone().trim();
		var replacementStack = [names];
		var nameList = keys(names);

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

		if (nameList.length > 0) {
			walk(this.node, {
				enter: function (node, parent) {
					var _this4 = this;

					var scope = node._scope;

					if (scope) {
						var _ret = (function () {
							var newNames = {};
							var hasReplacements = undefined;

							keys(names).forEach(function (key) {
								if (! ~scope.names.indexOf(key)) {
									newNames[key] = names[key];
									hasReplacements = true;
								}
							});

							deshadowList.forEach(function (name) {
								if (~scope.names.indexOf(name)) {
									newNames[name] = name + '$$'; // TODO better mechanism
									hasReplacements = true;
								}
							});

							if (!hasReplacements) {
								return {
									v: _this4.skip()
								};
							}

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

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

					// We want to rewrite identifiers (that aren't property names)
					if (node.type !== 'Identifier') return;
					if (parent.type === 'MemberExpression' && !parent.computed && node !== parent.object) return;
					if (parent.type === 'Property' && node !== parent.value) return;
					// TODO others...?

					var name = has(names, node.name) && names[node.name];

					if (name && name !== node.name) {
						magicString.overwrite(node.start, node.end, name);
					}
				},

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

		return magicString;
	};

	return Statement;
})();

var _analyse = analyse;

function analyse(magicString, module) {
	// first we need to generate comprehensive scope info
	var previousStatement = null;
	var commentIndex = 0;

	module.statements.forEach(function (statement) {
		var node = statement.node;

		var trailing = !!previousStatement;

		// TODO surely this can be neater
		// attach leading comment
		do {
			var comment = module.comments[commentIndex];

			// prevent comments inside the previous statement being
			// appended to it
			if (previousStatement) {
				while (comment && comment.start < previousStatement.node.end) {
					commentIndex += 1;
					comment = module.comments[commentIndex];
				}
			}

			if (!comment || comment.end > node.start) break;

			// attach any trailing comment to the previous statement
			if (trailing && !/\n/.test(module.source.slice(previousStatement.node.end, comment.start))) {
				previousStatement.trailingComment = comment;
			}

			// then attach leading comments to this statement
			else {
				statement.leadingComments.push(comment);
			}

			commentIndex += 1;
			trailing = false;
		} while (module.comments[commentIndex]);

		// determine margin
		var previousEnd = previousStatement ? (previousStatement.trailingComment || previousStatement.node).end : 0;
		var start = (statement.leadingComments[0] || node).start;

		var gap = magicString.original.slice(previousEnd, start);
		var margin = gap.split('\n').length;

		if (previousStatement) previousStatement.margin[1] = margin;
		statement.margin[0] = margin;

		statement.analyse();

		previousStatement = statement;
	});
}

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 = {};
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;
}

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

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

var Module = (function () {
	function Module(_ref) {
		var _this = this;

		var path = _ref.path;
		var source = _ref.source;
		var bundle = _ref.bundle;

		Module___classCallCheck(this, Module);

		this.source = source;

		this.bundle = bundle;
		this.path = path;
		this.relativePath = _path.relative(bundle.base, path).slice(0, -3); // remove .js

		this.magicString = new MagicString(source, {
			filename: path
		});

		this.suggestedNames = {};
		this.comments = [];

		// Try to extract a list of top-level statements/declarations. If
		// the parse fails, attach file info and abort
		try {
			var ast = acorn.parse(source, {
				ecmaVersion: 6,
				sourceType: 'module',
				onComment: function (block, text, start, end) {
					return _this.comments.push({ block: block, text: text, start: start, end: end });
				}
			});

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

			this.statements = ast.body.map(function (node) {
				var magicString = _this.magicString.snip(node.start, node.end);
				return new Statement(node, magicString, _this);
			});
		} catch (err) {
			err.code = 'PARSE_ERROR';
			err.file = path;
			throw err;
		}

		this.importDeclarations = this.statements.filter(isImportDeclaration);
		this.exportDeclarations = this.statements.filter(isExportDeclaration);

		this.analyse();
	}

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

		// imports and exports, indexed by ID
		this.imports = {};
		this.exports = {};

		this.importDeclarations.forEach(function (statement) {
			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 (has(_this2.imports, localName)) {
					var err = new Error('Duplicated import \'' + localName + '\'');
					err.file = _this2.path;
					err.loc = getLocation(_this2.source, specifier.start);
					throw err;
				}

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

		this.exportDeclarations.forEach(function (statement) {
			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);

				_this2.exports.default = {
					statement: statement,
					name: 'default',
					localName: isDeclaration ? node.declaration.id.name : 'default',
					isDeclaration: isDeclaration
				};
			}

			// 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;

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

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

					var _name = undefined;

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

					_this2.exports[_name] = {
						statement: statement,
						localName: _name,
						expression: declaration
					};
				}
			}
		});

		_analyse(this.magicString, this);

		this.canonicalNames = {};

		this.definitions = {};
		this.definitionPromises = {};
		this.modifications = {};

		this.statements.forEach(function (statement) {
			Object.keys(statement.defines).forEach(function (name) {
				_this2.definitions[name] = statement;
			});

			Object.keys(statement.modifies).forEach(function (name) {
				if (!has(_this2.modifications, name)) {
					_this2.modifications[name] = [];
				}

				_this2.modifications[name].push(statement);
			});
		});
	};

	Module.prototype.getCanonicalName = function getCanonicalName(localName) {
		if (has(this.suggestedNames, localName)) {
			localName = this.suggestedNames[localName];
		}

		if (!has(this.canonicalNames, localName)) {
			var canonicalName = undefined;

			if (has(this.imports, localName)) {
				var importDeclaration = this.imports[localName];
				var _module = importDeclaration.module;

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

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

					canonicalName = _module.getCanonicalName(exporterLocalName);
				}
			} else {
				canonicalName = localName;
			}

			this.canonicalNames[localName] = canonicalName;
		}

		return this.canonicalNames[localName];
	};

	Module.prototype.define = function define(name) {
		var _this3 = this;

		// shortcut cycles. TODO this won't work everywhere...
		if (has(this.definitionPromises, name)) {
			return Module__emptyArrayPromise;
		}

		var promise = undefined;

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

				promise = _this3.bundle.fetchModule(importDeclaration.source, _this3.path).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 = has(_this3.suggestedNames, localName) ? _this3.suggestedNames[localName] : localName;

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

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

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

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

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

						return module.expandAllStatements();
					}

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

					if (!exportDeclaration) {
						throw new Error('Module ' + module.path + ' does not export ' + importDeclaration.name + ' (imported by ' + _this3.path + ')');
					}

					return module.define(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.define(this.exports.default.name);
		} else {
			var statement = undefined;

			if (name === 'default') {
				statement = this.exports.default.statement;
			} else {
				statement = this.definitions[name];
			}

			if (statement && !statement.isIncluded) {
				promise = statement.expand();
			}
		}

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

	Module.prototype.expandAllStatements = function expandAllStatements(isEntryModule) {
		var _this4 = this;

		var allStatements = [];

		return sequence(this.statements, function (statement) {
			// A statement may have already been included, in which case we need to
			// curb rollup's enthusiasm and move it down here. It remains to be seen
			// if this approach is bulletproof
			if (statement.isIncluded) {
				var index = allStatements.indexOf(statement);
				if (~index) {
					allStatements.splice(index, 1);
					allStatements.push(statement);
				}

				return;
			}

			// 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 _this4.bundle.fetchModule(statement.node.source.value, _this4.path).then(function (module) {
						statement.module = module; // TODO what is this for? what does it do? why not _module?
						return module.expandAllStatements();
					}).then(function (statements) {
						allStatements.push.apply(allStatements, statements);
					});
				}

				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.expand().then(function (statements) {
						allStatements.push.apply(allStatements, statements);
					});
				}

				return;
			}

			// include everything else
			return statement.expand().then(function (statements) {
				allStatements.push.apply(allStatements, statements);
			});
		}).then(function () {
			return allStatements;
		});
	};

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

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

	return Module;
})();

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

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

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

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

		this.canonicalNames = {};
		this.suggestedNames = {};

		this.needsDefault = false;
		this.needsNamed = false;
	}

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

		if (name === '*') {
			return this.name;
		}

		// TODO this depends on the output format... works for CJS etc but not ES6
		return '' + 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 amd(bundle, magicString, exportMode, options) {
	var deps = bundle.externalModules.map(quoteId);
	var args = bundle.externalModules.map(getName);

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

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

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

	var exports = bundle.entryModule.exports;

	var exportBlock = undefined;

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

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

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

function cjs(bundle, magicString, 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 = keys(bundle.entryModule.exports).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 es6(bundle, magicString, exportMode, options) {
	var introBlock = ''; // TODO...

	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 iife(bundle, magicString, exportMode, options) {
	var globalNames = options.globals || {};

	var dependencies = bundle.externalModules.map(function (module) {
		return has(globalNames, module.id) ? 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('(window.' + options.moduleName + ' = {})');
		args.unshift('exports');
	}

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

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

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

function umd(bundle, magicString, exportMode, options) {
	var indentStr = magicString.getIndentString();

	var globalNames = options.globals || {};

	var amdDeps = bundle.externalModules.map(quoteId);
	var cjsDeps = bundle.externalModules.map(req);
	var globalDeps = bundle.externalModules.map(function (module) {
		return has(globalNames, module.id) ? 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 = (has(options, 'moduleId') ? '[\'' + options.moduleId + '\'], ' : '') + (amdDeps.length ? '[' + amdDeps.join(', ') + '], ' : '');

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

	var intro = ('(function (global, factory) {\n\t\t\ttypeof exports === \'object\' && typeof module !== \'undefined\' ? 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, indentStr);

	var exports = bundle.entryModule.exports;

	var exportBlock = undefined;

	if (exportMode === 'default') {
		var canonicalName = bundle.entryModule.getCanonicalName('default');
		exportBlock = 'return ' + canonicalName + ';';
	} else {
		exportBlock = Object.keys(exports).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().append('\n\n}));').prepend(intro);
}

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

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 (_path.isAbsolute(importee)) return 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 _path.resolve(_path.dirname(importer), importee).replace(/\.js$/, '') + '.js';
}

function defaultExternalResolver(id, importer, options) {
	// for now, only node_modules is supported, and only jsnext:main
	var parsed = _path.parse(importer);
	var dir = parsed.dir;

	while (dir !== parsed.root) {
		var pkgPath = _path.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 _path.resolve(_path.dirname(pkgPath), main).replace(/\.js$/, '') + '.js';
		}

		dir = _path.dirname(dir);
	}

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

// noop

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

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

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

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

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

		this.entryPath = _path.resolve(options.entry).replace(/\.js$/, '') + '.js';
		this.base = _path.dirname(this.entryPath);

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

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

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

		this.entryModule = null;
		this.modulePromises = {};
		this.statements = [];
		this.externalModules = [];
		this.defaultExportName = null;
		this.internalNamespaceModules = [];
	}

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

		return sander.Promise.resolve(importer === null ? importee : this.resolvePath(importee, importer, this.resolvePathOptions)).then(function (path) {
			if (!path) {
				// external module
				if (!has(_this.modulePromises, importee)) {
					var _module = new ExternalModule(importee);
					_this.externalModules.push(_module);
					_this.modulePromises[importee] = sander.Promise.resolve(_module);
				}

				return _this.modulePromises[importee];
			}

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

					return module;
				});
			}

			return _this.modulePromises[path];
		});
	};

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

		// bring in top-level AST nodes from the entry module
		return this.fetchModule(this.entryPath, null).then(function (entryModule) {
			_this2.entryModule = entryModule;

			if (entryModule.exports.default) {
				(function () {
					var defaultExportName = makeLegalIdentifier(_path.basename(_this2.entryPath).slice(0, -_path.extname(_this2.entryPath).length));

					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.expandAllStatements(true);
		}).then(function (statements) {
			_this2.statements = statements;
			_this2.deconflict();
		});
	};

	Bundle.prototype.deconflict = function deconflict() {
		var definers = {};
		var conflicts = {};

		// Discover conflicts (i.e. two statements in separate modules both define `foo`)
		this.statements.forEach(function (statement) {
			var module = statement.module;
			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 _name = module.getCanonicalName('default');

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

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

			names.forEach(function (name) {
				if (has(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);
			});
		});

		// 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 (has(definers, name)) {
				conflicts[name] = true;
			} else {
				definers[name] = [];
			}

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

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

			modules.pop(); // the module closest to the entryModule gets away with keeping things as they are

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

		function getSafeName(name) {
			while (has(conflicts, name)) {
				name = '_' + name;
			}

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

	Bundle.prototype.generate = function generate() {
		var options = arguments[0] === undefined ? {} : arguments[0];

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

		// Determine export mode - 'default', 'named', 'none'
		var exportMode = this.getExportMode(options.exports);

		var previousMargin = 0;

		// Apply new names and add to the output bundle
		this.statements.forEach(function (statement) {
			var replacements = {};

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

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

			var source = statement.replaceIdentifiers(replacements);

			// modify exports as necessary
			if (statement.isExportDeclaration) {
				// skip `export { foo, bar, baz }`
				if (statement.node.type === 'ExportNamedDeclaration' && statement.node.specifiers.length) {
					return;
				}

				// remove `export` from `export var foo = 42`
				if (statement.node.type === 'ExportNamedDeclaration' && statement.node.declaration.type === 'VariableDeclaration') {
					source.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) {
					source.remove(statement.node.start, statement.node.declaration.start);
				} else if (statement.node.type === 'ExportDefaultDeclaration') {
					var _module2 = statement.module;
					var canonicalName = _module2.getCanonicalName('default');

					if (statement.node.declaration.type === 'Identifier' && canonicalName === _module2.getCanonicalName(statement.node.declaration.name)) {
						return;
					}

					source.overwrite(statement.node.start, statement.node.declaration.start, 'var ' + canonicalName + ' = ');
				} else {
					throw new Error('Unhandled export');
				}
			}

			// add leading comments
			if (statement.leadingComments.length) {
				var commentBlock = statement.leadingComments.map(function (comment) {
					return comment.block ? '/*' + comment.text + '*/' : '//' + comment.text;
				}).join('\n');

				magicString.addSource(new MagicString(commentBlock));
			}

			// add margin
			var margin = Math.max(statement.margin[0], previousMargin);
			var newLines = new Array(margin).join('\n');

			// add the statement itself
			magicString.addSource({
				content: source,
				separator: newLines
			});

			// add trailing comments
			var comment = statement.trailingComment;
			if (comment) {
				var commentBlock = comment.block ? ' /*' + comment.text + '*/' : ' //' + comment.text;

				magicString.append(commentBlock);
			}

			previousMargin = statement.margin[1];
		});

		// 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('*') + ' = {\n' + exportKeys.map(function (key) {
				return '' + indentString + 'get ' + key + ' () { return ' + module.getCanonicalName(key) + '; }';
			}).join(',\n') + '\n};\n\n';
		}).join('');

		magicString.prepend(namespaceBlock);

		var finalise = finalisers[options.format || 'es6'];

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

		magicString = finalise(this, magicString.trim(), exportMode, options);

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

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

				// make sources relative. TODO fix this upstream?
				var dir = _path.dirname(map.file);
				map.sources = map.sources.map(function (source) {
					return source ? _path.relative(dir, source) : null;
				});
			})();
		}

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

	Bundle.prototype.getExportMode = function getExportMode(exportMode) {
		var exportKeys = keys(this.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;
	};

	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.generate(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$generate = bundle.generate(options);

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

				var promises = [sander.writeFile(dest, code)];

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

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

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

				return Promise.all(promises);
			}
		};
	});
}

exports.rollup = rollup;
//# sourceMappingURL=rollup.js.map