rollup 2.7.2 → 2.7.6

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.7.2
-	Wed, 22 Apr 2020 19:00:15 GMT - commit 97e6fa89d2ad14603094af77bad461a1aa81df3b
+	Rollup.js v2.7.6
+	Thu, 30 Apr 2020 18:55:10 GMT - commit 468010ba801b1e59573b6aa7319461a449aa43df
 
 
 	https://github.com/rollup/rollup

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.7.2
-	Wed, 22 Apr 2020 19:00:15 GMT - commit 97e6fa89d2ad14603094af77bad461a1aa81df3b
+	Rollup.js v2.7.6
+	Thu, 30 Apr 2020 18:55:10 GMT - commit 468010ba801b1e59573b6aa7319461a449aa43df
 
 
 	https://github.com/rollup/rollup
@@ -13,7 +13,7 @@ import { createHash as createHash$1 } from 'crypto';
 import { writeFile as writeFile$1, readdirSync, mkdirSync, readFile as readFile$1, lstatSync, realpathSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version = "2.7.2";
+var version = "2.7.6";
 
 // Reserved word lists for various dialects of the language
 
@@ -5041,13 +5041,28 @@ function getCjsExportFromNamespace (n) {
 	return n && n['default'] || n;
 }
 
-var acorn$1 = getCjsExportFromNamespace(acorn);
+var require$$0 = getCjsExportFromNamespace(acorn);
 
-if (acorn$1.version.indexOf("6.") != 0 && acorn$1.version.indexOf("6.0.") == 0 && acorn$1.version.indexOf("7.") != 0) {
-  throw new Error(`acorn-private-class-elements requires acorn@^6.1.0 or acorn@7.0.0, not ${acorn$1.version}`)
-}
-const tt = acorn$1.tokTypes;
-const TokenType$1 = acorn$1.TokenType;
+const getPrototype = Object.getPrototypeOf || (o => o.__proto__);
+
+const getAcorn = Parser => {
+  if (Parser.acorn) return Parser.acorn
+
+  const acorn = require$$0;
+
+  if (acorn.version.indexOf("6.") != 0 && acorn.version.indexOf("6.0.") == 0 && acorn.version.indexOf("7.") != 0) {
+    throw new Error(`acorn-private-class-elements requires acorn@^6.1.0 or acorn@7.0.0, not ${acorn.version}`)
+  }
+
+  // Make sure `Parser` comes from the same acorn as we `require`d,
+  // otherwise the comparisons fail.
+  for (let cur = Parser; cur && cur !== acorn.Parser; cur = getPrototype(cur)) {
+    if (cur !== acorn.Parser) {
+      throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
+    }
+  }
+  return acorn
+};
 
 var acornPrivateClassElements = function(Parser) {
   // Only load this plugin once.
@@ -5055,15 +5070,7 @@ var acornPrivateClassElements = function(Parser) {
     return Parser
   }
 
-  // Make sure `Parser` comes from the same acorn as our `tt`,
-  // otherwise the comparisons fail.
-  let cur = Parser;
-  while (cur && cur !== acorn$1.Parser) {
-    cur = cur.__proto__;
-  }
-  if (cur !== acorn$1.Parser) {
-    throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
-  }
+  const acorn = getAcorn(Parser);
 
   Parser = class extends Parser {
     _branch() {
@@ -5081,12 +5088,12 @@ var acornPrivateClassElements = function(Parser) {
       element.key = this.parsePrivateName();
       if (element.key.name == "constructor") this.raise(element.key.start, "Classes may not have a private element named constructor");
       const accept = {get: "set", set: "get"}[element.kind];
-      const privateBoundNames = this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1];
+      const privateBoundNames = this._privateBoundNames;
       if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
         this.raise(element.start, "Duplicate private element");
       }
       privateBoundNames[element.key.name] = element.kind || true;
-      delete this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][element.key.name];
+      delete this._unresolvedPrivateNames[element.key.name];
       return element.key
     }
 
@@ -5111,37 +5118,60 @@ var acornPrivateClassElements = function(Parser) {
 
     // Manage stacks and check for undeclared private names
     parseClass(node, isStatement) {
-      this._privateBoundNamesStack = this._privateBoundNamesStack || [];
-      const privateBoundNames = Object.create(this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1] || null);
-      this._privateBoundNamesStack.push(privateBoundNames);
-      this._unresolvedPrivateNamesStack = this._unresolvedPrivateNamesStack || [];
-      const unresolvedPrivateNames = Object.create(null);
-      this._unresolvedPrivateNamesStack.push(unresolvedPrivateNames);
+      const oldOuterPrivateBoundNames = this._outerPrivateBoundNames;
+      this._outerPrivateBoundNames = this._privateBoundNames;
+      this._privateBoundNames = Object.create(this._privateBoundNames || null);
+      const oldOuterUnresolvedPrivateNames = this._outerUnresolvedPrivateNames;
+      this._outerUnresolvedPrivateNames = this._unresolvedPrivateNames;
+      this._unresolvedPrivateNames = Object.create(null);
+
       const _return = super.parseClass(node, isStatement);
-      this._privateBoundNamesStack.pop();
-      this._unresolvedPrivateNamesStack.pop();
-      if (!this._unresolvedPrivateNamesStack.length) {
+
+      const unresolvedPrivateNames = this._unresolvedPrivateNames;
+      this._privateBoundNames = this._outerPrivateBoundNames;
+      this._outerPrivateBoundNames = oldOuterPrivateBoundNames;
+      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
+      this._outerUnresolvedPrivateNames = oldOuterUnresolvedPrivateNames;
+      if (!this._unresolvedPrivateNames) {
         const names = Object.keys(unresolvedPrivateNames);
         if (names.length) {
           names.sort((n1, n2) => unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2]);
           this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name");
         }
-      } else Object.assign(this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1], unresolvedPrivateNames);
+      } else Object.assign(this._unresolvedPrivateNames, unresolvedPrivateNames);
+      return _return
+    }
+
+    // Class heritage is evaluated with outer private environment
+    parseClassSuper(node) {
+      const privateBoundNames = this._privateBoundNames;
+      this._privateBoundNames = this._outerPrivateBoundNames;
+      const unresolvedPrivateNames = this._unresolvedPrivateNames;
+      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
+      const _return = super.parseClassSuper(node);
+      this._privateBoundNames = privateBoundNames;
+      this._unresolvedPrivateNames = unresolvedPrivateNames;
       return _return
     }
 
     // Parse private element access
     parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
-      if (!this.eat(tt.dot)) {
+      if (!this.eat(acorn.tokTypes.dot)) {
         return super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow)
       }
       let node = this.startNodeAt(startPos, startLoc);
       node.object = base;
       node.computed = false;
       if (this.type == this.privateNameToken) {
+        if (base.type == "Super") {
+          this.raise(this.start, "Cannot access private element on super");
+        }
         node.property = this.parsePrivateName();
-        if (!this._privateBoundNamesStack.length || !this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1][node.property.name]) {
-          this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][node.property.name] = node.property.start;
+        if (!this._privateBoundNames || !this._privateBoundNames[node.property.name]) {
+          if (!this._unresolvedPrivateNames) {
+            this.raise(node.property.start, "Usage of undeclared private name");
+          }
+          this._unresolvedPrivateNames[node.property.name] = node.property.start;
         }
       } else {
         node.property = this.parseIdent(true);
@@ -5160,38 +5190,38 @@ var acornPrivateClassElements = function(Parser) {
       return _return
     }
   };
-  Parser.prototype.privateNameToken = new TokenType$1("privateName");
+  Parser.prototype.privateNameToken = new acorn.TokenType("privateName");
   return Parser
 };
 
-const tt$1 = acorn$1.tokTypes;
-
-
-function maybeParseFieldValue(field) {
-  if (this.eat(tt$1.eq)) {
-    const oldInFieldValue = this._inFieldValue;
-    this._inFieldValue = true;
-    field.value = this.parseExpression();
-    this._inFieldValue = oldInFieldValue;
-  } else field.value = null;
-}
-
 var acornClassFields = function(Parser) {
+  const acorn = Parser.acorn || require$$0;
+  const tt = acorn.tokTypes;
+
   Parser = acornPrivateClassElements(Parser);
   return class extends Parser {
+    _maybeParseFieldValue(field) {
+      if (this.eat(tt.eq)) {
+        const oldInFieldValue = this._inFieldValue;
+        this._inFieldValue = true;
+        field.value = this.parseExpression();
+        this._inFieldValue = oldInFieldValue;
+      } else field.value = null;
+    }
+
     // Parse fields
     parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion >= 8 && (this.type == tt$1.name || this.type == this.privateNameToken || this.type == tt$1.bracketL || this.type == tt$1.string)) {
+      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string)) {
         const branch = this._branch();
-        if (branch.type == tt$1.bracketL) {
+        if (branch.type == tt.bracketL) {
           let count = 0;
           do {
-            if (branch.eat(tt$1.bracketL)) ++count;
-            else if (branch.eat(tt$1.bracketR)) --count;
+            if (branch.eat(tt.bracketL)) ++count;
+            else if (branch.eat(tt.bracketR)) --count;
             else branch.next();
           } while (count > 0)
         } else branch.next();
-        if (branch.type == tt$1.eq || branch.canInsertSemicolon() || branch.type == tt$1.semi) {
+        if (branch.type == tt.eq || branch.canInsertSemicolon() || branch.type == tt.semi) {
           const node = this.startNode();
           if (this.type == this.privateNameToken) {
             this.parsePrivateClassElementName(node);
@@ -5202,8 +5232,8 @@ var acornClassFields = function(Parser) {
               (node.key.type === "Literal" && node.key.value === "constructor")) {
             this.raise(node.key.start, "Classes may not have a field called constructor");
           }
-          this.enterScope(67);
-          maybeParseFieldValue.call(this, node);
+          this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
+          this._maybeParseFieldValue(node);
           this.exitScope();
           this.finishNode(node, "FieldDefinition");
           this.semicolon();
@@ -5225,7 +5255,7 @@ var acornClassFields = function(Parser) {
 
 const skipWhiteSpace$1 = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 
-const tt$2 = acorn$1.tokTypes;
+const tt = require$$0.tokTypes;
 
 var acornExportNsFrom = function(Parser) {
   return class extends Parser {
@@ -5237,7 +5267,7 @@ var acornExportNsFrom = function(Parser) {
 
       this.next();
       const specifier = this.startNode();
-      this.expect(tt$2.star);
+      this.expect(tt.star);
       if (this.eatContextual("as")) {
         node.declaration = null;
         specifier.exported = this.parseIdent(true);
@@ -5245,7 +5275,7 @@ var acornExportNsFrom = function(Parser) {
         node.specifiers = [this.finishNode(specifier, "ExportNamespaceSpecifier")];
       }
       this.expectContextual("from");
-      if (this.type !== tt$2.string) this.unexpected();
+      if (this.type !== tt.string) this.unexpected();
       node.source = this.parseExprAtom();
       this.semicolon();
       return this.finishNode(node, node.specifiers ? "ExportNamedDeclaration" : "ExportAllDeclaration")
@@ -5253,7 +5283,7 @@ var acornExportNsFrom = function(Parser) {
   }
 };
 
-const tt$3 = acorn$1.tokTypes;
+const tt$1 = require$$0.tokTypes;
 
 const skipWhiteSpace$2 = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 
@@ -5267,7 +5297,7 @@ const nextTokenIsDot = parser => {
 var acornImportMeta = function(Parser) {
   return class extends Parser {
     parseExprAtom(refDestructuringErrors) {
-      if (this.type !== tt$3._import || !nextTokenIsDot(this)) return super.parseExprAtom(refDestructuringErrors)
+      if (this.type !== tt$1._import || !nextTokenIsDot(this)) return super.parseExprAtom(refDestructuringErrors)
 
       if (!this.options.allowImportExportEverywhere && !this.inModule) {
         this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
@@ -5276,7 +5306,7 @@ var acornImportMeta = function(Parser) {
       let node = this.startNode();
       if (this.containsEsc) this.raiseRecoverable(this.start, "Escape sequence in keyword import");
       node.meta = this.parseIdent(true);
-      this.expect(tt$3.dot);
+      this.expect(tt$1.dot);
       node.property = this.parseIdent(true);
       if (node.property.name !== "meta") {
         this.raiseRecoverable(node.property.start, "The only valid meta property for import is import.meta");
@@ -5288,7 +5318,7 @@ var acornImportMeta = function(Parser) {
     }
 
     parseStatement(context, topLevel, exports) {
-      if (this.type !== tt$3._import || !nextTokenIsDot(this)) {
+      if (this.type !== tt$1._import || !nextTokenIsDot(this)) {
         return super.parseStatement(context, topLevel, exports)
       }
 
@@ -5299,23 +5329,22 @@ var acornImportMeta = function(Parser) {
   }
 };
 
-const tt$4 = acorn$1.tokTypes;
-
-function maybeParseFieldValue$1(field) {
-  if (this.eat(tt$4.eq)) {
-    const oldInFieldValue = this._inStaticFieldValue;
-    this._inStaticFieldValue = true;
-    field.value = this.parseExpression();
-    this._inStaticFieldValue = oldInFieldValue;
-  } else field.value = null;
-}
-
-
-
 var acornStaticClassFeatures = function(Parser) {
   const ExtendedParser = acornPrivateClassElements(Parser);
 
+  const acorn = Parser.acorn || require$$0;
+  const tt = acorn.tokTypes;
+
   return class extends ExtendedParser {
+    _maybeParseFieldValue(field) {
+      if (this.eat(tt.eq)) {
+        const oldInFieldValue = this._inStaticFieldValue;
+        this._inStaticFieldValue = true;
+        field.value = this.parseExpression();
+        this._inStaticFieldValue = oldInFieldValue;
+      } else field.value = null;
+    }
+
     // Parse fields
     parseClassElement(_constructorAllowsSuper) {
       if (this.options.ecmaVersion < 8 || !this.isContextual("static")) {
@@ -5324,18 +5353,18 @@ var acornStaticClassFeatures = function(Parser) {
 
       const branch = this._branch();
       branch.next();
-      if ([tt$4.name, tt$4.bracketL, tt$4.string, this.privateNameToken].indexOf(branch.type) == -1) {
+      if ([tt.name, tt.bracketL, tt.string, this.privateNameToken].indexOf(branch.type) == -1) {
         return super.parseClassElement.apply(this, arguments)
       }
-      if (branch.type == tt$4.bracketL) {
+      if (branch.type == tt.bracketL) {
         let count = 0;
         do {
-          if (branch.eat(tt$4.bracketL)) ++count;
-          else if (branch.eat(tt$4.bracketR)) --count;
+          if (branch.eat(tt.bracketL)) ++count;
+          else if (branch.eat(tt.bracketR)) --count;
           else branch.next();
         } while (count > 0)
       } else branch.next();
-      if (branch.type != tt$4.eq && !branch.canInsertSemicolon() && branch.type != tt$4.semi) {
+      if (branch.type != tt.eq && !branch.canInsertSemicolon() && branch.type != tt.semi) {
         return super.parseClassElement.apply(this, arguments)
       }
 
@@ -5354,7 +5383,7 @@ var acornStaticClassFeatures = function(Parser) {
         this.raise(node.key.start, "Classes may not have a static property named prototype");
       }
 
-      maybeParseFieldValue$1.call(this, node);
+      this._maybeParseFieldValue(node);
       this.finishNode(node, "FieldDefinition");
       this.semicolon();
       return node
@@ -9594,15 +9623,15 @@ class FunctionDeclaration extends FunctionNode {
 
 const WHITESPACE = /\s/;
 // The header ends at the first non-white-space after "default"
-function getDeclarationStart(code, start = 0) {
+function getDeclarationStart(code, start) {
     start = findFirstOccurrenceOutsideComment(code, 'default', start) + 7;
     while (WHITESPACE.test(code[start]))
         start++;
     return start;
 }
-function getIdInsertPosition(code, declarationKeyword, start = 0) {
+function getIdInsertPosition(code, declarationKeyword, endMarker, start) {
     const declarationEnd = findFirstOccurrenceOutsideComment(code, declarationKeyword, start) + declarationKeyword.length;
-    code = code.slice(declarationEnd, findFirstOccurrenceOutsideComment(code, '{', declarationEnd));
+    code = code.slice(declarationEnd, findFirstOccurrenceOutsideComment(code, endMarker, declarationEnd));
     const generatorStarPos = findFirstOccurrenceOutsideComment(code, '*');
     if (generatorStarPos === -1) {
         return declarationEnd;
@@ -9627,19 +9656,14 @@ class ExportDefaultDeclaration extends NodeBase {
         const { start, end } = nodeRenderOptions;
         const declarationStart = getDeclarationStart(code.original, this.start);
         if (this.declaration instanceof FunctionDeclaration) {
-            this.renderNamedDeclaration(code, declarationStart, 'function', this.declaration.id === null, options);
+            this.renderNamedDeclaration(code, declarationStart, 'function', '(', this.declaration.id === null, options);
         }
         else if (this.declaration instanceof ClassDeclaration) {
-            this.renderNamedDeclaration(code, declarationStart, 'class', this.declaration.id === null, options);
+            this.renderNamedDeclaration(code, declarationStart, 'class', '{', this.declaration.id === null, options);
         }
         else if (this.variable.getOriginalVariable() !== this.variable) {
             // Remove altogether to prevent re-declaring the same variable
-            if (options.format === 'system' && this.variable.exportName) {
-                code.overwrite(start, end, `exports('${this.variable.exportName}', ${this.variable.getName()});`);
-            }
-            else {
-                treeshakeNode(this, code, start, end);
-            }
+            treeshakeNode(this, code, start, end);
             return;
         }
         else if (this.variable.included) {
@@ -9658,12 +9682,12 @@ class ExportDefaultDeclaration extends NodeBase {
         }
         this.declaration.render(code, options);
     }
-    renderNamedDeclaration(code, declarationStart, declarationKeyword, needsId, options) {
+    renderNamedDeclaration(code, declarationStart, declarationKeyword, endMarker, needsId, options) {
         const name = this.variable.getName();
         // Remove `export default`
         code.remove(this.start, declarationStart);
         if (needsId) {
-            code.appendLeft(getIdInsertPosition(code.original, declarationKeyword, declarationStart), ` ${name}`);
+            code.appendLeft(getIdInsertPosition(code.original, declarationKeyword, endMarker, declarationStart), ` ${name}`);
         }
         if (options.format === 'system' &&
             this.declaration instanceof ClassDeclaration &&
@@ -9745,24 +9769,6 @@ class ExportDefaultVariable extends LocalVariable {
         }
         return this.originalVariable;
     }
-    setRenderNames(baseName, name) {
-        const original = this.getOriginalVariable();
-        if (original === this) {
-            super.setRenderNames(baseName, name);
-        }
-        else {
-            original.setRenderNames(baseName, name);
-        }
-    }
-    setSafeName(name) {
-        const original = this.getOriginalVariable();
-        if (original === this) {
-            super.setSafeName(name);
-        }
-        else {
-            original.setSafeName(name);
-        }
-    }
 }
 
 const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
@@ -9882,14 +9888,16 @@ class SyntheticNamedExportVariable extends Variable {
         this.module = context.module;
         this.defaultVariable = defaultVariable;
     }
+    getBaseVariable() {
+        return this.defaultVariable instanceof SyntheticNamedExportVariable
+            ? this.defaultVariable.getBaseVariable()
+            : this.defaultVariable;
+    }
     getName() {
         const name = this.name;
         const renderBaseName = this.defaultVariable.getName();
         return `${renderBaseName}${getPropertyAccess(name)}`;
     }
-    getOriginalVariable() {
-        return this.defaultVariable.getOriginalVariable();
-    }
     include() {
         if (!this.included) {
             this.included = true;
@@ -14817,17 +14825,29 @@ class Module {
         if (this.relevantDependencies)
             return this.relevantDependencies;
         const relevantDependencies = new Set();
-        for (const variable of this.imports) {
-            relevantDependencies.add(variable instanceof SyntheticNamedExportVariable
-                ? variable.getOriginalVariable().module
-                : variable.module);
+        for (let variable of this.imports) {
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            else if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            if (variable.module) {
+                relevantDependencies.add(variable.module);
+            }
         }
         if (this.isEntryPoint || this.dynamicallyImportedBy.length > 0 || this.graph.preserveModules) {
             for (const exportName of [...this.getReexports(), ...this.getExports()]) {
-                const variable = this.getVariableForExportName(exportName);
-                relevantDependencies.add(variable instanceof SyntheticNamedExportVariable
-                    ? variable.getOriginalVariable().module
-                    : variable.module);
+                let variable = this.getVariableForExportName(exportName);
+                if (variable instanceof SyntheticNamedExportVariable) {
+                    variable = variable.getBaseVariable();
+                }
+                else if (variable instanceof ExportDefaultVariable) {
+                    variable = variable.getOriginalVariable();
+                }
+                if (variable.module) {
+                    relevantDependencies.add(variable.module);
+                }
             }
         }
         if (this.graph.treeshakingOptions) {
@@ -14873,7 +14893,10 @@ class Module {
         }
         const exportNamesByVariable = new Map();
         for (const exportName of this.getAllExportNames()) {
-            const tracedVariable = this.getVariableForExportName(exportName);
+            let tracedVariable = this.getVariableForExportName(exportName);
+            if (tracedVariable instanceof ExportDefaultVariable) {
+                tracedVariable = tracedVariable.getOriginalVariable();
+            }
             if (!tracedVariable ||
                 !(tracedVariable.included || tracedVariable instanceof ExternalVariable)) {
                 continue;
@@ -16284,12 +16307,11 @@ class Chunk$1 {
         for (const dep of this.dependencies) {
             const imports = [];
             for (const variable of this.imports) {
-                const renderedVariable = variable instanceof ExportDefaultVariable ? variable.getOriginalVariable() : variable;
                 if ((variable.module instanceof Module
                     ? variable.module.chunk === dep
                     : variable.module === dep) &&
-                    !renderedImports.has(renderedVariable)) {
-                    renderedImports.add(renderedVariable);
+                    !renderedImports.has(variable)) {
+                    renderedImports.add(variable);
                     imports.push({
                         imported: variable.module instanceof ExternalModule
                             ? variable.name
@@ -16493,10 +16515,13 @@ class Chunk$1 {
     }
     setUpChunkImportsAndExportsForModule(module) {
         for (let variable of module.imports) {
-            if (variable.module.chunk !== this) {
-                if (variable instanceof SyntheticNamedExportVariable) {
-                    variable = variable.getOriginalVariable();
-                }
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            else if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            if (variable.module && variable.module.chunk !== this) {
                 this.imports.add(variable);
                 if (!(variable instanceof NamespaceVariable && this.graph.preserveModules) &&
                     variable.module instanceof Module) {
@@ -16511,7 +16536,7 @@ class Chunk$1 {
                 this.exports.add(exportedVariable);
                 const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
                 const importedVariable = isSynthetic
-                    ? exportedVariable.getOriginalVariable()
+                    ? exportedVariable.getBaseVariable()
                     : exportedVariable;
                 const exportingModule = importedVariable.module;
                 if (exportingModule &&