rollup 0.66.5 → 0.66.6

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v0.66.5
-	Tue, 09 Oct 2018 05:29:31 GMT - commit e5d9f3e08694d94e363ba6b45315a41890caf76b
+	Rollup.js v0.66.6
+	Wed, 10 Oct 2018 14:49:51 GMT - commit aa68a8cd6d363681ec1df60df63e05f6b53c4277
 
 
 	https://github.com/rollup/rollup
@@ -2688,36 +2688,36 @@ var ExportDefaultVariable = /** @class */ (function (_super) {
     function ExportDefaultVariable(name, exportDefaultDeclaration, deoptimizationTracker) {
         var _this = _super.call(this, name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, deoptimizationTracker) || this;
         // Not initialised during construction
-        _this.original = null;
-        _this.hasId =
-            (exportDefaultDeclaration.declaration.type === FunctionDeclaration ||
-                exportDefaultDeclaration.declaration.type === ClassDeclaration) &&
-                !!exportDefaultDeclaration.declaration.id;
+        _this.originalId = null;
+        var declaration = exportDefaultDeclaration.declaration;
+        if ((declaration.type === FunctionDeclaration ||
+            declaration.type === ClassDeclaration) &&
+            declaration.id) {
+            _this.hasId = true;
+            _this.originalId = declaration.id;
+        }
+        else if (declaration.type === Identifier) {
+            _this.originalId = declaration;
+        }
         return _this;
     }
     ExportDefaultVariable.prototype.addReference = function (identifier) {
         if (!this.hasId) {
             this.name = identifier.name;
-            if (this.original !== null) {
-                this.original.addReference(identifier);
-            }
         }
     };
     ExportDefaultVariable.prototype.getName = function (reset) {
         if (!reset && this.safeName)
             return this.safeName;
-        if (this.original !== null && !this.original.isReassigned)
-            return this.original.getName();
+        if (this.referencesOriginal())
+            return this.originalId.variable.getName();
         return this.name;
     };
     ExportDefaultVariable.prototype.referencesOriginal = function () {
-        return this.original && !this.original.isReassigned;
+        return this.originalId && (this.hasId || !this.originalId.variable.isReassigned);
     };
     ExportDefaultVariable.prototype.getOriginalVariableName = function () {
-        return this.original && this.original.getName();
-    };
-    ExportDefaultVariable.prototype.setOriginalVariable = function (original) {
-        this.original = original;
+        return (this.originalId && this.originalId.name) || null;
     };
     return ExportDefaultVariable;
 }(LocalVariable));
@@ -9622,151 +9622,6 @@ var FunctionDeclaration$1 = /** @class */ (function (_super) {
     return FunctionDeclaration$$1;
 }(FunctionNode));
 
-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 `export { foo as bar }`
-        if (parent.type === 'ExportSpecifier' && node !== parent.local)
-            return false;
-        return true;
-    }
-    return false;
-}
-
-function isIdentifier(node) {
-    return node.type === Identifier;
-}
-var Identifier$1 = /** @class */ (function (_super) {
-    __extends(Identifier$$1, _super);
-    function Identifier$$1() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Identifier$$1.prototype.bind = function () {
-        if (this.bound)
-            return;
-        this.bound = true;
-        if (this.variable === null && isReference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-        }
-        if (this.variable !== null &&
-            this.variable.isLocal &&
-            this.variable.additionalInitializers !== null) {
-            this.variable.consolidateInitializers();
-        }
-    };
-    Identifier$$1.prototype.declare = function (kind, init) {
-        switch (kind) {
-            case 'var':
-            case 'function':
-                this.variable = this.scope.addDeclaration(this, this.context.deoptimizationTracker, init, true);
-                break;
-            case 'let':
-            case 'const':
-            case 'class':
-                this.variable = this.scope.addDeclaration(this, this.context.deoptimizationTracker, init, false);
-                break;
-            case 'parameter':
-                this.variable = this.scope.addParameterDeclaration(this);
-                break;
-            default:
-                throw new Error("Unexpected identifier kind " + kind + ".");
-        }
-    };
-    Identifier$$1.prototype.getLiteralValueAtPath = function (path$$1, recursionTracker, origin) {
-        if (this.variable !== null) {
-            return this.variable.getLiteralValueAtPath(path$$1, recursionTracker, origin);
-        }
-        return UNKNOWN_VALUE;
-    };
-    Identifier$$1.prototype.getReturnExpressionWhenCalledAtPath = function (path$$1, recursionTracker, origin) {
-        if (this.variable !== null) {
-            return this.variable.getReturnExpressionWhenCalledAtPath(path$$1, recursionTracker, origin);
-        }
-        return UNKNOWN_EXPRESSION;
-    };
-    Identifier$$1.prototype.hasEffectsWhenAccessedAtPath = function (path$$1, options) {
-        return this.variable && this.variable.hasEffectsWhenAccessedAtPath(path$$1, options);
-    };
-    Identifier$$1.prototype.hasEffectsWhenAssignedAtPath = function (path$$1, options) {
-        return !this.variable || this.variable.hasEffectsWhenAssignedAtPath(path$$1, options);
-    };
-    Identifier$$1.prototype.hasEffectsWhenCalledAtPath = function (path$$1, callOptions, options) {
-        return !this.variable || this.variable.hasEffectsWhenCalledAtPath(path$$1, callOptions, options);
-    };
-    Identifier$$1.prototype.include = function () {
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null && !this.variable.included) {
-                this.variable.include();
-                this.context.requestTreeshakingPass();
-            }
-        }
-    };
-    Identifier$$1.prototype.initialise = function () {
-        this.included = false;
-        this.bound = false;
-        // To avoid later shape mutations
-        if (!this.variable) {
-            this.variable = null;
-        }
-    };
-    Identifier$$1.prototype.deoptimizePath = function (path$$1) {
-        if (!this.bound)
-            this.bind();
-        if (this.variable !== null) {
-            if (path$$1.length === 0 &&
-                this.name in this.context.imports &&
-                !this.scope.contains(this.name)) {
-                this.disallowImportReassignment();
-            }
-            this.variable.deoptimizePath(path$$1);
-        }
-    };
-    Identifier$$1.prototype.render = function (code, _options, _a) {
-        var _b = _a === void 0 ? BLANK : _a, renderedParentType = _b.renderedParentType, isCalleeOfRenderedParent = _b.isCalleeOfRenderedParent, isShorthandProperty = _b.isShorthandProperty;
-        if (this.variable) {
-            var name = this.variable.getName();
-            if (name !== this.name) {
-                code.overwrite(this.start, this.end, name, {
-                    storeName: true,
-                    contentOnly: true
-                });
-                if (isShorthandProperty) {
-                    code.prependRight(this.start, this.name + ": ");
-                }
-            }
-            // In strict mode, any variable named "eval" must be the actual "eval" function
-            if (name === 'eval' &&
-                renderedParentType === CallExpression &&
-                isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
-            }
-        }
-    };
-    Identifier$$1.prototype.disallowImportReassignment = function () {
-        this.context.error({
-            code: 'ILLEGAL_REASSIGNMENT',
-            message: "Illegal reassignment to import '" + this.name + "'"
-        }, this.start);
-    };
-    return Identifier$$1;
-}(NodeBase));
-
 var WHITESPACE = /\s/;
 // The header ends at the first non-white-space after "default"
 function getDeclarationStart(code, start) {
@@ -9794,16 +9649,6 @@ var ExportDefaultDeclaration$1 = /** @class */ (function (_super) {
     function ExportDefaultDeclaration$$1() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    ExportDefaultDeclaration$$1.prototype.bind = function () {
-        _super.prototype.bind.call(this);
-        if (this.declarationName &&
-            // Do not set it for Class and FunctionExpressions otherwise they get treeshaken away
-            (isFunctionDeclaration(this.declaration) ||
-                isClassDeclaration(this.declaration) ||
-                isIdentifier(this.declaration))) {
-            this.variable.setOriginalVariable(this.scope.findVariable(this.declarationName));
-        }
-    };
     ExportDefaultDeclaration$$1.prototype.initialise = function () {
         this.included = false;
         this.declarationName =
@@ -10225,6 +10070,151 @@ var ImmutableEntityPathTracker = /** @class */ (function () {
 }());
 var EMPTY_IMMUTABLE_TRACKER = new ImmutableEntityPathTracker();
 
+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 `export { foo as bar }`
+        if (parent.type === 'ExportSpecifier' && node !== parent.local)
+            return false;
+        return true;
+    }
+    return false;
+}
+
+function isIdentifier(node) {
+    return node.type === Identifier;
+}
+var Identifier$1 = /** @class */ (function (_super) {
+    __extends(Identifier$$1, _super);
+    function Identifier$$1() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Identifier$$1.prototype.bind = function () {
+        if (this.bound)
+            return;
+        this.bound = true;
+        if (this.variable === null && isReference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+        }
+        if (this.variable !== null &&
+            this.variable.isLocal &&
+            this.variable.additionalInitializers !== null) {
+            this.variable.consolidateInitializers();
+        }
+    };
+    Identifier$$1.prototype.declare = function (kind, init) {
+        switch (kind) {
+            case 'var':
+            case 'function':
+                this.variable = this.scope.addDeclaration(this, this.context.deoptimizationTracker, init, true);
+                break;
+            case 'let':
+            case 'const':
+            case 'class':
+                this.variable = this.scope.addDeclaration(this, this.context.deoptimizationTracker, init, false);
+                break;
+            case 'parameter':
+                this.variable = this.scope.addParameterDeclaration(this);
+                break;
+            default:
+                throw new Error("Unexpected identifier kind " + kind + ".");
+        }
+    };
+    Identifier$$1.prototype.getLiteralValueAtPath = function (path$$1, recursionTracker, origin) {
+        if (this.variable !== null) {
+            return this.variable.getLiteralValueAtPath(path$$1, recursionTracker, origin);
+        }
+        return UNKNOWN_VALUE;
+    };
+    Identifier$$1.prototype.getReturnExpressionWhenCalledAtPath = function (path$$1, recursionTracker, origin) {
+        if (this.variable !== null) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path$$1, recursionTracker, origin);
+        }
+        return UNKNOWN_EXPRESSION;
+    };
+    Identifier$$1.prototype.hasEffectsWhenAccessedAtPath = function (path$$1, options) {
+        return this.variable && this.variable.hasEffectsWhenAccessedAtPath(path$$1, options);
+    };
+    Identifier$$1.prototype.hasEffectsWhenAssignedAtPath = function (path$$1, options) {
+        return !this.variable || this.variable.hasEffectsWhenAssignedAtPath(path$$1, options);
+    };
+    Identifier$$1.prototype.hasEffectsWhenCalledAtPath = function (path$$1, callOptions, options) {
+        return !this.variable || this.variable.hasEffectsWhenCalledAtPath(path$$1, callOptions, options);
+    };
+    Identifier$$1.prototype.include = function () {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null && !this.variable.included) {
+                this.variable.include();
+                this.context.requestTreeshakingPass();
+            }
+        }
+    };
+    Identifier$$1.prototype.initialise = function () {
+        this.included = false;
+        this.bound = false;
+        // To avoid later shape mutations
+        if (!this.variable) {
+            this.variable = null;
+        }
+    };
+    Identifier$$1.prototype.deoptimizePath = function (path$$1) {
+        if (!this.bound)
+            this.bind();
+        if (this.variable !== null) {
+            if (path$$1.length === 0 &&
+                this.name in this.context.imports &&
+                !this.scope.contains(this.name)) {
+                this.disallowImportReassignment();
+            }
+            this.variable.deoptimizePath(path$$1);
+        }
+    };
+    Identifier$$1.prototype.render = function (code, _options, _a) {
+        var _b = _a === void 0 ? BLANK : _a, renderedParentType = _b.renderedParentType, isCalleeOfRenderedParent = _b.isCalleeOfRenderedParent, isShorthandProperty = _b.isShorthandProperty;
+        if (this.variable) {
+            var name = this.variable.getName();
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    storeName: true,
+                    contentOnly: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, this.name + ": ");
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === CallExpression &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    };
+    Identifier$$1.prototype.disallowImportReassignment = function () {
+        this.context.error({
+            code: 'ILLEGAL_REASSIGNMENT',
+            message: "Illegal reassignment to import '" + this.name + "'"
+        }, this.start);
+    };
+    return Identifier$$1;
+}(NodeBase));
+
 var CallExpression$1 = /** @class */ (function (_super) {
     __extends(CallExpression, _super);
     function CallExpression() {
@@ -13186,9 +13176,6 @@ var Module = /** @class */ (function () {
             // export default function foo () {}
             // export default foo;
             // export default 42;
-            var identifier = (node.declaration.id &&
-                node.declaration.id.name) ||
-                node.declaration.name;
             if (this.exports.default) {
                 this.error({
                     code: 'DUPLICATE_EXPORT',
@@ -13197,7 +13184,7 @@ var Module = /** @class */ (function () {
             }
             this.exports.default = {
                 localName: 'default',
-                identifier: identifier,
+                identifier: node.variable.getOriginalVariableName(),
                 node: node
             };
         }
@@ -20627,7 +20614,7 @@ function Uint8ArrayEqual(bufferA, bufferB) {
     return true;
 }
 
-var version$1 = "0.66.5";
+var version$1 = "0.66.6";
 
 function mkdirpath(path$$1) {
     var dir = path.dirname(path$$1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "0.66.5",
+  "version": "0.66.6",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/rollup.es.js",