rollup 0.49.3 → 0.50.0

package/dist/rollup.es.js

@@ -1,6 +1,6 @@
 /*
-	Rollup.js v0.49.3
-	Thu Sep 07 2017 21:02:36 GMT-0400 (EDT) - commit 0d20ed12e069b4fc445faecf221ffe5b40fbf90a
+	Rollup.js v0.50.0
+	Sat Sep 16 2017 09:48:09 GMT-0400 (EDT) - commit b949eb08169115ff66648838cbc4833379bf9440
 
 
 	https://github.com/rollup/rollup
@@ -1938,15 +1938,15 @@ var types = {
   eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
   assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
   incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
-  prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
+  prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
   logicalOR: binop("||", 1),
   logicalAND: binop("&&", 2),
   bitwiseOR: binop("|", 3),
   bitwiseXOR: binop("^", 4),
   bitwiseAND: binop("&", 5),
-  equality: binop("==/!=", 6),
-  relational: binop("</>", 7),
-  bitShift: binop("<</>>", 8),
+  equality: binop("==/!=/===/!==", 6),
+  relational: binop("</>/<=/>=", 7),
+  bitShift: binop("<</>>/>>>", 8),
   plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
   modulo: binop("%", 10),
   star: binop("*", 10),
@@ -2296,7 +2296,7 @@ var pp = Parser.prototype;
 
 // ## Parser utilities
 
-var literal = /^(?:'((?:[^']|\.)*)'|"((?:[^"]|\.)*)"|;)/;
+var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;
 pp.strictDirective = function(start) {
   var this$1 = this;
 
@@ -4010,7 +4010,7 @@ pp$3.parseTemplate = function(ref) {
 
 pp$3.isAsyncProp = function(prop) {
   return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
-    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL) &&
+    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword) &&
     !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
 };
 
@@ -4886,7 +4886,7 @@ pp$8.readToken_caret = function() { // '^'
 pp$8.readToken_plus_min = function(code) { // '+-'
   var next = this.input.charCodeAt(this.pos + 1);
   if (next === code) {
-    if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
+    if (next == 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 62 &&
         (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
       // A `-->` line comment
       this.skipLineComment(3);
@@ -4907,9 +4907,8 @@ pp$8.readToken_lt_gt = function(code) { // '<>'
     if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
     return this.finishOp(types.bitShift, size)
   }
-  if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+  if (next == 33 && code == 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 45 &&
       this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) { this.unexpected(); }
     // `<!--`, an XML-style comment that should be interpreted as a line comment
     this.skipLineComment(4);
     this.skipSpace();
@@ -5515,19 +5514,39 @@ function relativeId ( id ) {
 	return relative( process.cwd(), id );
 }
 
-const UNKNOWN_VALUE = { toString: () => '[[UNKNOWN]]' };
+class Variable {
+	constructor ( name ) {
+		this.name = name;
+	}
 
-const UNKNOWN_ASSIGNMENT = {
-	type: 'UNKNOWN',
-	hasEffectsWhenMutated: () => true,
-};
+	addCall () {}
+
+	getName () {
+		return this.name;
+	}
+
+	hasEffectsWhenCalled () {
+		return true;
+	}
+
+	hasEffectsWhenMutated () {
+		return true;
+	}
+
+	includeVariable () {
+		if ( this.included ) {
+			return false;
+		}
+		this.included = true;
+		return true;
+	}
+}
 
-class SyntheticNamespaceDeclaration {
+class NamespaceVariable extends Variable {
 	constructor ( module ) {
+		super( module.basename() );
 		this.isNamespace = true;
 		this.module = module;
-		this.name = module.basename();
-
 		this.needsNamespaceBlock = false;
 
 		this.originals = blank();
@@ -5540,26 +5559,15 @@ class SyntheticNamespaceDeclaration {
 		this.name = node.name;
 	}
 
-	assignExpression () {
-		// This should probably not happen, but not defining this might prevent a more meaningful error message
-	}
-
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT );
-	}
-
-	getName () {
-		return this.name;
-	}
+	assignExpression () {}
 
-	includeDeclaration () {
-		if ( this.included ) {
-			return false;
+	includeVariable () {
+		const hasBeenIncluded = super.includeVariable();
+		if ( hasBeenIncluded ) {
+			this.needsNamespaceBlock = true;
+			forOwn( this.originals, original => original.includeVariable() );
 		}
-		this.included = true;
-		this.needsNamespaceBlock = true;
-		forOwn( this.originals, original => original.includeDeclaration() );
-		return true;
+		return hasBeenIncluded;
 	}
 
 	renderBlock ( es, legacy, indentString ) {
@@ -5579,55 +5587,6 @@ class SyntheticNamespaceDeclaration {
 	}
 }
 
-class ExternalDeclaration {
-	constructor ( module, name ) {
-		this.module = module;
-		this.name = name;
-		this.safeName = null;
-		this.isExternal = true;
-		this.isNamespace = name === '*';
-	}
-
-	addReference ( reference ) {
-		reference.declaration = this;
-
-		if ( this.name === 'default' || this.name === '*' ) {
-			this.module.suggestName( reference.name );
-		}
-	}
-
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT );
-	}
-
-	getName ( es ) {
-		if ( this.name === '*' ) {
-			return this.module.name;
-		}
-
-		if ( this.name === 'default' ) {
-			return this.module.exportsNamespace || ( !es && this.module.exportsNames ) ?
-				`${this.module.name}__default` :
-				this.module.name;
-		}
-
-		return es ? this.safeName : `${this.module.name}.${this.name}`;
-	}
-
-	includeDeclaration () {
-		if ( this.included ) {
-			return false;
-		}
-		this.included = true;
-		this.module.used = true;
-		return true;
-	}
-
-	setSafeName ( name ) {
-		this.safeName = name;
-	}
-}
-
 function extractNames ( param ) {
 	const names = [];
 	extractors[ param.type ]( names, param );
@@ -5660,13 +5619,216 @@ const extractors = {
 	}
 };
 
-class Node$1 {
-	assignExpression () {}
+const UNKNOWN_VALUE = { toString: () => '[[UNKNOWN]]' };
+
+const UNKNOWN_ASSIGNMENT = {
+	type: 'UNKNOWN',
+	bindCall: () => {},
+	hasEffectsWhenCalled: () => true,
+	hasEffectsWhenMutated: () => true,
+};
+
+const UNDEFINED_ASSIGNMENT = {
+	type: 'UNDEFINED',
+	bindCall: () => {},
+	hasEffectsWhenCalled: () => true,
+	hasEffectsWhenMutated: () => true,
+};
+
+const UNKNOWN_OBJECT_LITERAL = {
+	type: 'UNKNOWN_OBJECT_LITERAL',
+	bindCall: () => {},
+	hasEffectsWhenCalled: () => true,
+	hasEffectsWhenMutated: () => false,
+};
+
+const OPTION_IGNORE_BREAK_STATEMENTS = 'IGNORE_BREAK_STATEMENTS';
+const OPTION_IGNORE_RETURN_AWAIT_YIELD = 'IGNORE_RETURN_AWAIT_YIELD';
+const OPTION_IGNORE_SAFE_THIS_MUTATIONS = 'IGNORE_SAFE_THIS_MUTATIONS';
+const OPTION_CALLED_NODES = 'CALLED_NODES';
+const OPTION_MUTATED_NODES = 'MUTATED_NODES';
+const IGNORED_LABELS = 'IGNORED_LABELS';
+
+/** Wrapper to ensure immutability */
+class ExecutionPathOptions {
+	/**
+	 * @returns {ExecutionPathOptions}
+	 */
+	static create () {
+		return new this( {} );
+	}
+
+	constructor ( optionValues ) {
+		this._optionValues = optionValues;
+	}
+
+	/**
+	 * Returns a new ExecutionPathOptions instance with the given option set to a new value.
+	 * Does not mutate the current instance. Also works in sub-classes.
+	 * @param {string} option - The name of an option
+	 * @param {*} value - The new value of the option
+	 * @returns {ExecutionPathOptions} A new options instance
+	 */
+	set ( option, value ) {
+		return new this.constructor( Object.assign( {}, this._optionValues, { [option]: value } ) );
+	}
+
+	/**
+	 * @param {string} option - The name of an option
+	 * @returns {*} Its value
+	 */
+	get ( option ) {
+		return this._optionValues[ option ];
+	}
 
+	/**
+	 * @return {boolean}
+	 */
+	ignoreBreakStatements () {
+		return this.get( OPTION_IGNORE_BREAK_STATEMENTS );
+	}
+
+	/**
+	 * @param {boolean} [value=true]
+	 * @return {ExecutionPathOptions}
+	 */
+	setIgnoreBreakStatements ( value ) {
+		if ( value === void 0 ) value = true;
+
+		return this.set( OPTION_IGNORE_BREAK_STATEMENTS, value );
+	}
+
+	/**
+	 * @param {string} labelName
+	 * @return {boolean}
+	 */
+	ignoreLabel ( labelName ) {
+		const ignoredLabels = this.get( IGNORED_LABELS );
+		return ignoredLabels && ignoredLabels.has( labelName );
+	}
+
+	/**
+	 * @param {string} labelName
+	 * @return {ExecutionPathOptions}
+	 */
+	setIgnoreLabel ( labelName ) {
+		return this.set( IGNORED_LABELS, new Set( this.get( IGNORED_LABELS ) ).add( labelName ) );
+	}
+
+	/**
+	 * @return {ExecutionPathOptions}
+	 */
+	setIgnoreNoLabels () {
+		return this.set( IGNORED_LABELS, null );
+	}
+
+	/**
+	 * @return {boolean}
+	 */
+	ignoreReturnAwaitYield () {
+		return this.get( OPTION_IGNORE_RETURN_AWAIT_YIELD );
+	}
+
+	/**
+	 * @param {boolean} [value=true]
+	 * @return {ExecutionPathOptions}
+	 */
+	setIgnoreReturnAwaitYield ( value ) {
+		if ( value === void 0 ) value = true;
+
+		return this.set( OPTION_IGNORE_RETURN_AWAIT_YIELD, value );
+	}
+
+	/**
+	 * @return {boolean}
+	 */
+	ignoreSafeThisMutations () {
+		return this.get( OPTION_IGNORE_SAFE_THIS_MUTATIONS );
+	}
+
+	/**
+	 * @param {boolean} [value=true]
+	 * @return {ExecutionPathOptions}
+	 */
+	setIgnoreSafeThisMutations ( value ) {
+		if ( value === void 0 ) value = true;
+
+		return this.set( OPTION_IGNORE_SAFE_THIS_MUTATIONS, value );
+	}
+
+	/**
+	 * @param {Node} node
+	 * @return {ExecutionPathOptions}
+	 */
+	addMutatedNode ( node ) {
+		return this.set( OPTION_MUTATED_NODES, new Set( this.get( OPTION_MUTATED_NODES ) ).add( node ) );
+	}
+
+	/**
+	 * @param {Node} node
+	 * @return {boolean}
+	 */
+	hasNodeBeenMutated ( node ) {
+		const mutatedNodes = this.get( OPTION_MUTATED_NODES );
+		return mutatedNodes && mutatedNodes.has( node );
+	}
+
+	/**
+	 * @param {Node} node
+	 * @return {ExecutionPathOptions}
+	 */
+	addCalledNode ( node ) {
+		return this.set( OPTION_CALLED_NODES, new Set( this.get( OPTION_CALLED_NODES ) ).add( node ) );
+	}
+
+	/**
+	 * @param {Node} node
+	 * @return {boolean}
+	 */
+	hasNodeBeenCalled ( node ) {
+		const calledNodes = this.get( OPTION_CALLED_NODES );
+		return calledNodes && calledNodes.has( node );
+	}
+
+	/**
+	 * @param {Node} calledNode
+	 * @return {ExecutionPathOptions}
+	 */
+	getHasEffectsWhenCalledOptions ( calledNode ) {
+		return this
+			.addCalledNode( calledNode )
+			.setIgnoreReturnAwaitYield()
+			.setIgnoreBreakStatements( false )
+			.setIgnoreNoLabels();
+	}
+}
+
+class Node$1 {
+	/**
+	 * Called once all nodes have been initialised and the scopes have been populated.
+	 * Use this to bind assignments and calls to variables.
+	 */
 	bind () {
 		this.eachChild( child => child.bind() );
 	}
 
+	/**
+	 * Bind an expression as an assignment to a node.
+	 * The default noop implementation is ok as long as hasEffectsWhenAssigned
+	 * always returns true for this node. Otherwise it should be overridden.
+	 * @param {Node} expression
+	 */
+	bindAssignment () {}
+
+	/**
+	 * Binds ways a node is called to a node. Current options are:
+	 * - withNew: boolean - Did this call use the "new" operator
+	 * The default noop implementation is ok as long as hasEffectsWhenCalled
+	 * always returns true for this node. Otherwise it should be overridden.
+	 * @param callOptions
+	 */
+	bindCall () {}
+
 	eachChild ( callback ) {
 		this.keys.forEach( key => {
 			const value = this[ key ];
@@ -5680,34 +5842,65 @@ class Node$1 {
 		} );
 	}
 
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT );
-	}
-
 	getValue () {
 		return UNKNOWN_VALUE;
 	}
 
+	/**
+	 * Determine if this Node would have an effect on the bundle.
+	 * This is usually true for already included nodes. Exceptions are e.g. break statements
+	 * which only have an effect if their surrounding loop or switch statement is included.
+	 * The options pass on information like this about the current execution path.
+	 * @param {ExecutionPathOptions} options
+	 * @return {boolean}
+	 */
 	hasEffects ( options ) {
 		return this.included || this.someChild( child => child.hasEffects( options ) );
 	}
 
+	/**
+	 * Special make-shift logic to treat cases where apparently side-effect free statements
+	 * are executed for side-effects. The most important case are getters with side-effects.
+	 * Once we can reliably handle this case in member expressions, this function should
+	 * probably be removed again.
+	 * @param {ExecutionPathOptions} options
+	 * @return {boolean}
+	 */
 	hasEffectsAsExpressionStatement () {
 		return true;
 	}
 
+	/**
+	 * @param {ExecutionPathOptions} options
+	 * @return {boolean}
+	 */
 	hasEffectsWhenAssigned () {
 		return true;
 	}
 
-	hasEffectsWhenMutated () {
+	/**
+	 * @param {ExecutionPathOptions} options
+	 * @return {boolean}
+	 */
+	hasEffectsWhenCalled () {
 		return true;
 	}
 
-	includeDeclaration () {
-		return this.includeInBundle();
+	/**
+	 * @param {ExecutionPathOptions} options
+	 * @return {boolean}
+	 */
+	hasEffectsWhenMutated () {
+		return true;
 	}
 
+	/**
+	 * Includes the node in the bundle. Children are usually included if they are
+	 * necessary for this node (e.g. a function body) or if they have effects.
+	 * Necessary variables should be included as well. Should return true if any
+	 * nodes or variables have been added that were missing before.
+	 * @return {boolean}
+	 */
 	includeInBundle () {
 		if ( this.isFullyIncluded() ) { return false; }
 		let addedNewNodes = false;
@@ -5723,21 +5916,49 @@ class Node$1 {
 		return true;
 	}
 
+	/**
+	 * Alternative version of includeInBundle to override the default behaviour of
+	 * declarations to only include nodes for declarators that have an effect. Necessary
+	 * for for-loops that do not use a declared loop variable.
+	 * @return {boolean}
+	 */
+	includeWithAllDeclarations () {
+		return this.includeInBundle();
+	}
+
+	/**
+	 * Assign a scope to this node and make sure all children have the right scopes.
+	 * Perform any additional initialisation that does not depend on the scope being
+	 * populated with variables.
+	 * Usually one should not override this function but override initialiseScope,
+	 * initialiseNode and/or initialiseChildren instead. BlockScopes have a special
+	 * alternative initialisation initialiseAndReplaceScope.
+	 * @param {Scope} parentScope
+	 */
 	initialise ( parentScope ) {
 		this.initialiseScope( parentScope );
 		this.initialiseNode( parentScope );
 		this.initialiseChildren( parentScope );
 	}
 
-	// Override if e.g. some children need to be initialised with the parent scope
+	/**
+	 * Override to change how and with what scopes children are initialised
+	 * @param {Scope} parentScope
+	 */
 	initialiseChildren () {
 		this.eachChild( child => child.initialise( this.scope ) );
 	}
 
-	// Override to perform special initialisation steps after the scope is initialised
+	/**
+	 * Override to perform special initialisation steps after the scope is initialised
+	 * @param {Scope} parentScope
+	 */
 	initialiseNode () {}
 
-	// Overwrite to create a new scope
+	/**
+	 * Override if this scope should receive a different scope than the parent scope.
+	 * @param {Scope} parentScope
+	 */
 	initialiseScope ( parentScope ) {
 		this.scope = parentScope;
 	}
@@ -5748,6 +5969,11 @@ class Node$1 {
 		}
 	}
 
+	/**
+	 * Shortcut to skip checking this node for effects when all children have already
+	 * been included.
+	 * @param {Scope} parentScope
+	 */
 	isFullyIncluded () {
 		if ( this._fullyIncluded ) {
 			return true;
@@ -5768,8 +5994,15 @@ class Node$1 {
 		this.eachChild( child => child.render( code, es ) );
 	}
 
+	/**
+	 * Start a new execution path to determine if this node has an effect on the bundle and
+	 * should therefore be included. Unless they are fully included, included nodes should
+	 * always be included again in subsequent visits as the inclusion of additional variables
+	 * may require the inclusion of more child nodes in e.g. block statements.
+	 * @return {boolean}
+	 */
 	shouldBeIncluded () {
-		return this.hasEffects( {} );
+		return this.hasEffects( ExecutionPathOptions.create() );
 	}
 
 	someChild ( callback ) {
@@ -5790,45 +6023,91 @@ class Node$1 {
 }
 
 class ArrayPattern extends Node$1 {
-	assignExpression () {
-		this.eachChild( child => child.assignExpression( UNKNOWN_ASSIGNMENT ) );
+	bindAssignment () {
+		this.eachChild( child => child.bindAssignment( UNKNOWN_ASSIGNMENT ) );
 	}
 
 	hasEffectsWhenAssigned ( options ) {
 		return this.someChild( child => child.hasEffectsWhenAssigned( options ) );
 	}
+
+	initialiseAndDeclare ( parentScope, kind ) {
+		this.initialiseScope( parentScope );
+		this.eachChild( child => child.initialiseAndDeclare( parentScope, kind, UNKNOWN_ASSIGNMENT ) );
+	}
 }
 
-class Parameter {
-	constructor ( name ) {
-		this.name = name;
-		this.isParam = true;
-		this.assignedExpressions = new Set( [ UNKNOWN_ASSIGNMENT ] );
+class LocalVariable extends Variable {
+	constructor ( name, declarator, init ) {
+		super( name );
+		this.isReassigned = false;
+		this.exportName = null;
+		this.declarations = new Set( declarator ? [ declarator ] : null );
+		this.assignedExpressions = new Set( init ? [ init ] : null );
+		this.calls = new Set();
+	}
+
+	addDeclaration ( identifier ) {
+		this.declarations.add( identifier );
 	}
 
-	addReference () {
-		// noop?
+	addCall ( callOptions ) {
+		// To prevent infinite loops
+		if ( this.calls.has( callOptions ) ) { return; }
+		this.calls.add( callOptions );
+		Array.from( this.assignedExpressions ).forEach( expression => expression.bindCall( callOptions ) );
 	}
 
+	addReference () {}
+
 	assignExpression ( expression ) {
 		this.assignedExpressions.add( expression );
 		this.isReassigned = true;
+		Array.from( this.calls ).forEach( callOptions => expression.bindCall( callOptions ) );
 	}
 
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT ); // TODO populate this at call time
+	getName ( es ) {
+		if ( es ) { return this.name; }
+		if ( !this.isReassigned || !this.exportName ) { return this.name; }
+
+		return `exports.${this.exportName}`;
 	}
 
-	getName () {
-		return this.name;
+	hasEffectsWhenCalled ( options ) {
+		return Array.from( this.assignedExpressions ).some( node =>
+			!options.hasNodeBeenCalled( node )
+			&& node.hasEffectsWhenCalled( options.getHasEffectsWhenCalledOptions( node ) )
+		);
 	}
 
-	includeDeclaration () {
-		if ( this.included ) {
-			return false;
+	hasEffectsWhenMutated ( options ) {
+		return this.included
+			|| Array.from( this.assignedExpressions ).some( node =>
+				!options.hasNodeBeenMutated( node ) &&
+				node.hasEffectsWhenMutated( options.addMutatedNode( node ) )
+			);
+	}
+
+	includeVariable () {
+		const hasBeenIncluded = super.includeVariable();
+		if ( hasBeenIncluded ) {
+			this.declarations.forEach( identifier => identifier.includeInBundle() );
 		}
-		this.included = true;
-		return true;
+		return hasBeenIncluded;
+	}
+
+	toString () {
+		return this.name;
+	}
+}
+
+class ParameterVariable extends LocalVariable {
+	constructor ( name, declarator ) {
+		super( name, declarator, UNKNOWN_ASSIGNMENT );
+	}
+
+	getName () {
+		return this.name;
 	}
 }
 
@@ -5837,43 +6116,38 @@ class Scope {
 	if ( options === void 0 ) options = {};
 
 		this.parent = options.parent;
-		this.isBlockScope = !!options.isBlockScope;
-		this.isLexicalBoundary = !!options.isLexicalBoundary;
 		this.isModuleScope = !!options.isModuleScope;
 
 		this.children = [];
 		if ( this.parent ) { this.parent.children.push( this ); }
 
-		this.declarations = blank();
-
-		if ( this.isLexicalBoundary && !this.isModuleScope ) {
-			this.declarations.arguments = new Parameter( 'arguments' );
-		}
+		this.variables = blank();
 	}
 
-	addDeclaration ( name, declaration, isVar, isParam ) {
-		if ( isVar && this.isBlockScope ) {
-			this.parent.addDeclaration( name, declaration, isVar, isParam );
+	addDeclaration ( identifier, isHoisted, init ) {
+		const name = identifier.name;
+		if ( this.variables[ name ] ) {
+			const variable = this.variables[ name ];
+			variable.addDeclaration( identifier );
+			init && variable.assignExpression( init );
 		} else {
-			const existingDeclaration = this.declarations[ name ];
-
-			if ( existingDeclaration && existingDeclaration.duplicates ) {
-				// TODO warn/throw on duplicates?
-				existingDeclaration.duplicates.push( declaration );
-			} else {
-				this.declarations[ name ] = isParam ? new Parameter( name ) : declaration;
-			}
+			this.variables[ name ] = new LocalVariable( identifier.name, identifier, init );
 		}
 	}
 
+	addParameterDeclaration ( identifier ) {
+		const name = identifier.name;
+		this.variables[ name ] = new ParameterVariable( name, identifier );
+	}
+
 	contains ( name ) {
-		return !!this.declarations[ name ] ||
+		return !!this.variables[ name ] ||
 			( this.parent ? this.parent.contains( name ) : false );
 	}
 
 	deshadow ( names ) {
-		keys( this.declarations ).forEach( key => {
-			const declaration = this.declarations[ key ];
+		keys( this.variables ).forEach( key => {
+			const declaration = this.variables[ key ];
 
 			// we can disregard exports.foo etc
 			if ( declaration.exportName && declaration.isReassigned ) { return; }
@@ -5893,61 +6167,52 @@ class Scope {
 		this.children.forEach( scope => scope.deshadow( names ) );
 	}
 
-	findDeclaration ( name ) {
-		return this.declarations[ name ] ||
-			( this.parent && this.parent.findDeclaration( name ) );
+	findLexicalBoundary () {
+		return this.parent.findLexicalBoundary();
 	}
 
-	findLexicalBoundary () {
-		return this.isLexicalBoundary ? this : this.parent.findLexicalBoundary();
+	findVariable ( name ) {
+		return this.variables[ name ] ||
+			( this.parent && this.parent.findVariable( name ) );
 	}
 }
 
-class Function$1 extends Node$1 {
-	bind () {
-		if ( this.id ) { this.id.bind(); }
-		this.params.forEach( param => param.bind() );
-		this.body.bind();
-	}
+class ArrowFunctionExpression extends Node$1 {
+	// Should receive an implementation once we start tracking parameter values
+	bindCall () {}
 
 	hasEffects () {
 		return this.included;
 	}
 
-	initialiseChildren () {
-		this.params.forEach( param => {
-			param.initialise( this.scope );
-			extractNames( param ).forEach( name => this.scope.addDeclaration( name, null, false, true ) );
-		} );
-		this.body.initialiseAndReplaceScope ?
-			this.body.initialiseAndReplaceScope( this.scope ) :
-			this.body.initialise( this.scope );
+	hasEffectsWhenCalled ( options ) {
+		return this.params.some( param => param.hasEffects( options ) )
+			|| this.body.hasEffects( options );
 	}
 
-	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: false,
-			isLexicalBoundary: true
-		} );
+	hasEffectsWhenMutated () {
+		return this.included;
+	}
+
+	initialiseChildren () {
+		this.params.forEach( param => param.initialiseAndDeclare( this.scope, 'parameter' ) );
+		if ( this.body.initialiseAndReplaceScope ) {
+			this.body.initialiseAndReplaceScope( new Scope( { parent: this.scope } ) );
+		} else {
+			this.body.initialise( this.scope );
+		}
 	}
-}
 
-class ArrowFunctionExpression extends Function$1 {
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: false,
-			isLexicalBoundary: false
-		} );
+		this.scope = new Scope( { parent: parentScope } );
 	}
 }
 
 // TODO tidy this up a bit (e.g. they can both use node.module.imports)
 function disallowIllegalReassignment ( scope, node ) {
 	if ( node.type === 'MemberExpression' && node.object.type === 'Identifier' ) {
-		const declaration = scope.findDeclaration( node.object.name );
-		if ( declaration.isNamespace ) {
+		const variable = scope.findVariable( node.object.name );
+		if ( variable.isNamespace ) {
 			node.module.error({
 				code: 'ILLEGAL_NAMESPACE_REASSIGNMENT',
 				message: `Illegal reassignment to import '${node.object.name}'`
@@ -5969,7 +6234,7 @@ class AssignmentExpression extends Node$1 {
 	bind () {
 		super.bind();
 		disallowIllegalReassignment( this.scope, this.left );
-		this.left.assignExpression( this.right );
+		this.left.bindAssignment( this.right );
 	}
 
 	hasEffects ( options ) {
@@ -5982,345 +6247,175 @@ class AssignmentExpression extends Node$1 {
 }
 
 class AssignmentPattern extends Node$1 {
-	hasEffectsWhenAssigned ( options ) {
-		return this.left.hasEffectsWhenAssigned( options );
-	}
-}
-
-class AwaitExpression extends Node$1 {
-	hasEffects ( options ) {
-		return super.hasEffects( options )
-			|| !options.inNestedFunctionCall;
-	}
-
-	hasEffectsAsExpressionStatement ( options ) {
-		return this.hasEffects( options );
-	}
-}
-
-const operators = {
-	'==': ( left, right ) => left == right,
-	'!=': ( left, right ) => left != right,
-	'===': ( left, right ) => left === right,
-	'!==': ( left, right ) => left !== right,
-	'<': ( left, right ) => left < right,
-	'<=': ( left, right ) => left <= right,
-	'>': ( left, right ) => left > right,
-	'>=': ( left, right ) => left >= right,
-	'<<': ( left, right ) => left << right,
-	'>>': ( left, right ) => left >> right,
-	'>>>': ( left, right ) => left >>> right,
-	'+': ( left, right ) => left + right,
-	'-': ( left, right ) => left - right,
-	'*': ( left, right ) => left * right,
-	'/': ( left, right ) => left / right,
-	'%': ( left, right ) => left % right,
-	'|': ( left, right ) => left | right,
-	'^': ( left, right ) => left ^ right,
-	'&': ( left, right ) => left & right,
-	'**': ( left, right ) => Math.pow( left, right ),
-	in: ( left, right ) => left in right,
-	instanceof: ( left, right ) => left instanceof right
-};
-
-class BinaryExpression extends Node$1 {
-	getValue () {
-		const leftValue = this.left.getValue();
-		if ( leftValue === UNKNOWN_VALUE ) { return UNKNOWN_VALUE; }
-
-		const rightValue = this.right.getValue();
-		if ( rightValue === UNKNOWN_VALUE ) { return UNKNOWN_VALUE; }
-
-		if ( !operators[ this.operator ] ) { return UNKNOWN_VALUE; }
-
-		return operators[ this.operator ]( leftValue, rightValue );
-	}
-}
-
-class Statement extends Node$1 {
-	render ( code, es ) {
-		if ( !this.module.bundle.treeshake || this.included ) {
-			super.render( code, es );
-		} else {
-			code.remove( this.leadingCommentStart || this.start, this.next || this.end );
-		}
-	}
-}
-
-class BlockStatement extends Statement {
 	bind () {
-		this.body.forEach( node => node.bind() );
-	}
-
-	includeInBundle () {
-		if ( this.isFullyIncluded() ) { return false; }
-		let addedNewNodes = false;
-		this.body.forEach( node => {
-			if ( node.shouldBeIncluded() ) {
-				if ( node.includeInBundle() ) {
-					addedNewNodes = true;
-				}
-			}
-		} );
-		if ( !this.included || addedNewNodes ) {
-			this.included = true;
-			return true;
-		}
-		return false;
-	}
-
-	initialiseAndReplaceScope ( scope ) {
-		this.scope = scope;
-		this.initialiseNode();
-		this.initialiseChildren( scope );
+		super.bind();
+		this.left.bindAssignment( this.right );
 	}
 
-	initialiseChildren () {
-		let lastNode;
-		for ( const node of this.body ) {
-			node.initialise( this.scope );
-
-			if ( lastNode ) { lastNode.next = node.start; }
-			lastNode = node;
-		}
+	bindAssignment ( expression ) {
+		this.left.bindAssignment( expression );
 	}
 
-	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+	hasEffectsWhenAssigned ( options ) {
+		return this.left.hasEffectsWhenAssigned( options );
 	}
 
-	render ( code, es ) {
-		if ( this.body.length ) {
-			for ( const node of this.body ) {
-				node.render( code, es );
-			}
-		} else {
-			Statement.prototype.render.call( this, code, es );
-		}
+	initialiseAndDeclare ( parentScope, kind, init ) {
+		this.initialiseScope( parentScope );
+		this.right.initialise( parentScope );
+		this.left.initialiseAndDeclare( parentScope, kind, init );
 	}
 }
 
-class BreakStatement extends Node$1 {
+class AwaitExpression extends Node$1 {
 	hasEffects ( options ) {
 		return super.hasEffects( options )
-			|| !options.inNestedBreakableStatement;
-	}
-
-	shouldBeIncluded () {
-		return true;
-	}
-}
-
-function isReference (node, parent) {
-	if (node.type === 'MemberExpression') {
-		return !node.computed && isReference(node.object, node);
-	}
-
-	if (node.type === 'Identifier') {
-		// the only time we could have an identifier node without a parent is
-		// if it's the entire body of a function without a block statement –
-		// i.e. an arrow function expression like `a => a`
-		if (!parent) return true;
-
-		// TODO is this right?
-		if (parent.type === 'MemberExpression' || parent.type === 'MethodDefinition') {
-			return parent.computed || node === parent.object;
-		}
-
-		// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-		if (parent.type === 'Property') return parent.computed || node === parent.value;
-
-		// disregard the `bar` in `class Foo { bar () {...} }`
-		if (parent.type === 'MethodDefinition') return false;
-
-		// disregard the `bar` in `export { foo as bar }`
-		if (parent.type === 'ExportSpecifier' && node !== parent.local) return false;
-
-		return true;
-	}
-
-	return false;
-}
-
-function flatten ( node ) {
-	const parts = [];
-	while ( node.type === 'MemberExpression' ) {
-		if ( node.computed ) { return null; }
-		parts.unshift( node.property.name );
-
-		node = node.object;
+			|| !options.ignoreReturnAwaitYield();
 	}
 
-	if ( node.type !== 'Identifier' ) { return null; }
-
-	const name = node.name;
-	parts.unshift( name );
-
-	return { name, keypath: parts.join( '.' ) };
-}
-
-const pureFunctions = {};
-
-const arrayTypes = 'Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split( ' ' );
-const simdTypes = 'Int8x16 Int16x8 Int32x4 Float32x4 Float64x2'.split( ' ' );
-const simdMethods = 'abs add and bool check div equal extractLane fromFloat32x4 fromFloat32x4Bits fromFloat64x2 fromFloat64x2Bits fromInt16x8Bits fromInt32x4 fromInt32x4Bits fromInt8x16Bits greaterThan greaterThanOrEqual lessThan lessThanOrEqual load max maxNum min minNum mul neg not notEqual or reciprocalApproximation reciprocalSqrtApproximation replaceLane select selectBits shiftLeftByScalar shiftRightArithmeticByScalar shiftRightLogicalByScalar shuffle splat sqrt store sub swizzle xor'.split( ' ' );
-const allSimdMethods = [];
-simdTypes.forEach( t => {
-	simdMethods.forEach( m => {
-		allSimdMethods.push( `SIMD.${t}.${m}` );
-	});
-});
-
-[
-	'Array.isArray',
-	'Error', 'EvalError', 'InternalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError',
-	'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'unescape',
-	'Object', 'Object.create', 'Object.getNotifier', 'Object.getOwn', 'Object.getOwnPropertyDescriptor', 'Object.getOwnPropertyNames', 'Object.getOwnPropertySymbols', 'Object.getPrototypeOf', 'Object.is', 'Object.isExtensible', 'Object.isFrozen', 'Object.isSealed', 'Object.keys',
-	'Function', 'Boolean',
-	'Number', 'Number.isFinite', 'Number.isInteger', 'Number.isNaN', 'Number.isSafeInteger', 'Number.parseFloat', 'Number.parseInt',
-	'Symbol', 'Symbol.for', 'Symbol.keyFor',
-	'Math.abs', 'Math.acos', 'Math.acosh', 'Math.asin', 'Math.asinh', 'Math.atan', 'Math.atan2', 'Math.atanh', 'Math.cbrt', 'Math.ceil', 'Math.clz32', 'Math.cos', 'Math.cosh', 'Math.exp', 'Math.expm1', 'Math.floor', 'Math.fround', 'Math.hypot', 'Math.imul', 'Math.log', 'Math.log10', 'Math.log1p', 'Math.log2', 'Math.max', 'Math.min', 'Math.pow', 'Math.random', 'Math.round', 'Math.sign', 'Math.sin', 'Math.sinh', 'Math.sqrt', 'Math.tan', 'Math.tanh', 'Math.trunc',
-	'Date', 'Date.UTC', 'Date.now', 'Date.parse',
-	'String', 'String.fromCharCode', 'String.fromCodePoint', 'String.raw',
-	'RegExp',
-	'Map', 'Set', 'WeakMap', 'WeakSet',
-	'ArrayBuffer', 'ArrayBuffer.isView',
-	'DataView',
-	'JSON.parse', 'JSON.stringify',
-	'Promise.all', 'Promise.race', 'Promise.resolve',
-	'Intl.Collator', 'Intl.Collator.supportedLocalesOf', 'Intl.DateTimeFormat', 'Intl.DateTimeFormat.supportedLocalesOf', 'Intl.NumberFormat', 'Intl.NumberFormat.supportedLocalesOf'
-
-	// TODO properties of e.g. window...
-].concat(
-	arrayTypes,
-	arrayTypes.map( t => `${t}.from` ),
-	arrayTypes.map( t => `${t}.of` ),
-	simdTypes.map( t => `SIMD.${t}` ),
-	allSimdMethods
-).forEach( name => pureFunctions[ name ] = true );
-
-const currentlyCalling = new Set();
-
-function isES5Function ( node ) {
-	return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
+	hasEffectsAsExpressionStatement ( options ) {
+		return this.hasEffects( options );
+	}
 }
 
-function hasEffectsNew ( node ) {
-	let inner = node;
-
-	if ( inner.type === 'ExpressionStatement' ) {
-		inner = inner.expression;
+const operators = {
+	'==': ( left, right ) => left == right,
+	'!=': ( left, right ) => left != right,
+	'===': ( left, right ) => left === right,
+	'!==': ( left, right ) => left !== right,
+	'<': ( left, right ) => left < right,
+	'<=': ( left, right ) => left <= right,
+	'>': ( left, right ) => left > right,
+	'>=': ( left, right ) => left >= right,
+	'<<': ( left, right ) => left << right,
+	'>>': ( left, right ) => left >> right,
+	'>>>': ( left, right ) => left >>> right,
+	'+': ( left, right ) => left + right,
+	'-': ( left, right ) => left - right,
+	'*': ( left, right ) => left * right,
+	'/': ( left, right ) => left / right,
+	'%': ( left, right ) => left % right,
+	'|': ( left, right ) => left | right,
+	'^': ( left, right ) => left ^ right,
+	'&': ( left, right ) => left & right,
+	'**': ( left, right ) => Math.pow( left, right ),
+	in: ( left, right ) => left in right,
+	instanceof: ( left, right ) => left instanceof right
+};
 
-		if ( inner.type === 'AssignmentExpression' ) {
-			if ( inner.right.hasEffects( { inNestedFunctionCall: true } ) ) {
-				return true;
+class BinaryExpression extends Node$1 {
+	getValue () {
+		const leftValue = this.left.getValue();
+		if ( leftValue === UNKNOWN_VALUE ) { return UNKNOWN_VALUE; }
 
-			} else {
-				inner = inner.left;
+		const rightValue = this.right.getValue();
+		if ( rightValue === UNKNOWN_VALUE ) { return UNKNOWN_VALUE; }
 
-				if ( inner.type === 'MemberExpression' ) {
-					if ( inner.computed && inner.property.hasEffects( { inNestedFunctionCall: true } ) ) {
-						return true;
+		if ( !operators[ this.operator ] ) { return UNKNOWN_VALUE; }
 
-					} else {
-						inner = inner.object;
+		return operators[ this.operator ]( leftValue, rightValue );
+	}
+}
 
-						if ( inner.type === 'ThisExpression' ) {
-							return false;
-						}
-					}
-				}
-			}
+class Statement extends Node$1 {
+	render ( code, es ) {
+		if ( !this.module.bundle.treeshake || this.included ) {
+			super.render( code, es );
+		} else {
+			code.remove( this.leadingCommentStart || this.start, this.next || this.end );
 		}
 	}
-
-	return node.hasEffects( { inNestedFunctionCall: true } );
 }
 
-function fnHasEffects ( fn, isNew ) {
-	if ( currentlyCalling.has( fn ) ) { return false; } // prevent infinite loops... TODO there must be a better way
-	currentlyCalling.add( fn );
-
-	// handle body-less arrow functions
-	const body = fn.body.type === 'BlockStatement' ? fn.body.body : [ fn.body ];
-
-	for ( const node of body ) {
-		if ( isNew ? hasEffectsNew( node ) : node.hasEffects( { inNestedFunctionCall: true } ) ) {
-			currentlyCalling.delete( fn );
-			return true;
+class BlockScope extends Scope {
+	addDeclaration ( identifier, isHoisted, init ) {
+		if ( isHoisted ) {
+			this.parent.addDeclaration( identifier, isHoisted, init );
+		} else {
+			super.addDeclaration( identifier, false, init );
 		}
 	}
-
-	currentlyCalling.delete( fn );
-	return false;
 }
 
-function callHasEffects ( scope, callee, isNew ) {
-	const values = new Set( [ callee ] );
-
-	for ( const node of values ) {
-		if ( node.type === 'UNKNOWN' ) { return true; } // err on side of caution
+class BlockStatement extends Statement {
+	bind () {
+		this.body.forEach( node => node.bind() );
+	}
 
-		if ( /Function/.test( node.type ) ) {
-			if ( fnHasEffects( node, isNew && isES5Function( node ) ) ) { return true; }
-		}
+	hasEffects ( options ) {
+		// Empty block statements do not have effects even though they may be included as e.g. function body
+		return this.body.some( child => child.hasEffects( options ) );
+	}
 
-		else if ( /Class/.test( node.type ) ) {
-			// TODO find constructor (may belong to a superclass)
+	includeInBundle () {
+		if ( this.isFullyIncluded() ) { return false; }
+		let addedNewNodes = false;
+		this.body.forEach( node => {
+			if ( node.shouldBeIncluded() ) {
+				if ( node.includeInBundle() ) {
+					addedNewNodes = true;
+				}
+			}
+		} );
+		if ( !this.included || addedNewNodes ) {
+			this.included = true;
 			return true;
 		}
+		return false;
+	}
 
-		else if ( isReference( node ) ) {
-			const flattened = flatten( node );
-			const declaration = scope.findDeclaration( flattened.name );
-
-			if ( declaration.isGlobal ) {
-				if ( !pureFunctions[ flattened.keypath ] ) { return true; }
-			}
+	initialiseAndReplaceScope ( scope ) {
+		this.scope = scope;
+		this.initialiseNode();
+		this.initialiseChildren( scope );
+	}
 
-			else if ( declaration.isExternal ) {
-				return true; // TODO make this configurable? e.g. `path.[whatever]`
-			}
+	initialiseChildren () {
+		let lastNode;
+		for ( const node of this.body ) {
+			node.initialise( this.scope );
 
-			else {
-				if ( node.declaration ) {
-					node.declaration.gatherPossibleValues( values );
-				} else {
-					return true;
-				}
-			}
+			if ( lastNode ) { lastNode.next = node.start; }
+			lastNode = node;
 		}
+	}
 
-		else if ( node.gatherPossibleValues ) {
-			node.gatherPossibleValues( values );
-		}
+	initialiseScope ( parentScope ) {
+		this.scope = new BlockScope( { parent: parentScope } );
+	}
 
-		else {
-			// probably an error in the user's code — err on side of caution
-			return true;
+	render ( code, es ) {
+		if ( this.body.length ) {
+			for ( const node of this.body ) {
+				node.render( code, es );
+			}
+		} else {
+			Statement.prototype.render.call( this, code, es );
 		}
 	}
+}
 
-	return false;
+class BreakStatement extends Node$1 {
+	hasEffects ( options ) {
+		return super.hasEffects( options )
+			|| !options.ignoreBreakStatements()
+			|| (this.label && !options.ignoreLabel( this.label.name ));
+	}
 }
 
 class CallExpression extends Node$1 {
 	bind () {
 		if ( this.callee.type === 'Identifier' ) {
-			const declaration = this.scope.findDeclaration( this.callee.name );
+			const variable = this.scope.findVariable( this.callee.name );
 
-			if ( declaration.isNamespace ) {
+			if ( variable.isNamespace ) {
 				this.module.error( {
 					code: 'CANNOT_CALL_NAMESPACE',
 					message: `Cannot call a namespace ('${this.callee.name}')`
 				}, this.start );
 			}
 
-			if ( this.callee.name === 'eval' && declaration.isGlobal ) {
+			if ( this.callee.name === 'eval' && variable.isGlobal ) {
 				this.module.warn( {
 					code: 'EVAL',
 					message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
@@ -6330,12 +6425,13 @@ class CallExpression extends Node$1 {
 		}
 
 		super.bind();
+		this.callee.bindCall( { withNew: false } );
 	}
 
 	hasEffects ( options ) {
 		return this.included
 			|| this.arguments.some( child => child.hasEffects( options ) )
-			|| callHasEffects( this.scope, this.callee, false );
+			|| this.callee.hasEffectsWhenCalled( options.getHasEffectsWhenCalledOptions( this.callee ) );
 	}
 
 	hasEffectsAsExpressionStatement ( options ) {
@@ -6345,27 +6441,49 @@ class CallExpression extends Node$1 {
 
 class CatchClause extends Node$1 {
 	initialiseChildren () {
-		if ( this.param ) {
-			this.param.initialise( this.scope );
-			extractNames( this.param ).forEach( name => this.scope.addDeclaration( name, null, false, true ) );
-		}
+		this.param && this.param.initialiseAndDeclare( this.scope, 'parameter' );
 		this.body.initialiseAndReplaceScope( this.scope );
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+		this.scope = new BlockScope( { parent: parentScope } );
 	}
 }
 
-class Class extends Node$1 {
-	addReference () {}
+class ClassBody extends Node$1 {
+	bindCall ( callOptions ) {
+		if ( this.classConstructor ) {
+			this.classConstructor.bindCall( callOptions );
+		}
+	}
 
-	getName () {
-		return this.name;
+	hasEffectsWhenCalled ( options ) {
+		if ( this.classConstructor ) {
+			return this.classConstructor.hasEffectsWhenCalled( options );
+		}
+		return false;
+	}
+
+	initialiseNode () {
+		this.classConstructor = this.body.find( method => method.kind === 'constructor' );
+	}
+}
+
+class ClassNode extends Node$1 {
+	bindCall ( callOptions ) {
+		if ( this.superClass ) {
+			this.superClass.bindCall( callOptions );
+		}
+		this.body.bindCall( callOptions );
+	}
+
+	hasEffectsAsExpressionStatement ( options ) {
+		return this.hasEffects( options );
+	}
+
+	hasEffectsWhenCalled ( options ) {
+		return this.body.hasEffectsWhenCalled( options )
+			|| ( this.superClass && this.superClass.hasEffectsWhenCalled( options ) );
 	}
 
 	initialiseChildren () {
@@ -6376,28 +6494,14 @@ class Class extends Node$1 {
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true
-		} );
+		this.scope = new Scope( { parent: parentScope } );
 	}
 }
 
-class ClassDeclaration extends Class {
-	gatherPossibleValues ( values ) {
-		values.add( this );
-	}
-
-	hasEffects () {
-		return this.included;
-	}
-
+class ClassDeclaration extends ClassNode {
 	initialiseChildren ( parentScope ) {
-		if ( this.id ) {
-			this.name = this.id.name;
-			parentScope.addDeclaration( this.name, this, false, false );
-			this.id.initialise( parentScope );
-		}
+		// Class declarations are like let declarations: Not hoisted, can be reassigned, cannot be redeclared
+		this.id && this.id.initialiseAndDeclare( parentScope, 'class', this );
 		super.initialiseChildren( parentScope );
 	}
 
@@ -6410,14 +6514,10 @@ class ClassDeclaration extends Class {
 	}
 }
 
-class ClassExpression extends Class {
-	initialiseChildren (parentScope) {
-		if ( this.id ) {
-			this.name = this.id.name;
-			this.scope.addDeclaration( this.name, this, false, false );
-			this.id.initialise( this.scope );
-		}
-		super.initialiseChildren(parentScope);
+class ClassExpression extends ClassNode {
+	initialiseChildren ( parentScope ) {
+		this.id && this.id.initialiseAndDeclare( this.scope, 'class', this );
+		super.initialiseChildren( parentScope );
 	}
 }
 
@@ -6440,16 +6540,6 @@ class ConditionalExpression extends Node$1 {
 		}
 	}
 
-	gatherPossibleValues ( values ) {
-		const testValue = this.test.getValue();
-
-		if ( testValue === UNKNOWN_VALUE ) {
-			values.add( this.consequent ).add( this.alternate );
-		} else {
-			values.add( testValue ? this.consequent : this.alternate );
-		}
-	}
-
 	getValue () {
 		const testValue = this.test.getValue();
 		if ( testValue === UNKNOWN_VALUE ) { return UNKNOWN_VALUE; }
@@ -6493,7 +6583,7 @@ class DoWhileStatement extends Statement {
 		return (
 			this.included
 			|| this.test.hasEffects( options )
-			|| this.body.hasEffects( Object.assign( {}, options, { inNestedBreakableStatement: true } ) )
+			|| this.body.hasEffects( options.setIgnoreBreakStatements() )
 		);
 	}
 }
@@ -6519,6 +6609,10 @@ class ExportAllDeclaration extends Node$1 {
 const functionOrClassDeclaration = /^(?:Function|Class)Declaration/;
 
 class ExportDefaultDeclaration extends Node$1 {
+	addCall ( options ) {
+		this.declaration.bindCall( options );
+	}
+
 	addReference ( reference ) {
 		this.name = reference.name;
 		if ( this.original ) { this.original.addReference( reference ); }
@@ -6526,15 +6620,11 @@ class ExportDefaultDeclaration extends Node$1 {
 
 	bind () {
 		const name = ( this.declaration.id && this.declaration.id.name ) || this.declaration.name;
-		if ( name ) { this.original = this.scope.findDeclaration( name ); }
+		if ( name ) { this.original = this.scope.findVariable( name ); }
 
 		this.declaration.bind();
 	}
 
-	gatherPossibleValues ( values ) {
-		this.declaration.gatherPossibleValues( values );
-	}
-
 	getName ( es ) {
 		if ( this.original && !this.original.isReassigned ) {
 			return this.original.getName( es );
@@ -6543,7 +6633,11 @@ class ExportDefaultDeclaration extends Node$1 {
 		return this.name;
 	}
 
-	includeDeclaration () {
+	hasEffectsWhenCalled ( options ) {
+		return this.declaration.hasEffectsWhenCalled( options );
+	}
+
+	includeVariable () {
 		if ( this.included ) {
 			return false;
 		}
@@ -6564,7 +6658,7 @@ class ExportDefaultDeclaration extends Node$1 {
 		this.isDefault = true;
 
 		this.name = ( this.declaration.id && this.declaration.id.name ) || this.declaration.name || this.module.basename();
-		this.scope.declarations.default = this;
+		this.scope.variables.default = this;
 	}
 
 	// TODO this is total chaos, tidy it up
@@ -6612,7 +6706,7 @@ class ExportDefaultDeclaration extends Node$1 {
 				if ( functionOrClassDeclaration.test( this.declaration.type ) ) {
 					code.remove( this.leadingCommentStart || this.start, this.next || this.end );
 				} else {
-					const hasEffects = this.declaration.hasEffects( {} );
+					const hasEffects = this.declaration.hasEffects( ExecutionPathOptions.create() );
 					code.remove( this.start, hasEffects ? declaration_start : this.next || this.end );
 				}
 			} else if ( name === this.declaration.name ) {
@@ -6627,11 +6721,12 @@ class ExportDefaultDeclaration extends Node$1 {
 
 class ExportNamedDeclaration extends Node$1 {
 	bind () {
+		// Do not bind specifiers
 		if ( this.declaration ) { this.declaration.bind(); }
 	}
 
-	hasEffects () {
-		return this.included || (this.declaration && this.declaration.hasEffects());
+	hasEffects ( options ) {
+		return this.included || (this.declaration && this.declaration.hasEffects( options ));
 	}
 
 	initialiseNode () {
@@ -6679,7 +6774,7 @@ class ForStatement extends Statement {
 			|| this.init && this.init.hasEffects( options )
 			|| this.test && this.test.hasEffects( options )
 			|| this.update && this.update.hasEffects( options )
-			|| this.body.hasEffects( Object.assign( {}, options, { inNestedBreakableStatement: true } ) )
+			|| this.body.hasEffects( options.setIgnoreBreakStatements() )
 		);
 	}
 
@@ -6697,11 +6792,7 @@ class ForStatement extends Statement {
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+		this.scope = new BlockScope( { parent: parentScope } );
 	}
 }
 
@@ -6709,9 +6800,9 @@ class ForInStatement extends Statement {
 	hasEffects ( options ) {
 		return (
 			this.included
-			|| this.left && this.left.hasEffects( options )
+			|| this.left && (this.left.hasEffects( options ) || this.left.hasEffectsWhenAssigned( options ))
 			|| this.right && this.right.hasEffects( options )
-			|| this.body.hasEffects( Object.assign( {}, options, { inNestedBreakableStatement: true } ) )
+			|| this.body.hasEffects( options.setIgnoreBreakStatements() )
 		);
 	}
 
@@ -6725,39 +6816,35 @@ class ForInStatement extends Statement {
 
 	includeInBundle () {
 		let addedNewNodes = super.includeInBundle();
-		if ( this.left.includeDeclaration() ) {
+		if ( this.left.includeWithAllDeclarations() ) {
 			addedNewNodes = true;
 		}
 		return addedNewNodes;
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+		this.scope = new BlockScope( { parent: parentScope } );
 	}
 }
 
 class ForOfStatement extends Statement {
 	bind () {
 		super.bind();
-		this.left.assignExpression( UNKNOWN_ASSIGNMENT );
+		this.left.bindAssignment( UNKNOWN_ASSIGNMENT );
 	}
 
 	hasEffects ( options ) {
 		return (
 			this.included
-			|| this.left && this.left.hasEffects( options )
+			|| this.left && (this.left.hasEffects( options ) || this.left.hasEffectsWhenAssigned( options ))
 			|| this.right && this.right.hasEffects( options )
-			|| this.body.hasEffects( Object.assign( {}, options, { inNestedBreakableStatement: true } ) )
+			|| this.body.hasEffects( options.setIgnoreBreakStatements() )
 		);
 	}
 
 	includeInBundle () {
 		let addedNewNodes = super.includeInBundle();
-		if ( this.left.includeDeclaration() ) {
+		if ( this.left.includeWithAllDeclarations() ) {
 			addedNewNodes = true;
 		}
 		return addedNewNodes;
@@ -6772,45 +6859,65 @@ class ForOfStatement extends Statement {
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+		this.scope = new BlockScope( { parent: parentScope } );
 	}
 }
 
-class FunctionDeclaration extends Function$1 {
-	addReference () {}
+class FunctionScope extends Scope {
+	constructor ( options ) {
+		if ( options === void 0 ) options = {};
 
-	assignExpression ( expression ) {
-		this.assignedExpressions.add( expression );
-		this.isReassigned = true;
+		super( options );
+		this.variables.arguments = new ParameterVariable( 'arguments' );
+		this.variables.this = new LocalVariable( 'this', null, null );
 	}
 
-	gatherPossibleValues ( values ) {
-		values.add( this );
+	findLexicalBoundary () {
+		return this;
 	}
+}
 
-	getName () {
-		return this.name;
-	}
+class FunctionNode extends Node$1 {
+	bindCall ( ref ) {
+		var withNew = ref.withNew;
 
-	initialiseChildren ( parentScope ) {
-		if ( this.id ) {
-			this.name = this.id.name; // may be overridden by bundle.deconflict
-			parentScope.addDeclaration( this.name, this, false, false );
-			this.id.initialise( parentScope );
+		const thisVariable = this.scope.findVariable( 'this' );
+
+		if ( withNew ) {
+			thisVariable.assignExpression( UNKNOWN_OBJECT_LITERAL );
+		} else {
+			thisVariable.assignExpression( UNKNOWN_ASSIGNMENT );
 		}
-		super.initialiseChildren( parentScope );
+	}
+
+	hasEffects ( options ) {
+		return this.included || (this.id && this.id.hasEffects( options ));
+	}
+
+	hasEffectsAsExpressionStatement ( options ) {
+		return this.hasEffects( options );
+	}
+
+	hasEffectsWhenCalled ( options ) {
+		const innerOptions = options.setIgnoreSafeThisMutations();
+		return this.params.some( param => param.hasEffects( innerOptions ) )
+			|| this.body.hasEffects( innerOptions );
 	}
 
 	hasEffectsWhenMutated () {
 		return this.included;
 	}
 
-	initialiseNode () {
-		this.assignedExpressions = new Set( [ this ] );
+	initialiseScope ( parentScope ) {
+		this.scope = new FunctionScope( { parent: parentScope } );
+	}
+}
+
+class FunctionDeclaration extends FunctionNode {
+	initialiseChildren ( parentScope ) {
+		this.id && this.id.initialiseAndDeclare( parentScope, 'function', this );
+		this.params.forEach( param => param.initialiseAndDeclare( this.scope, 'parameter' ) );
+		this.body.initialiseAndReplaceScope( new Scope( { parent: this.scope } ) );
 	}
 
 	render ( code, es ) {
@@ -6822,21 +6929,43 @@ class FunctionDeclaration extends Function$1 {
 	}
 }
 
-class FunctionExpression extends Function$1 {
-	addReference () {}
+class FunctionExpression extends FunctionNode {
+	initialiseChildren () {
+		this.id && this.id.initialiseAndDeclare( this.scope, 'function', this );
+		this.params.forEach( param => param.initialiseAndDeclare( this.scope, 'parameter' ) );
+		this.body.initialiseAndReplaceScope( new Scope( { parent: this.scope } ) );
+	}
+}
 
-	getName () {
-		return this.name;
+function isReference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && isReference(node.object, node);
 	}
 
-	initialiseChildren ( parentScope ) {
-		if ( this.id ) {
-			this.name = this.id.name; // may be overridden by bundle.deconflict
-			this.scope.addDeclaration( this.name, this, false, false );
-			this.id.initialise( this.scope );
+	if (node.type === 'Identifier') {
+		// the only time we could have an identifier node without a parent is
+		// if it's the entire body of a function without a block statement –
+		// i.e. an arrow function expression like `a => a`
+		if (!parent) return true;
+
+		// TODO is this right?
+		if (parent.type === 'MemberExpression' || parent.type === 'MethodDefinition') {
+			return parent.computed || node === parent.object;
 		}
-		super.initialiseChildren( parentScope );
+
+		// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+		if (parent.type === 'Property') return parent.computed || node === parent.value;
+
+		// disregard the `bar` in `class Foo { bar () {...} }`
+		if (parent.type === 'MethodDefinition') return false;
+
+		// disregard the `bar` in `export { foo as bar }`
+		if (parent.type === 'ExportSpecifier' && node !== parent.local) return false;
+
+		return true;
 	}
+
+	return false;
 }
 
 function isAssignmentPatternLhs ( node, parent ) {
@@ -6855,54 +6984,74 @@ function isAssignmentPatternLhs ( node, parent ) {
 }
 
 class Identifier extends Node$1 {
-	assignExpression ( expression ) {
-		if ( this.declaration ) {
-			this.declaration.assignExpression( expression );
+	bind () {
+		if ( isReference( this, this.parent ) || isAssignmentPatternLhs( this, this.parent ) ) {
+			this.variable = this.scope.findVariable( this.name );
+			this.variable.addReference( this );
 		}
 	}
 
-	bind () {
-		if ( isReference( this, this.parent ) || isAssignmentPatternLhs( this, this.parent ) ) {
-			this.declaration = this.scope.findDeclaration( this.name );
-			this.declaration.addReference( this ); // TODO necessary?
+	bindAssignment ( expression ) {
+		if ( this.variable ) {
+			this.variable.assignExpression( expression );
 		}
 	}
 
-	gatherPossibleValues ( values ) {
-		if ( isReference( this, this.parent ) ) {
-			values.add( this );
+	bindCall ( callOptions ) {
+		if ( this.variable ) {
+			this.variable.addCall( callOptions );
 		}
 	}
 
 	hasEffectsAsExpressionStatement ( options ) {
-		return this.hasEffects( options ) || this.declaration.isGlobal;
+		return this.hasEffects( options ) || this.variable.isGlobal;
 	}
 
 	hasEffectsWhenAssigned () {
-		return this.declaration && this.declaration.included;
+		return this.variable && this.variable.included;
+	}
+
+	hasEffectsWhenCalled ( options ) {
+		if ( !this.variable ) {
+			return true;
+		}
+		return this.variable.hasEffectsWhenCalled( options );
 	}
 
 	hasEffectsWhenMutated ( options ) {
-		return this.declaration &&
-			(this.declaration.included ||
-			this.declaration.isParam ||
-			this.declaration.isGlobal ||
-			this.declaration.isExternal ||
-			this.declaration.isNamespace ||
-			!this.declaration.assignedExpressions ||
-			Array.from( this.declaration.assignedExpressions ).some( node => node.hasEffectsWhenMutated( options ) ));
+		return this.variable && this.variable.hasEffectsWhenMutated( options );
 	}
 
 	includeInBundle () {
 		if ( this.included ) { return false; }
 		this.included = true;
-		this.declaration && this.declaration.includeDeclaration();
+		this.variable && this.variable.includeVariable();
 		return true;
 	}
 
+	initialiseAndDeclare ( parentScope, kind, init ) {
+		this.initialiseScope( parentScope );
+		switch ( kind ) {
+			case 'var':
+			case 'function':
+				this.scope.addDeclaration( this, true, init );
+				break;
+			case 'let':
+			case 'const':
+			case 'class':
+				this.scope.addDeclaration( this, false, init );
+				break;
+			case 'parameter':
+				this.scope.addParameterDeclaration( this );
+				break;
+			default:
+				throw new Error( 'Unexpected identifier kind', kind );
+		}
+	}
+
 	render ( code, es ) {
-		if ( this.declaration ) {
-			const name = this.declaration.getName( es );
+		if ( this.variable ) {
+			const name = this.variable.getName( es );
 			if ( name !== this.name ) {
 				code.overwrite( this.start, this.end, name, { storeName: true, contentOnly: false } );
 
@@ -6925,7 +7074,7 @@ const statementsWithIfStatements = new Set( [
 	'WhileStatement'
 ] );
 
-function handleVarDeclarations ( node, scope ) {
+function getHoistedVars ( node, scope ) {
 	const hoistedVars = [];
 
 	function visit ( node ) {
@@ -6935,7 +7084,7 @@ function handleVarDeclarations ( node, scope ) {
 				declarator.initialise( scope );
 
 				extractNames( declarator.id ).forEach( name => {
-					if ( !~hoistedVars.indexOf( name ) ) { hoistedVars.push( name ); }
+					if ( hoistedVars.indexOf( name ) < 0 ) { hoistedVars.push( name ); }
 				} );
 			} );
 		}
@@ -6950,29 +7099,24 @@ function handleVarDeclarations ( node, scope ) {
 	return hoistedVars;
 }
 
-// TODO DRY this out
 class IfStatement extends Statement {
 	initialiseChildren ( parentScope ) {
+		super.initialiseChildren( parentScope );
 		if ( this.module.bundle.treeshake ) {
 			this.testValue = this.test.getValue();
 
 			if ( this.testValue === UNKNOWN_VALUE ) {
-				super.initialiseChildren( parentScope );
-			} else if ( this.testValue ) {
-				this.consequent.initialise( this.scope );
+				return;
+			}
+			if ( this.testValue ) {
 				if ( this.alternate ) {
-					this.hoistedVars = handleVarDeclarations( this.alternate, this.scope );
+					this.hoistedVars = getHoistedVars( this.alternate, this.scope );
 					this.alternate = null;
 				}
 			} else {
-				if ( this.alternate ) {
-					this.alternate.initialise( this.scope );
-				}
-				this.hoistedVars = handleVarDeclarations( this.consequent, this.scope );
+				this.hoistedVars = getHoistedVars( this.consequent, this.scope );
 				this.consequent = null;
 			}
-		} else {
-			super.initialiseChildren( parentScope );
 		}
 	}
 
@@ -6991,8 +7135,8 @@ class IfStatement extends Statement {
 				if ( this.hoistedVars ) {
 					const names = this.hoistedVars
 						.map( name => {
-							const declaration = this.scope.findDeclaration( name );
-							return declaration.included ? declaration.getName() : null;
+							const variable = this.scope.findVariable( name );
+							return variable.included ? variable.getName() : null;
 						} )
 						.filter( Boolean );
 
@@ -7042,15 +7186,21 @@ class ImportDeclaration extends Node$1 {
 	}
 }
 
+class LabeledStatement extends Statement {
+	hasEffects ( options ) {
+		return this.body.hasEffects(
+			options
+				.setIgnoreLabel( this.label.name )
+				.setIgnoreBreakStatements()
+		);
+	}
+}
+
 class Literal extends Node$1 {
 	getValue () {
 		return this.value;
 	}
 
-	gatherPossibleValues ( values ) {
-		values.add( this );
-	}
-
 	hasEffectsWhenMutated () {
 		return false;
 	}
@@ -7090,6 +7240,63 @@ class LogicalExpression extends Node$1 {
 	}
 }
 
+function flatten ( node ) {
+	const parts = [];
+	while ( node.type === 'MemberExpression' ) {
+		if ( node.computed ) { return null; }
+		parts.unshift( node.property.name );
+
+		node = node.object;
+	}
+
+	if ( node.type !== 'Identifier' ) { return null; }
+
+	const name = node.name;
+	parts.unshift( name );
+
+	return { name, keypath: parts.join( '.' ) };
+}
+
+const pureFunctions = {};
+
+const arrayTypes = 'Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split( ' ' );
+const simdTypes = 'Int8x16 Int16x8 Int32x4 Float32x4 Float64x2'.split( ' ' );
+const simdMethods = 'abs add and bool check div equal extractLane fromFloat32x4 fromFloat32x4Bits fromFloat64x2 fromFloat64x2Bits fromInt16x8Bits fromInt32x4 fromInt32x4Bits fromInt8x16Bits greaterThan greaterThanOrEqual lessThan lessThanOrEqual load max maxNum min minNum mul neg not notEqual or reciprocalApproximation reciprocalSqrtApproximation replaceLane select selectBits shiftLeftByScalar shiftRightArithmeticByScalar shiftRightLogicalByScalar shuffle splat sqrt store sub swizzle xor'.split( ' ' );
+const allSimdMethods = [];
+simdTypes.forEach( t => {
+	simdMethods.forEach( m => {
+		allSimdMethods.push( `SIMD.${t}.${m}` );
+	});
+});
+
+[
+	'Array.isArray',
+	'Error', 'EvalError', 'InternalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError',
+	'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'unescape',
+	'Object', 'Object.create', 'Object.getNotifier', 'Object.getOwn', 'Object.getOwnPropertyDescriptor', 'Object.getOwnPropertyNames', 'Object.getOwnPropertySymbols', 'Object.getPrototypeOf', 'Object.is', 'Object.isExtensible', 'Object.isFrozen', 'Object.isSealed', 'Object.keys',
+	'Function', 'Boolean',
+	'Number', 'Number.isFinite', 'Number.isInteger', 'Number.isNaN', 'Number.isSafeInteger', 'Number.parseFloat', 'Number.parseInt',
+	'Symbol', 'Symbol.for', 'Symbol.keyFor',
+	'Math.abs', 'Math.acos', 'Math.acosh', 'Math.asin', 'Math.asinh', 'Math.atan', 'Math.atan2', 'Math.atanh', 'Math.cbrt', 'Math.ceil', 'Math.clz32', 'Math.cos', 'Math.cosh', 'Math.exp', 'Math.expm1', 'Math.floor', 'Math.fround', 'Math.hypot', 'Math.imul', 'Math.log', 'Math.log10', 'Math.log1p', 'Math.log2', 'Math.max', 'Math.min', 'Math.pow', 'Math.random', 'Math.round', 'Math.sign', 'Math.sin', 'Math.sinh', 'Math.sqrt', 'Math.tan', 'Math.tanh', 'Math.trunc',
+	'Date', 'Date.UTC', 'Date.now', 'Date.parse',
+	'String', 'String.fromCharCode', 'String.fromCodePoint', 'String.raw',
+	'RegExp',
+	'Map', 'Set', 'WeakMap', 'WeakSet',
+	'ArrayBuffer', 'ArrayBuffer.isView',
+	'DataView',
+	'JSON.parse', 'JSON.stringify',
+	'Promise.all', 'Promise.race', 'Promise.resolve',
+	'Intl.Collator', 'Intl.Collator.supportedLocalesOf', 'Intl.DateTimeFormat', 'Intl.DateTimeFormat.supportedLocalesOf', 'Intl.NumberFormat', 'Intl.NumberFormat.supportedLocalesOf'
+
+	// TODO properties of e.g. window...
+].concat(
+	arrayTypes,
+	arrayTypes.map( t => `${t}.from` ),
+	arrayTypes.map( t => `${t}.of` ),
+	simdTypes.map( t => `SIMD.${t}` ),
+	allSimdMethods
+).forEach( name => pureFunctions[ name ] = true );
+
 const validProp = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 
 class Keypath {
@@ -7122,15 +7329,15 @@ class MemberExpression extends Node$1 {
 		const keypath = new Keypath( this );
 
 		if ( !keypath.computed && keypath.root.type === 'Identifier' ) {
-			let declaration = this.scope.findDeclaration( keypath.root.name );
+			let variable = this.scope.findVariable( keypath.root.name );
 
-			while ( declaration.isNamespace && keypath.parts.length ) {
-				const exporterId = declaration.module.id;
+			while ( variable.isNamespace && keypath.parts.length ) {
+				const exporterId = variable.module.id;
 
 				const part = keypath.parts[ 0 ];
-				declaration = declaration.module.traceExport( part.name || part.value );
+				variable = variable.module.traceExport( part.name || part.value );
 
-				if ( !declaration ) {
+				if ( !variable ) {
 					this.module.warn( {
 						code: 'MISSING_EXPORT',
 						missing: part.name || part.value,
@@ -7151,10 +7358,10 @@ class MemberExpression extends Node$1 {
 				return; // not a namespaced declaration
 			}
 
-			this.declaration = declaration;
+			this.variable = variable;
 
-			if ( declaration.isExternal ) {
-				declaration.module.suggestName( keypath.root.name );
+			if ( variable.isExternal ) {
+				variable.module.suggestName( keypath.root.name );
 			}
 		}
 
@@ -7163,8 +7370,10 @@ class MemberExpression extends Node$1 {
 		}
 	}
 
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT ); // TODO
+	bindCall ( callOptions ) {
+		if ( this.variable ) {
+			this.variable.addCall( callOptions );
+		}
 	}
 
 	hasEffectsWhenAssigned ( options ) {
@@ -7173,16 +7382,27 @@ class MemberExpression extends Node$1 {
 
 	includeInBundle () {
 		let addedNewNodes = super.includeInBundle();
-		if ( this.declaration && !this.declaration.included ) {
-			this.declaration.includeDeclaration();
+		if ( this.variable && !this.variable.included ) {
+			this.variable.includeVariable();
 			addedNewNodes = true;
 		}
 		return addedNewNodes;
 	}
 
+	hasEffectsWhenCalled ( options ) {
+		if ( this.variable ) {
+			return this.variable.hasEffectsWhenCalled( options );
+		}
+		if ( !isReference( this ) ) {
+			return true;
+		}
+		const flattenedNode = flatten( this );
+		return !(this.scope.findVariable( flattenedNode.name ).isGlobal && pureFunctions[ flattenedNode.keypath ]);
+	}
+
 	render ( code, es ) {
-		if ( this.declaration ) {
-			const name = this.declaration.getName( es );
+		if ( this.variable ) {
+			const name = this.variable.getName( es );
 			if ( name !== this.name ) { code.overwrite( this.start, this.end, name, { storeName: true, contentOnly: false } ); }
 		}
 
@@ -7194,9 +7414,30 @@ class MemberExpression extends Node$1 {
 	}
 }
 
+class MethodDefinition extends Node$1 {
+	bindCall ( callOptions ) {
+		this.value.bindCall( callOptions );
+	}
+
+	hasEffects ( options ) {
+		return this.key.hasEffects( options );
+	}
+
+	hasEffectsWhenCalled ( options ) {
+		return this.value.hasEffectsWhenCalled( options );
+	}
+}
+
 class NewExpression extends Node$1 {
-	hasEffects () {
-		return this.included || callHasEffects( this.scope, this.callee, true );
+	bind () {
+		super.bind();
+		this.callee.bindCall( { withNew: true } );
+	}
+
+	hasEffects ( options ) {
+		return this.included
+			|| this.arguments.some( child => child.hasEffects( options ) )
+			|| this.callee.hasEffectsWhenCalled( options.getHasEffectsWhenCalledOptions( this.callee ) );
 	}
 }
 
@@ -7207,24 +7448,35 @@ class ObjectExpression extends Node$1 {
 }
 
 class ObjectPattern extends Node$1 {
-	assignExpression () {
-		this.eachChild( child => child.assignExpression( UNKNOWN_ASSIGNMENT ) );
+	bindAssignment ( expression ) {
+		this.properties.forEach( child => child.bindAssignment( expression ) );
 	}
 
 	hasEffectsWhenAssigned ( options ) {
 		return this.someChild( child => child.hasEffectsWhenAssigned( options ) );
 	}
+
+	initialiseAndDeclare ( parentScope, kind, init ) {
+		this.initialiseScope( parentScope );
+		this.properties.forEach( child => child.initialiseAndDeclare( parentScope, kind, init ) );
+	}
 }
 
 class Property extends Node$1 {
-	assignExpression ( expression ) {
-		this.value.assignExpression( expression );
+	bindAssignment () {
+		this.value.bindAssignment( UNKNOWN_ASSIGNMENT );
 	}
 
 	hasEffectsWhenAssigned ( options ) {
 		return this.value.hasEffectsWhenAssigned( options );
 	}
 
+	initialiseAndDeclare ( parentScope, kind, init ) {
+		this.initialiseScope( parentScope );
+		this.key.initialise( parentScope );
+		this.value.initialiseAndDeclare( parentScope, kind, init && UNKNOWN_ASSIGNMENT );
+	}
+
 	render ( code, es ) {
 		if ( !this.shorthand ) {
 			this.key.render( code, es );
@@ -7234,23 +7486,24 @@ class Property extends Node$1 {
 }
 
 class RestElement extends Node$1 {
-	assignExpression () {
-		this.argument.assignExpression( UNKNOWN_ASSIGNMENT );
+	bindAssignment () {
+		this.argument.bindAssignment( UNKNOWN_ASSIGNMENT );
 	}
 
 	hasEffectsWhenAssigned ( options ) {
 		return this.argument.hasEffectsWhenAssigned( options );
 	}
+
+	initialiseAndDeclare ( parentScope, kind ) {
+		this.initialiseScope( parentScope );
+		this.argument.initialiseAndDeclare( parentScope, kind, UNKNOWN_ASSIGNMENT );
+	}
 }
 
 class ReturnStatement extends Statement {
 	hasEffects ( options ) {
 		return super.hasEffects( options )
-			|| !options.inNestedFunctionCall;
-	}
-
-	shouldBeIncluded () {
-		return true;
+			|| !options.ignoreReturnAwaitYield();
 	}
 }
 
@@ -7277,32 +7530,28 @@ class SwitchCase extends Node$1 {
 }
 
 class SwitchStatement extends Statement {
-	hasEffects(options) {
-		return super.hasEffects(Object.assign({}, options, {inNestedBreakableStatement: true}));
+	hasEffects ( options ) {
+		return super.hasEffects( options.setIgnoreBreakStatements() );
 	}
 
 	initialiseScope ( parentScope ) {
-		this.scope = new Scope( {
-			parent: parentScope,
-			isBlockScope: true,
-			isLexicalBoundary: false
-		} );
+		this.scope = new BlockScope( { parent: parentScope } );
 	}
 }
 
 class TaggedTemplateExpression extends Node$1 {
 	bind () {
 		if ( this.tag.type === 'Identifier' ) {
-			const declaration = this.scope.findDeclaration( this.tag.name );
+			const variable = this.scope.findVariable( this.tag.name );
 
-			if ( declaration.isNamespace ) {
+			if ( variable.isNamespace ) {
 				this.module.error( {
 					code: 'CANNOT_CALL_NAMESPACE',
 					message: `Cannot call a namespace ('${this.tag.name}')`
 				}, this.start );
 			}
 
-			if ( this.tag.name === 'eval' && declaration.isGlobal ) {
+			if ( this.tag.name === 'eval' && variable.isGlobal ) {
 				this.module.warn( {
 					code: 'EVAL',
 					message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
@@ -7312,10 +7561,12 @@ class TaggedTemplateExpression extends Node$1 {
 		}
 
 		super.bind();
+		this.tag.bindCall( { withNew: false } );
 	}
 
 	hasEffects ( options ) {
-		return this.quasi.hasEffects( options ) || callHasEffects( this.scope, this.tag, false );
+		return super.hasEffects( options )
+			|| this.tag.hasEffectsWhenCalled( options.getHasEffectsWhenCalledOptions( this.tag ) );
 	}
 }
 
@@ -7348,6 +7599,14 @@ class ThisExpression extends Node$1 {
 		}
 	}
 
+	bind () {
+		this.variable = this.scope.findVariable( 'this' );
+	}
+
+	hasEffectsWhenMutated ( options ) {
+		return !options.ignoreSafeThisMutations() || this.variable.hasEffectsWhenMutated( options );
+	}
+
 	render ( code ) {
 		if ( this.alias ) {
 			code.overwrite( this.start, this.end, this.alias, { storeName: true, contentOnly: false } );
@@ -7405,8 +7664,8 @@ class UpdateExpression extends Node$1 {
 	bind () {
 		disallowIllegalReassignment( this.scope, this.argument );
 		if ( this.argument.type === 'Identifier' ) {
-			const declaration = this.scope.findDeclaration( this.argument.name );
-			declaration.isReassigned = true;
+			const variable = this.scope.findVariable( this.argument.name );
+			variable.isReassigned = true;
 		}
 		super.bind();
 	}
@@ -7420,88 +7679,25 @@ class UpdateExpression extends Node$1 {
 	}
 }
 
-class DeclaratorProxy {
-	constructor ( name, declarator, isTopLevel, init ) {
-		this.name = name;
-		this.declarator = declarator;
-
-		this.isReassigned = false;
-		this.exportName = null;
-
-		this.duplicates = [];
-		this.assignedExpressions = new Set( init ? [ init ] : null );
-	}
-
-	addReference () {
-		/* noop? */
-	}
-
-	assignExpression ( expression ) {
-		this.assignedExpressions.add( expression );
-		this.isReassigned = true;
-	}
-
-	gatherPossibleValues ( values ) {
-		this.assignedExpressions.forEach( value => values.add( value ) );
-	}
-
-	getName ( es ) {
-		// TODO destructuring...
-		if ( es ) { return this.name; }
-		if ( !this.isReassigned || !this.exportName ) { return this.name; }
-
-		return `exports.${this.exportName}`;
-	}
-
-	includeDeclaration () {
-		if ( this.included ) {
-			return false;
-		}
-		this.included = true;
-		this.declarator.includeDeclaration();
-		this.duplicates.forEach( duplicate => duplicate.includeDeclaration() );
-		return true;
-	}
-
-	toString () {
-		return this.name;
-	}
-}
-
 class VariableDeclarator extends Node$1 {
-	assignExpression () {
-		for ( const proxy of this.proxies.values() ) {
-			proxy.assignExpression( UNKNOWN_ASSIGNMENT );
-		}
+	bindAssignment ( expression ) {
+		this.id.bindAssignment( expression );
 	}
 
-	hasEffects ( options ) {
-		return super.hasEffects( options )
-			|| extractNames( this.id ).some( name => this.proxies.get( name ).included );
-	}
-
-	initialiseNode () {
-		this.proxies = new Map();
-		const lexicalBoundary = this.scope.findLexicalBoundary();
-		const init = this.init
-			? ( this.id.type === 'Identifier' ? this.init : UNKNOWN_ASSIGNMENT )
-			: null;
-
-		extractNames( this.id ).forEach( name => {
-			const proxy = new DeclaratorProxy( name, this, lexicalBoundary.isModuleScope, init );
-
-			this.proxies.set( name, proxy );
-			this.scope.addDeclaration( name, proxy, this.parent.kind === 'var' );
-		} );
+	initialiseDeclarator ( parentScope, kind ) {
+		this.initialiseScope( parentScope );
+		this.init && this.init.initialise( this.scope );
+		this.id.initialiseAndDeclare( this.scope, kind, this.init );
 	}
 
+	// TODO Deleting this does not break any tests. Find meaningful test or delete.
 	render ( code, es ) {
 		extractNames( this.id ).forEach( name => {
-			const declaration = this.proxies.get( name );
+			const variable = this.scope.findVariable( name );
 
-			if ( !es && declaration.exportName && declaration.isReassigned ) {
+			if ( !es && variable.exportName && variable.isReassigned ) {
 				if ( this.init ) {
-					code.overwrite( this.start, this.id.end, declaration.getName( es ) );
+					code.overwrite( this.start, this.id.end, variable.getName( es ) );
 				} else if ( this.module.bundle.treeshake ) {
 					code.remove( this.start, this.end );
 				}
@@ -7528,15 +7724,19 @@ function getSeparator ( code, start ) {
 const forStatement = /^For(?:Of|In)?Statement/;
 
 class VariableDeclaration extends Node$1 {
-	assignExpression () {
-		this.eachChild( child => child.assignExpression( UNKNOWN_ASSIGNMENT ) );
+	bindAssignment () {
+		this.eachChild( child => child.bindAssignment( UNKNOWN_ASSIGNMENT ) );
 	}
 
-	includeDeclaration () {
+	hasEffectsWhenAssigned () {
+		return false;
+	}
+
+	includeWithAllDeclarations () {
 		if ( this.isFullyIncluded() ) { return false; }
 		let addedNewNodes = false;
 		this.declarations.forEach( declarator => {
-			if ( declarator.includeDeclaration() ) {
+			if ( declarator.includeInBundle() ) {
 				addedNewNodes = true;
 			}
 		} );
@@ -7564,6 +7764,10 @@ class VariableDeclaration extends Node$1 {
 		return false;
 	}
 
+	initialiseChildren () {
+		this.declarations.forEach( child => child.initialiseDeclarator( this.scope, this.kind ) );
+	}
+
 	render ( code, es ) {
 		const treeshake = this.module.bundle.treeshake;
 
@@ -7584,8 +7788,8 @@ class VariableDeclaration extends Node$1 {
 			const prefix = empty ? '' : separator; // TODO indentation
 
 			if ( declarator.id.type === 'Identifier' ) {
-				const proxy = declarator.proxies.get( declarator.id.name );
-				const isExportedAndReassigned = !es && proxy.exportName && proxy.isReassigned;
+				const variable = this.scope.findVariable( declarator.id.name );
+				const isExportedAndReassigned = !es && variable.exportName && variable.isReassigned;
 
 				if ( isExportedAndReassigned ) {
 					if ( declarator.init ) {
@@ -7593,7 +7797,7 @@ class VariableDeclaration extends Node$1 {
 						c = declarator.end;
 						empty = false;
 					}
-				} else if ( !treeshake || proxy.included ) {
+				} else if ( !treeshake || variable.included ) {
 					if ( shouldSeparate ) { code.overwrite( c, declarator.start, `${prefix}${this.kind} ` ); } // TODO indentation
 					c = declarator.end;
 					empty = false;
@@ -7603,8 +7807,8 @@ class VariableDeclaration extends Node$1 {
 				let isIncluded = false;
 
 				extractNames( declarator.id ).forEach( name => {
-					const proxy = declarator.proxies.get( name );
-					const isExportedAndReassigned = !es && proxy.exportName && proxy.isReassigned;
+					const variable = this.scope.findVariable( name );
+					const isExportedAndReassigned = !es && variable.exportName && variable.isReassigned;
 
 					if ( isExportedAndReassigned ) {
 						// code.overwrite( c, declarator.start, prefix );
@@ -7651,11 +7855,22 @@ class WhileStatement extends Statement {
 		return (
 			this.included
 			|| this.test.hasEffects( options )
-			|| this.body.hasEffects( Object.assign( {}, options, { inNestedBreakableStatement: true } ) )
+			|| this.body.hasEffects( options.setIgnoreBreakStatements() )
 		);
 	}
 }
 
+class YieldExpression extends Node$1 {
+	hasEffects ( options ) {
+		return super.hasEffects( options )
+			|| !options.ignoreReturnAwaitYield();
+	}
+
+	hasEffectsAsExpressionStatement ( options ) {
+		return this.hasEffects( options );
+	}
+}
+
 var nodes = {
 	ArrayExpression: Node$1,
 	ArrayPattern,
@@ -7668,6 +7883,7 @@ var nodes = {
 	BreakStatement,
 	CallExpression,
 	CatchClause,
+	ClassBody,
 	ClassDeclaration,
 	ClassExpression,
 	ConditionalExpression,
@@ -7685,9 +7901,11 @@ var nodes = {
 	Identifier,
 	IfStatement,
 	ImportDeclaration,
+	LabeledStatement,
 	Literal,
 	LogicalExpression,
 	MemberExpression,
+	MethodDefinition,
 	NewExpression,
 	ObjectExpression,
 	ObjectPattern,
@@ -7706,7 +7924,8 @@ var nodes = {
 	UpdateExpression,
 	VariableDeclarator,
 	VariableDeclaration,
-	WhileStatement
+	WhileStatement,
+	YieldExpression
 };
 
 class UnknownNode extends Node$1 {
@@ -7800,14 +8019,13 @@ function clone ( node ) {
 
 class ModuleScope extends Scope {
 	constructor ( module ) {
-		super({
-			isBlockScope: false,
-			isLexicalBoundary: true,
+		super( {
 			isModuleScope: true,
 			parent: module.bundle.scope
-		});
+		} );
 
 		this.module = module;
+		this.variables.this = new LocalVariable( 'this', null, UNDEFINED_ASSIGNMENT );
 	}
 
 	deshadow ( names ) {
@@ -7819,21 +8037,21 @@ class ModuleScope extends Scope {
 			const addDeclaration = declaration => {
 				if ( declaration.isNamespace && !declaration.isExternal ) {
 					declaration.module.getExports().forEach( name => {
-						addDeclaration( declaration.module.traceExport(name) );
-					});
+						addDeclaration( declaration.module.traceExport( name ) );
+					} );
 				}
 
 				names.add( declaration.name );
 			};
 
 			specifier.module.getExports().forEach( name => {
-				addDeclaration( specifier.module.traceExport(name) );
-			});
+				addDeclaration( specifier.module.traceExport( name ) );
+			} );
 
 			if ( specifier.name !== '*' ) {
 				const declaration = specifier.module.traceExport( specifier.name );
 				if ( !declaration ) {
-					this.module.warn({
+					this.module.warn( {
 						code: 'NON_EXISTENT_EXPORT',
 						name: specifier.name,
 						source: specifier.module.id,
@@ -7851,22 +8069,22 @@ class ModuleScope extends Scope {
 					names.add( specifier.specifier.imported.name );
 				}
 			}
-		});
+		} );
 
 		super.deshadow( names );
 	}
 
-	findDeclaration ( name ) {
-		if ( this.declarations[ name ] ) {
-			return this.declarations[ name ];
-		}
-
-		return this.module.trace( name ) || this.parent.findDeclaration( name );
-	}
-
 	findLexicalBoundary () {
 		return this;
 	}
+
+	findVariable ( name ) {
+		if ( this.variables[ name ] ) {
+			return this.variables[ name ];
+		}
+
+		return this.module.trace( name ) || this.parent.findVariable( name );
+	}
 }
 
 function tryParse ( module, acornOptions ) {
@@ -7885,6 +8103,11 @@ function tryParse ( module, acornOptions ) {
 	}
 }
 
+function includeFully ( node ) {
+	node.includeInBundle();
+	node.eachChild( includeFully );
+}
+
 class Module {
 	constructor ( ref ) {
 	var id = ref.id;
@@ -8019,9 +8242,6 @@ class Module {
 				localName: 'default',
 				identifier
 			};
-
-			// create a synthetic declaration
-			//this.declarations.default = new SyntheticDefaultDeclaration( node, identifier || this.basename() );
 		}
 
 		// export var { foo, bar } = ...
@@ -8188,6 +8408,10 @@ class Module {
 		return keys( reexports );
 	}
 
+	includeAllInBundle () {
+		this.ast.body.forEach( includeFully );
+	}
+
 	includeInBundle () {
 		let addedNewNodes = false;
 		this.ast.body.forEach( node => {
@@ -8202,7 +8426,7 @@ class Module {
 
 	namespace () {
 		if ( !this.declarations[ '*' ] ) {
-			this.declarations[ '*' ] = new SyntheticNamespaceDeclaration( this );
+			this.declarations[ '*' ] = new NamespaceVariable( this );
 		}
 
 		return this.declarations[ '*' ];
@@ -8238,8 +8462,8 @@ class Module {
 
 	trace ( name ) {
 		// TODO this is slightly circular
-		if ( name in this.scope.declarations ) {
-			return this.scope.declarations[ name ];
+		if ( name in this.scope.variables ) {
+			return this.scope.variables[ name ];
 		}
 
 		if ( name in this.imports ) {
@@ -8294,7 +8518,7 @@ class Module {
 			const name = exportDeclaration.localName;
 			const declaration = this.trace( name );
 
-			return declaration || this.bundle.scope.findDeclaration( name );
+			return declaration || this.bundle.scope.findVariable( name );
 		}
 
 		if ( name === 'default' ) { return; }
@@ -8324,11 +8548,54 @@ class Module {
 	}
 }
 
+class ExternalVariable extends Variable {
+	constructor ( module, name ) {
+		super( name );
+		this.module = module;
+		this.safeName = null;
+		this.isExternal = true;
+		this.isNamespace = name === '*';
+	}
+
+	addReference ( reference ) {
+		if ( this.name === 'default' || this.name === '*' ) {
+			this.module.suggestName( reference.name );
+		}
+	}
+
+	getName ( es ) {
+		if ( this.name === '*' ) {
+			return this.module.name;
+		}
+
+		if ( this.name === 'default' ) {
+			return this.module.exportsNamespace || ( !es && this.module.exportsNames ) ?
+				`${this.module.name}__default` :
+				this.module.name;
+		}
+
+		return es ? this.safeName : `${this.module.name}.${this.name}`;
+	}
+
+	includeDeclaration () {
+		if ( this.included ) {
+			return false;
+		}
+		this.included = true;
+		this.module.used = true;
+		return true;
+	}
+
+	setSafeName ( name ) {
+		this.safeName = name;
+	}
+}
+
 class ExternalModule {
 	constructor ( id ) {
 		this.id = id;
 
-		const parts = id.split(/[\\/]/);
+		const parts = id.split( /[\\/]/ );
 		this.name = makeLegal( parts.pop() );
 
 		this.nameSuggestions = blank();
@@ -8355,9 +8622,8 @@ class ExternalModule {
 		if ( name !== 'default' && name !== '*' ) { this.exportsNames = true; }
 		if ( name === '*' ) { this.exportsNamespace = true; }
 
-		return this.declarations[ name ] || (
-			this.declarations[ name ] = new ExternalDeclaration( this, name )
-		);
+		return this.declarations[ name ]
+			|| (this.declarations[ name ] = new ExternalVariable( this, name ));
 	}
 }
 
@@ -9399,9 +9665,9 @@ function callIfFunction ( thing ) {
 	return typeof thing === 'function' ? thing() : thing;
 }
 
-class SyntheticGlobalDeclaration {
+class GlobalVariable extends Variable {
 	constructor ( name ) {
-		this.name = name;
+		super( name );
 		this.isExternal = true;
 		this.isGlobal = true;
 		this.isReassigned = false;
@@ -9409,33 +9675,23 @@ class SyntheticGlobalDeclaration {
 	}
 
 	addReference ( reference ) {
-		reference.declaration = this;
 		if ( reference.isReassignment ) { this.isReassigned = true; }
 	}
 
 	assignExpression () {}
 
-	gatherPossibleValues ( values ) {
-		values.add( UNKNOWN_ASSIGNMENT );
-	}
-
-	getName () {
-		return this.name;
-	}
-
-	includeDeclaration () {
-		this.included = true;
-		return false;
+	hasEffectsWhenCalled () {
+		return !pureFunctions[ this.name ];
 	}
 }
 
 class BundleScope extends Scope {
-	findDeclaration ( name ) {
-		if ( !this.declarations[ name ] ) {
-			this.declarations[ name ] = new SyntheticGlobalDeclaration( name );
+	findVariable ( name ) {
+		if ( !this.variables[ name ] ) {
+			this.variables[ name ] = new GlobalVariable( name );
 		}
 
-		return this.declarations[ name ];
+		return this.variables[ name ];
 	}
 }
 
@@ -9491,7 +9747,7 @@ class Bundle$$1 {
 		this.scope = new BundleScope();
 		// TODO strictly speaking, this only applies with non-ES6, non-default-only bundles
 		[ 'module', 'exports', '_interopDefault' ].forEach( name => {
-			this.scope.findDeclaration( name ); // creates global declaration as side-effect
+			this.scope.findVariable( name ); // creates global variable as side-effect
 		} );
 
 		this.moduleById = new Map();
@@ -9553,7 +9809,7 @@ class Bundle$$1 {
 			.then( entryModule => {
 				this.entryModule = entryModule;
 
-				// Phase 2 – binding. We link references to their declarations
+				// Phase 2 – binding. We link references to their variables
 				// to generate a complete picture of the bundle
 
 				timeStart( 'phase 2' );
@@ -9563,31 +9819,30 @@ class Bundle$$1 {
 
 				timeEnd( 'phase 2' );
 
-				// Phase 3 – marking. We 'run' each statement to see which ones
-				// need to be included in the generated bundle
+				// Phase 3 – marking. We include all statements that should be included
 
 				timeStart( 'phase 3' );
 
 				// mark all export statements
 				entryModule.getExports().forEach( name => {
-					const declaration = entryModule.traceExport( name );
+					const variable = entryModule.traceExport( name );
 
-					declaration.exportName = name;
-					declaration.includeDeclaration();
+					variable.exportName = name;
+					variable.includeVariable();
 
-					if ( declaration.isNamespace ) {
-						declaration.needsNamespaceBlock = true;
+					if ( variable.isNamespace ) {
+						variable.needsNamespaceBlock = true;
 					}
 				} );
 
 				entryModule.getReexports().forEach( name => {
-					const declaration = entryModule.traceExport( name );
+					const variable = entryModule.traceExport( name );
 
-					if ( declaration.isExternal ) {
-						declaration.reexported = declaration.module.reexported = true;
+					if ( variable.isExternal ) {
+						variable.reexported = variable.module.reexported = true;
 					} else {
-						declaration.exportName = name;
-						declaration.includeDeclaration();
+						variable.exportName = name;
+						variable.includeVariable();
 					}
 				} );
 
@@ -9602,6 +9857,9 @@ class Bundle$$1 {
 							}
 						} );
 					} while ( addedNewNodes );
+				} else {
+					// Necessary to properly replace namespace imports
+					this.modules.forEach( module => module.includeAllInBundle() );
 				}
 
 				timeEnd( 'phase 3' );
@@ -9648,7 +9906,7 @@ class Bundle$$1 {
 		const used = blank();
 
 		// ensure no conflicts with globals
-		keys( this.scope.declarations ).forEach( name => used[ name ] = 1 );
+		keys( this.scope.variables ).forEach( name => used[ name ] = 1 );
 
 		function getSafeName ( name ) {
 			while ( used[ name ] ) {
@@ -9676,12 +9934,12 @@ class Bundle$$1 {
 		} );
 
 		this.modules.forEach( module => {
-			forOwn( module.scope.declarations, ( declaration ) => {
-				if ( declaration.isDefault && declaration.declaration.id ) {
+			forOwn( module.scope.variables, variable => {
+				if ( variable.isDefault && variable.declaration.id ) {
 					return;
 				}
 
-				declaration.name = getSafeName( declaration.name );
+				variable.name = getSafeName( variable.name );
 			} );
 
 			// deconflict reified namespaces
@@ -9834,12 +10092,12 @@ class Bundle$$1 {
 							// need to find the actual import declaration, so we can provide
 							// a useful error message. Bit hoop-jumpy but what can you do
 							const declaration = module.ast.body.find( node => {
-								return node.isImportDeclaration && node.source.value === source;
+								return ( node.isImportDeclaration || node.isExportDeclaration ) && node.source.value === source;
 							} );
-
+							const declarationType = /Export/.test( declaration.type ) ? 'export' : 'import';
 							module.error( {
 								code: 'CANNOT_IMPORT_SELF',
-								message: `A module cannot import itself`
+								message: `A module cannot ${declarationType} itself`
 							}, declaration.start );
 						}
 
@@ -10320,7 +10578,7 @@ function createCommonjsModule(fn, module) {
  * Licensed under the MIT license.
  */
 
-var index$2 = function filenameRegex() {
+var filenameRegex = function filenameRegex() {
   return /([^\\\/]+)$/;
 };
 
@@ -10331,7 +10589,7 @@ var index$2 = function filenameRegex() {
  * Released under the MIT License.
  */
 
-var index$6 = function (arr) {
+var arrFlatten = function (arr) {
   return flat(arr, []);
 };
 
@@ -10377,7 +10635,7 @@ function diff(arr, arrays) {
   }
 
   if (argsLen > 2) {
-    arrays = index$6(slice.call(arguments, 1));
+    arrays = arrFlatten(slice.call(arguments, 1));
   }
 
   while (++i < len) {
@@ -10392,7 +10650,7 @@ function diff(arr, arrays) {
  * Expose `diff`
  */
 
-var index$4 = diff;
+var arrDiff = diff;
 
 /*!
  * array-unique <https://github.com/jonschlinkert/array-unique>
@@ -10401,7 +10659,7 @@ var index$4 = diff;
  * Licensed under the MIT License.
  */
 
-var index$8 = function unique(arr) {
+var arrayUnique = function unique(arr) {
   if (!Array.isArray(arr)) {
     throw new TypeError('array-unique expects an array.');
   }
@@ -10423,12 +10681,12 @@ var index$8 = function unique(arr) {
 
 var toString$1$1 = {}.toString;
 
-var index$18 = Array.isArray || function (arr) {
+var isarray = Array.isArray || function (arr) {
   return toString$1$1.call(arr) == '[object Array]';
 };
 
-var index$16 = function isObject(val) {
-  return val != null && typeof val === 'object' && index$18(val) === false;
+var isobject = function isObject(val) {
+  return val != null && typeof val === 'object' && isarray(val) === false;
 };
 
 /*!
@@ -10440,7 +10698,7 @@ var index$16 = function isObject(val) {
 
 // The _isBuffer check is for Safari 5-7 support, because it's missing
 // Object.prototype.constructor. Remove this eventually
-var index$24 = function (obj) {
+var isBuffer_1 = function (obj) {
   return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
 };
 
@@ -10462,7 +10720,7 @@ var toString$2 = Object.prototype.toString;
  * @return {*} Native javascript type
  */
 
-var index$22 = function kindOf(val) {
+var kindOf = function kindOf(val) {
   // primitivies
   if (typeof val === 'undefined') {
     return 'undefined';
@@ -10515,7 +10773,7 @@ var index$22 = function kindOf(val) {
   }
 
   // buffer
-  if (index$24(val)) {
+  if (isBuffer_1(val)) {
     return 'buffer';
   }
 
@@ -10569,8 +10827,8 @@ var index$22 = function kindOf(val) {
   return 'object';
 };
 
-var index$20 = function isNumber(num) {
-  var type = index$22(num);
+var isNumber = function isNumber(num) {
+  var type = kindOf(num);
   if (type !== 'number' && type !== 'string') {
     return false;
   }
@@ -10587,7 +10845,7 @@ var toString$3 = Object.prototype.toString;
  * @return {*} Native javascript type
  */
 
-var index$30 = function kindOf(val) {
+var kindOf$2 = function kindOf(val) {
   // primitivies
   if (typeof val === 'undefined') {
     return 'undefined';
@@ -10640,7 +10898,7 @@ var index$30 = function kindOf(val) {
   }
 
   // buffer
-  if (index$24(val)) {
+  if (isBuffer_1(val)) {
     return 'buffer';
   }
 
@@ -10694,8 +10952,8 @@ var index$30 = function kindOf(val) {
   return 'object';
 };
 
-var index$28 = function isNumber(num) {
-  var type = index$30(num);
+var isNumber$2 = function isNumber(num) {
+  var type = kindOf$2(num);
 
   if (type === 'string') {
     if (!num.trim()) return false;
@@ -10715,7 +10973,7 @@ var toString$4 = Object.prototype.toString;
  * @return {*} Native javascript type
  */
 
-var index$32 = function kindOf(val) {
+var kindOf$4 = function kindOf(val) {
   // primitivies
   if (typeof val === 'undefined') {
     return 'undefined';
@@ -10771,7 +11029,7 @@ var index$32 = function kindOf(val) {
   }
 
   // buffer
-  if (index$24(val)) {
+  if (isBuffer_1(val)) {
     return 'buffer';
   }
 
@@ -10829,7 +11087,7 @@ var index$32 = function kindOf(val) {
  * Expose `randomatic`
  */
 
-var index$26 = randomatic;
+var randomatic_1 = randomatic;
 
 /**
  * Available mask characters
@@ -10865,12 +11123,12 @@ function randomatic(pattern, length, options) {
     if (typeof pattern === 'string') {
       length = pattern.length;
 
-    } else if (index$28(pattern)) {
+    } else if (isNumber$2(pattern)) {
       options = {}; length = pattern; pattern = '*';
     }
   }
 
-  if (index$32(length) === 'object' && length.hasOwnProperty('chars')) {
+  if (kindOf$4(length) === 'object' && length.hasOwnProperty('chars')) {
     options = length;
     pattern = options.chars;
     length = pattern.length;
@@ -10914,7 +11172,7 @@ var cache;
  * Expose `repeat`
  */
 
-var index$34 = repeat;
+var repeatString = repeat;
 
 /**
  * Repeat the given `string` the specified `number`
@@ -10972,7 +11230,7 @@ function repeat(str, num) {
  * Licensed under the MIT license.
  */
 
-var index$36 = function repeat(ele, num) {
+var repeatElement = function repeat(ele, num) {
   var arr = new Array(num);
 
   for (var i = 0; i < num; i++) {
@@ -10986,7 +11244,7 @@ var index$36 = function repeat(ele, num) {
  * Expose `fillRange`
  */
 
-var index$14 = fillRange;
+var fillRange_1 = fillRange;
 
 /**
  * Return a range of numbers or letters.
@@ -11011,7 +11269,7 @@ function fillRange(a, b, step, options, fn) {
     fn = options; options = {};
   }
 
-  if (index$16(step)) {
+  if (isobject(step)) {
     options = step; step = '';
   }
 
@@ -11046,11 +11304,11 @@ function fillRange(a, b, step, options, fn) {
 
       // repeat string
       if (m === '+') {
-        return index$36(a, b);
+        return repeatElement(a, b);
 
       // randomize a, `b` times
       } else if (m === '?') {
-        return [index$26(a, b)];
+        return [randomatic_1(a, b)];
 
       // expand right, no regex reduction
       } else if (m === '>') {
@@ -11073,7 +11331,7 @@ function fillRange(a, b, step, options, fn) {
         regex = true;
         sep$$1 = m;
       }
-    } else if (!index$20(step)) {
+    } else if (!isNumber(step)) {
       if (!opts.silent) {
         throw new TypeError('fill-range: invalid step.');
       }
@@ -11098,8 +11356,8 @@ function fillRange(a, b, step, options, fn) {
   }
 
   // validate arguments
-  var isNumA = index$20(zeros(a));
-  var isNumB = index$20(zeros(b));
+  var isNumA = isNumber(zeros(a));
+  var isNumB = isNumber(zeros(b));
 
   if ((!isNumA && isNumB) || (isNumA && !isNumB)) {
     if (!opts.silent) {
@@ -11362,7 +11620,7 @@ function isPadded(origA, origB) {
       : blen;
 
     return function (a) {
-      return index$34('0', len - length(a));
+      return repeatString('0', len - length(a));
     };
   }
   return false;
@@ -11376,7 +11634,7 @@ function length(val) {
   return val.toString().length;
 }
 
-var index$12 = function expandRange(str, options, fn) {
+var expandRange = function expandRange(str, options, fn) {
   if (typeof str !== 'string') {
     throw new TypeError('expand-range expects a string.');
   }
@@ -11406,7 +11664,7 @@ var index$12 = function expandRange(str, options, fn) {
   }
 
   args.push(opts);
-  return index$14.apply(null, args.concat(fn));
+  return fillRange_1.apply(null, args.concat(fn));
 };
 
 /*!
@@ -11462,7 +11720,7 @@ function randomize$1() {
 
 var cache$1 = {};
 
-var index$38 = {
+var preserve = {
 	before: before,
 	after: after
 };
@@ -11479,7 +11737,7 @@ var index$38 = {
  * Expose `braces`
  */
 
-var index$10 = function(str, options) {
+var braces_1 = function(str, options) {
   if (typeof str !== 'string') {
     throw new Error('braces expects a string');
   }
@@ -11549,7 +11807,7 @@ function braces(str, arr, options) {
         return arr.concat(str);
       } else {
         es6 = true;
-        str = index$38.before(str, es6Regex());
+        str = preserve.before(str, es6Regex());
       }
   }
 
@@ -11569,7 +11827,7 @@ function braces(str, arr, options) {
   var segs, segsLength;
 
   if (inner.indexOf('..') !== -1) {
-    segs = index$12(inner, opts, fn) || inner.split(',');
+    segs = expandRange(inner, opts, fn) || inner.split(',');
     segsLength = segs.length;
 
   } else if (inner[0] === '"' || inner[0] === '\'') {
@@ -11607,7 +11865,7 @@ function braces(str, arr, options) {
       arr = braces(val, arr, opts);
     } else if (val !== '') {
       if (opts.nodupes && arr.indexOf(val) !== -1) { continue; }
-      arr.push(es6 ? index$38.after(val) : val);
+      arr.push(es6 ? preserve.after(val) : val);
     }
   }
 
@@ -11657,7 +11915,7 @@ function exponential(str, options, fn) {
 
       } else {
         var num = Math.pow(2, exp);
-        arr.push.apply(arr, index$36(ele, num));
+        arr.push.apply(arr, repeatElement(ele, num));
       }
     }
   }
@@ -11865,7 +12123,7 @@ function filter$1(arr, cb) {
  * Licensed under the MIT License.
  */
 
-var index$42 = function isPosixBracket(str) {
+var isPosixBracket = function isPosixBracket(str) {
   return typeof str === 'string' && /\[([:.=+])(?:[^\[\]]|)+\1\]/.test(str);
 };
 
@@ -11893,10 +12151,10 @@ var POSIX = {
  * Expose `brackets`
  */
 
-var index$40 = brackets;
+var expandBrackets = brackets;
 
 function brackets(str) {
-  if (!index$42(str)) {
+  if (!isPosixBracket(str)) {
     return str;
   }
 
@@ -12029,7 +12287,7 @@ brackets.match = function(arr, pattern) {
  * Licensed under the MIT License.
  */
 
-var index$46 = function isExtglob(str) {
+var isExtglob = function isExtglob(str) {
   return typeof str === 'string'
     && /[@?!+*]\(/.test(str);
 };
@@ -12046,7 +12304,7 @@ var cache$2 = {};
  * Expose `extglob`
  */
 
-var index$44 = extglob;
+var extglob_1 = extglob;
 
 /**
  * Convert the given extglob `string` to a regex-compatible
@@ -12214,15 +12472,15 @@ function toRegex$1(pattern, contains, isNegated) {
 
 
 
-var index$48 = function isGlob(str) {
+var isGlob = function isGlob(str) {
   return typeof str === 'string'
     && (/[*!?{}(|)[\]]/.test(str)
-     || index$46(str));
+     || isExtglob(str));
 };
 
 var isWin = process.platform === 'win32';
 
-var index$52 = function (str) {
+var removeTrailingSeparator = function (str) {
 	var i = str.length - 1;
 	if (i < 2) {
 		return str;
@@ -12247,13 +12505,13 @@ function isSeparator(str, i) {
 
 
 
-var index$50 = function normalizePath(str, stripTrailing) {
+var normalizePath = function normalizePath(str, stripTrailing) {
   if (typeof str !== 'string') {
     throw new TypeError('expected a string');
   }
   str = str.replace(/[\\\/]+/g, '/');
   if (stripTrailing !== false) {
-    str = index$52(str);
+    str = removeTrailingSeparator(str);
   }
   return str;
 };
@@ -12265,7 +12523,7 @@ var index$50 = function normalizePath(str, stripTrailing) {
  * Licensed under the MIT License.
  */
 
-var index$56 = function isExtendable(val) {
+var isExtendable = function isExtendable(val) {
   return typeof val !== 'undefined' && val !== null
     && (typeof val === 'object' || typeof val === 'function');
 };
@@ -12277,7 +12535,7 @@ var index$56 = function isExtendable(val) {
  * Released under the MIT License.
  */
 
-var index$60 = function forIn(obj, fn, thisArg) {
+var forIn = function forIn(obj, fn, thisArg) {
   for (var key in obj) {
     if (fn.call(thisArg, obj[key], key, obj) === false) {
       break;
@@ -12287,16 +12545,16 @@ var index$60 = function forIn(obj, fn, thisArg) {
 
 var hasOwn = Object.prototype.hasOwnProperty;
 
-var index$58 = function forOwn(obj, fn, thisArg) {
-  index$60(obj, function(val, key) {
+var forOwn$1 = function forOwn(obj, fn, thisArg) {
+  forIn(obj, function(val, key) {
     if (hasOwn.call(obj, key)) {
       return fn.call(thisArg, obj[key], key, obj);
     }
   });
 };
 
-var index$54 = function omit(obj, keys) {
-  if (!index$56(obj)) return {};
+var object_omit = function omit(obj, keys) {
+  if (!isExtendable(obj)) return {};
 
   keys = [].concat.apply([], [].slice.call(arguments, 1));
   var last = keys[keys.length - 1];
@@ -12311,7 +12569,7 @@ var index$54 = function omit(obj, keys) {
     return obj;
   }
 
-  index$58(obj, function(value, key) {
+  forOwn$1(obj, function(value, key) {
     if (keys.indexOf(key) === -1) {
 
       if (!isFunction) {
@@ -12324,20 +12582,20 @@ var index$54 = function omit(obj, keys) {
   return res;
 };
 
-var index$66 = function globParent(str) {
+var globParent = function globParent(str) {
 	str += 'a'; // preserves full path in case of trailing path separator
-	do {str = path.dirname(str);} while (index$48(str));
+	do {str = path.dirname(str);} while (isGlob(str));
 	return str;
 };
 
-var index$64 = function globBase(pattern) {
+var globBase = function globBase(pattern) {
   if (typeof pattern !== 'string') {
     throw new TypeError('glob-base expects a string.');
   }
 
   var res = {};
-  res.base = index$66(pattern);
-  res.isGlob = index$48(pattern);
+  res.base = globParent(pattern);
+  res.isGlob = isGlob(pattern);
 
   if (res.base !== '.') {
     res.glob = pattern.substr(res.base.length);
@@ -12376,7 +12634,7 @@ function dirname$1(glob) {
  * Released under the MIT License.
  */
 
-var index$68 = function(str) {
+var isDotfile = function(str) {
   if (str.charCodeAt(0) === 46 /* . */ && str.indexOf('/', 1) === -1) {
     return true;
   }
@@ -12384,7 +12642,7 @@ var index$68 = function(str) {
   return slash !== -1 ? str.charCodeAt(slash + 1) === 46  /* . */ : false;
 };
 
-var index$62 = createCommonjsModule(function (module) {
+var parseGlob = createCommonjsModule(function (module) {
 /*!
  * parse-glob <https://github.com/jonschlinkert/parse-glob>
  *
@@ -12429,7 +12687,7 @@ module.exports = function parseGlob(glob) {
   // unescape dots and slashes in braces/brackets
   glob = escape(glob);
 
-  var parsed = index$64(glob);
+  var parsed = globBase(glob);
   tok.is.glob = parsed.isGlob;
 
   tok.glob = parsed.glob;
@@ -12445,7 +12703,7 @@ module.exports = function parseGlob(glob) {
   tok.path.extname = basename$$1.slice(1).join('.') || '';
   tok.path.ext = '';
 
-  if (index$48(tok.path.dirname) && !tok.path.basename) {
+  if (isGlob(tok.path.dirname) && !tok.path.basename) {
     if (!/\/$/.test(tok.glob)) {
       tok.path.basename = tok.glob;
     }
@@ -12478,11 +12736,11 @@ module.exports = function parseGlob(glob) {
   // Booleans
   var is = (glob && tok.is.glob);
   tok.is.negated  = glob && glob.charAt(0) === '!';
-  tok.is.extglob  = glob && index$46(glob);
+  tok.is.extglob  = glob && isExtglob(glob);
   tok.is.braces   = has(is, glob, '{');
   tok.is.brackets = has(is, glob, '[:');
   tok.is.globstar = has(is, glob, '**');
-  tok.is.dotfile  = index$68(tok.path.basename) || index$68(tok.path.filename);
+  tok.is.dotfile  = isDotfile(tok.path.basename) || isDotfile(tok.path.filename);
   tok.is.dotdir   = dotdir(tok.path.dirname);
   return (cache[glob] = tok);
 };
@@ -12551,18 +12809,18 @@ function unescape(str) {
  */
 
 // see http://jsperf.com/testing-value-is-primitive/7
-var index$72 = function isPrimitive(value) {
+var isPrimitive = function isPrimitive(value) {
   return value == null || (typeof value !== 'function' && typeof value !== 'object');
 };
 
-var index$74 = function isEqual(a, b) {
+var isEqualShallow = function isEqual(a, b) {
   if (!a && !b) { return true; }
   if (!a && b || a && !b) { return false; }
 
   var numKeysA = 0, numKeysB = 0, key;
   for (key in b) {
     numKeysB++;
-    if (!index$72(b[key]) || !a.hasOwnProperty(key) || (a[key] !== b[key])) {
+    if (!isPrimitive(b[key]) || !a.hasOwnProperty(key) || (a[key] !== b[key])) {
       return false;
     }
   }
@@ -12579,7 +12837,7 @@ var cache$3 = {};
  * Expose `regexCache`
  */
 
-var index$70 = regexCache;
+var regexCache_1 = regexCache;
 
 /**
  * Memoize the results of a call to the new RegExp constructor.
@@ -12612,7 +12870,7 @@ function regexCache(fn, str, opts) {
   }
 
   cached = cache$3[key];
-  if (cached && index$74(cached.opts, opts)) {
+  if (cached && isEqualShallow(cached.opts, opts)) {
     return cached.regex;
   }
 
@@ -12631,8 +12889,8 @@ function memo(key, opts, regex) {
 var cache_1 = cache$3;
 var basic_1 = basic;
 
-index$70.cache = cache_1;
-index$70.basic = basic_1;
+regexCache_1.cache = cache_1;
+regexCache_1.basic = basic_1;
 
 var utils_1 = createCommonjsModule(function (module) {
 'use strict';
@@ -12646,18 +12904,18 @@ var utils = module.exports;
  * Module dependencies
  */
 
-utils.diff = index$4;
-utils.unique = index$8;
-utils.braces = index$10;
-utils.brackets = index$40;
-utils.extglob = index$44;
-utils.isExtglob = index$46;
-utils.isGlob = index$48;
-utils.typeOf = index$22;
-utils.normalize = index$50;
-utils.omit = index$54;
-utils.parseGlob = index$62;
-utils.cache = index$70;
+utils.diff = arrDiff;
+utils.unique = arrayUnique;
+utils.braces = braces_1;
+utils.brackets = expandBrackets;
+utils.extglob = extglob_1;
+utils.isExtglob = isExtglob;
+utils.isGlob = isGlob;
+utils.typeOf = kindOf;
+utils.normalize = normalizePath;
+utils.omit = object_omit;
+utils.parseGlob = parseGlob;
+utils.cache = regexCache_1;
 
 /**
  * Get the filename of a filepath
@@ -12667,7 +12925,7 @@ utils.cache = index$70;
  */
 
 utils.filename = function filename(fp) {
-  var seg = fp.match(index$2());
+  var seg = fp.match(filenameRegex());
   return seg && seg[0];
 };
 
@@ -13761,7 +14019,7 @@ micromatch.matchKeys = matchKeys;
  * Expose `micromatch`
  */
 
-var index$1 = micromatch;
+var micromatch_1 = micromatch;
 
 function ensureArray$1 ( thing ) {
 	if ( Array.isArray( thing ) ) return thing;
@@ -13770,7 +14028,7 @@ function ensureArray$1 ( thing ) {
 }
 
 function createFilter ( include, exclude ) {
-	const getMatcher = id => ( isRegexp( id ) ? id : { test: index$1.matcher( resolve( id ) ) } );
+	const getMatcher = id => ( isRegexp( id ) ? id : { test: micromatch_1.matcher( resolve( id ) ) } );
 	include = ensureArray$1( include ).map( getMatcher );
 	exclude = ensureArray$1( exclude ).map( getMatcher );
 
@@ -13824,12 +14082,12 @@ requireRelative.resolve = function(requested, relativeTo) {
   return module$1._resolveFilename(requested, root);
 };
 
-var index$76 = requireRelative;
+var requireRelative_1$1 = requireRelative;
 
 let chokidar;
 
 try {
-	chokidar = index$76( 'chokidar', process.cwd() );
+	chokidar = requireRelative_1$1( 'chokidar', process.cwd() );
 } catch (err) {
 	chokidar = null;
 }
@@ -14165,7 +14423,7 @@ function watch$1(configs) {
 	return new Watcher(configs);
 }
 
-var version$1 = "0.49.3";
+var version$1 = "0.50.0";
 
 export { rollup, watch$1 as watch, version$1 as VERSION };
 //# sourceMappingURL=rollup.es.js.map