rollup 2.55.1 → 2.56.3

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.55.1
-	Thu, 29 Jul 2021 15:46:34 GMT - commit 97759be7eacc11c4f7e4fdb9fada077279b363f3
+	Rollup.js v2.56.3
+	Mon, 23 Aug 2021 05:06:39 GMT - commit c41d17ceedfa6c1d7430da70c6c80d86a91e9434
 
 
 	https://github.com/rollup/rollup
@@ -19,7 +19,7 @@ function _interopNamespaceDefaultOnly(e) {
   return {__proto__: null, 'default': e};
 }
 
-var version$1 = "2.55.1";
+var version$1 = "2.56.3";
 
 function ensureArray(items) {
     if (Array.isArray(items)) {
@@ -3166,35 +3166,54 @@ function removeLineBreaks(code, start, end) {
     }
 }
 
-function getSystemExportStatement(exportedVariables, options) {
-    const _ = options.compact ? '' : ' ';
+function getSystemExportStatement(exportedVariables, { compact, exportNamesByVariable }, modifier = '') {
+    const _ = compact ? '' : ' ';
     if (exportedVariables.length === 1 &&
-        options.exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
         const variable = exportedVariables[0];
-        return `exports('${options.exportNamesByVariable.get(variable)}',${_}${variable.getName()})`;
+        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName()}${modifier})`;
     }
     else {
         return `exports({${_}${exportedVariables
             .map(variable => {
-            return options.exportNamesByVariable
+            return exportNamesByVariable
                 .get(variable)
-                .map(exportName => `${exportName}:${_}${variable.getName()}`)
+                .map(exportName => `${exportName}:${_}${variable.getName()}${modifier}`)
                 .join(`,${_}`);
         })
             .join(`,${_}`)}${_}})`;
     }
 }
-function getSystemExportFunctionLeft(exportedVariables, setFromExpression, options) {
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { compact, exportNamesByVariable }) {
+    const _ = compact ? '' : ' ';
+    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
     const _ = options.compact ? '' : ' ';
     const s = options.compact ? '' : ';';
-    return `function${_}(v)${_}{${_}return exports({${_}${exportedVariables
-        .map(variable => {
-        return options.exportNamesByVariable
-            .get(variable)
-            .map(exportName => `${exportName}:${_}${setFromExpression ? variable.getName() : 'v'}`)
-            .join(`,${_}`);
-    })
-        .join(`,${_}`)}${_}}),${_}v${s}${_}}(`;
+    code.prependRight(expressionStart, `function${_}(v)${_}{${_}return ${getSystemExportStatement(exportedVariables, options)},${_}v${s}${_}}(`);
+    code.appendLeft(expressionEnd, ')');
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const _ = options.compact ? '' : ' ';
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName()}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const _ = options.compact ? '' : ' ';
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
 }
 
 const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
@@ -5890,8 +5909,7 @@ class ExportDefaultDeclaration extends NodeBase {
         else {
             code.remove(this.start, declarationStart);
             this.declaration.render(code, options, {
-                isCalleeOfRenderedParent: false,
-                renderedParentType: ExpressionStatement$1
+                renderedSurroundingElement: ExpressionStatement$1
             });
             if (code.original[this.end - 1] !== ';') {
                 code.appendLeft(this.end, ';');
@@ -6130,12 +6148,14 @@ class VariableDeclaration extends NodeBase {
         let isInDeclaration = false;
         let hasRenderedContent = false;
         let separatorString = '', leadingString, nextSeparatorString;
-        const systemPatternExports = [];
+        const aggregatedSystemExports = [];
+        const singleSystemExport = gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports);
         for (const { node, start, separator, contentEnd, end } of separatedNodes) {
             if (!node.included) {
                 code.remove(start, end);
                 continue;
             }
+            node.render(code, options);
             leadingString = '';
             nextSeparatorString = '';
             if (!node.id.included ||
@@ -6147,21 +6167,9 @@ class VariableDeclaration extends NodeBase {
                 isInDeclaration = false;
             }
             else {
-                if (options.format === 'system' && node.init !== null) {
-                    if (node.id.type !== Identifier$1) {
-                        node.id.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
-                    }
-                    else {
-                        const exportNames = options.exportNamesByVariable.get(node.id.variable);
-                        if (exportNames) {
-                            const _ = options.compact ? '' : ' ';
-                            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', node.id.end);
-                            code.prependLeft(findNonWhiteSpace(code.original, operatorPos + 1), exportNames.length === 1
-                                ? `exports('${exportNames[0]}',${_}`
-                                : getSystemExportFunctionLeft([node.id.variable], false, options));
-                            nextSeparatorString += ')';
-                        }
-                    }
+                if (singleSystemExport && singleSystemExport === node.id.variable) {
+                    const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', node.id.end);
+                    renderSystemExportExpression(singleSystemExport, findNonWhiteSpace(code.original, operatorPos + 1), separator === null ? contentEnd : separator, code, options);
                 }
                 if (isInDeclaration) {
                     separatorString += ',';
@@ -6181,16 +6189,40 @@ class VariableDeclaration extends NodeBase {
                 code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
                 code.appendLeft(renderedContentEnd, leadingString);
             }
-            node.render(code, options);
             actualContentEnd = contentEnd;
             renderedContentEnd = end;
             hasRenderedContent = true;
             lastSeparatorPos = separator;
             separatorString = nextSeparatorString;
         }
-        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options, isNoStatement);
+        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, aggregatedSystemExports, options, isNoStatement);
     }
 }
+function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports) {
+    var _a;
+    let singleSystemExport = null;
+    if (options.format === 'system') {
+        for (const { node } of separatedNodes) {
+            if (node.id instanceof Identifier &&
+                node.init &&
+                aggregatedSystemExports.length === 0 &&
+                ((_a = options.exportNamesByVariable.get(node.id.variable)) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                singleSystemExport = node.id.variable;
+                aggregatedSystemExports.push(singleSystemExport);
+            }
+            else {
+                node.id.addExportedVariables(aggregatedSystemExports, options.exportNamesByVariable);
+            }
+        }
+        if (aggregatedSystemExports.length > 1) {
+            singleSystemExport = null;
+        }
+        else if (singleSystemExport) {
+            aggregatedSystemExports.length = 0;
+        }
+    }
+    return singleSystemExport;
+}
 
 const NEW_ARRAY_PROPERTIES = [
     { key: UnknownInteger, kind: 'init', property: UNKNOWN_EXPRESSION },
@@ -6613,6 +6645,47 @@ class ArrowFunctionExpression extends NodeBase {
 }
 ArrowFunctionExpression.prototype.preventChildBlockScope = true;
 
+class ObjectPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const property of this.properties) {
+            if (property.type === Property$1) {
+                property.value.addExportedVariables(variables, exportNamesByVariable);
+            }
+            else {
+                property.argument.addExportedVariables(variables, exportNamesByVariable);
+            }
+        }
+    }
+    declare(kind, init) {
+        const variables = [];
+        for (const property of this.properties) {
+            variables.push(...property.declare(kind, init));
+        }
+        return variables;
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            for (const property of this.properties) {
+                property.deoptimizePath(path);
+            }
+        }
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        if (path.length > 0)
+            return true;
+        for (const property of this.properties) {
+            if (property.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const property of this.properties) {
+            property.markDeclarationReached();
+        }
+    }
+}
+
 class AssignmentExpression extends NodeBase {
     constructor() {
         super(...arguments);
@@ -6643,7 +6716,7 @@ class AssignmentExpression extends NodeBase {
         }
         this.right.include(context, includeChildrenRecursively);
     }
-    render(code, options, { preventASI, renderedParentType } = BLANK) {
+    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
         if (this.left.included) {
             this.left.render(code, options);
             this.right.render(code, options);
@@ -6655,29 +6728,40 @@ class AssignmentExpression extends NodeBase {
                 removeLineBreaks(code, inclusionStart, this.right.start);
             }
             this.right.render(code, options, {
-                renderedParentType: renderedParentType || this.parent.type
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
             });
         }
         if (options.format === 'system') {
-            const exportNames = this.left.variable && options.exportNamesByVariable.get(this.left.variable);
-            if (this.left.type === 'Identifier' && exportNames) {
-                const _ = options.compact ? '' : ' ';
-                const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
-                const operation = this.operator.length > 1 ? `${exportNames[0]}${_}${this.operator.slice(0, -1)}${_}` : '';
-                code.overwrite(operatorPos, findNonWhiteSpace(code.original, operatorPos + this.operator.length), `=${_}${exportNames.length === 1
-                    ? `exports('${exportNames[0]}',${_}`
-                    : getSystemExportFunctionLeft([this.left.variable], false, options)}${operation}`);
-                code.appendLeft(this.right.end, ')');
+            if (this.left instanceof Identifier) {
+                const variable = this.left.variable;
+                const exportNames = options.exportNamesByVariable.get(variable);
+                if (exportNames) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, this.start, this.end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options);
+                    }
+                    return;
+                }
             }
             else {
                 const systemPatternExports = [];
                 this.left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
                 if (systemPatternExports.length > 0) {
-                    code.prependRight(this.start, `(${getSystemExportFunctionLeft(systemPatternExports, true, options)}`);
-                    code.appendLeft(this.end, '))');
+                    renderSystemExportFunction(systemPatternExports, this.start, this.end, renderedSurroundingElement === ExpressionStatement$1, code, options);
+                    return;
                 }
             }
         }
+        if (this.left.included &&
+            this.left instanceof ObjectPattern &&
+            (renderedSurroundingElement === ExpressionStatement$1 ||
+                renderedSurroundingElement === ArrowFunctionExpression$1)) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -6804,10 +6888,8 @@ class BinaryExpression extends NodeBase {
     hasEffectsWhenAccessedAtPath(path) {
         return path.length > 1;
     }
-    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
-        this.left.render(code, options, {
-            renderedSurroundingElement: renderedParentType || renderedSurroundingElement
-        });
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        this.left.render(code, options, { renderedSurroundingElement });
         this.right.render(code, options);
     }
 }
@@ -7052,8 +7134,7 @@ class MemberExpression extends NodeBase {
             if (renderedParentType && isCalleeOfRenderedParent) {
                 code.appendRight(this.start, '0, ');
             }
-            const surroundingElement = renderedParentType || renderedSurroundingElement;
-            this.object.render(code, options, surroundingElement ? { renderedSurroundingElement: surroundingElement } : BLANK);
+            this.object.render(code, options, { renderedSurroundingElement });
             this.property.render(code, options);
         }
     }
@@ -7258,11 +7339,10 @@ class CallExpression extends NodeBase {
             returnExpression.include(context, false);
         }
     }
-    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
-        const surroundingELement = renderedParentType || renderedSurroundingElement;
+    render(code, options, { renderedSurroundingElement } = BLANK) {
         this.callee.render(code, options, {
             isCalleeOfRenderedParent: true,
-            renderedSurroundingElement: surroundingELement
+            renderedSurroundingElement
         });
         if (this.arguments.length > 0) {
             if (this.arguments[this.arguments.length - 1].included) {
@@ -7377,10 +7457,9 @@ class ClassBody extends NodeBase {
 }
 
 class ClassExpression extends ClassNode {
-    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        const surroundingElement = renderedParentType || renderedSurroundingElement;
-        if (surroundingElement === ExpressionStatement$1) {
+        if (renderedSurroundingElement === ExpressionStatement$1) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -7554,15 +7633,12 @@ class ConditionalExpression extends NodeBase {
             usedBranch.render(code, options, {
                 isCalleeOfRenderedParent,
                 preventASI: true,
-                ...(renderedSurroundingElement
-                    ? { renderedSurroundingElement }
-                    : { renderedParentType: renderedParentType || this.parent.type })
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
             });
         }
         else {
-            this.test.render(code, options, {
-                renderedSurroundingElement: renderedParentType || renderedSurroundingElement
-            });
+            this.test.render(code, options, { renderedSurroundingElement });
             this.consequent.render(code, options);
             this.alternate.render(code, options);
         }
@@ -7796,10 +7872,9 @@ class ForStatement extends NodeBase {
 }
 
 class FunctionExpression extends FunctionNode {
-    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        const surroundingElement = renderedParentType || renderedSurroundingElement;
-        if (surroundingElement === ExpressionStatement$1) {
+        if (renderedSurroundingElement === ExpressionStatement$1) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -8127,12 +8202,12 @@ class ImportExpression extends NodeBase {
         if (this.inlineNamespace) {
             const _ = options.compact ? '' : ' ';
             const s = options.compact ? '' : ';';
-            code.overwrite(this.start, this.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.inlineNamespace.getName()}${s}${_}})`);
+            code.overwrite(this.start, this.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.inlineNamespace.getName()}${s}${_}})`, { contentOnly: true });
             return;
         }
         if (this.mechanism) {
-            code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, this.mechanism.left);
-            code.overwrite(this.end - 1, this.end, this.mechanism.right);
+            code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, this.mechanism.left, { contentOnly: true });
+            code.overwrite(this.end - 1, this.end, this.mechanism.right, { contentOnly: true });
         }
         this.source.render(code, options);
     }
@@ -8393,15 +8468,14 @@ class LogicalExpression extends NodeBase {
             this.getUsedBranch().render(code, options, {
                 isCalleeOfRenderedParent,
                 preventASI,
-                ...(renderedSurroundingElement
-                    ? { renderedSurroundingElement }
-                    : { renderedParentType: renderedParentType || this.parent.type })
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
             });
         }
         else {
             this.left.render(code, options, {
                 preventASI,
-                renderedSurroundingElement: renderedParentType || renderedSurroundingElement
+                renderedSurroundingElement
             });
             this.right.render(code, options);
         }
@@ -8657,11 +8731,10 @@ class ObjectExpression extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
-    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+    render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        const surroundingElement = renderedParentType || renderedSurroundingElement;
-        if (surroundingElement === ExpressionStatement$1 ||
-            surroundingElement === ArrowFunctionExpression$1) {
+        if (renderedSurroundingElement === ExpressionStatement$1 ||
+            renderedSurroundingElement === ArrowFunctionExpression$1) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -8707,47 +8780,6 @@ class ObjectExpression extends NodeBase {
     }
 }
 
-class ObjectPattern extends NodeBase {
-    addExportedVariables(variables, exportNamesByVariable) {
-        for (const property of this.properties) {
-            if (property.type === Property$1) {
-                property.value.addExportedVariables(variables, exportNamesByVariable);
-            }
-            else {
-                property.argument.addExportedVariables(variables, exportNamesByVariable);
-            }
-        }
-    }
-    declare(kind, init) {
-        const variables = [];
-        for (const property of this.properties) {
-            variables.push(...property.declare(kind, init));
-        }
-        return variables;
-    }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            for (const property of this.properties) {
-                property.deoptimizePath(path);
-            }
-        }
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length > 0)
-            return true;
-        for (const property of this.properties) {
-            if (property.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
-                return true;
-        }
-        return false;
-    }
-    markDeclarationReached() {
-        for (const property of this.properties) {
-            property.markDeclarationReached();
-        }
-    }
-}
-
 class PrivateIdentifier extends NodeBase {
 }
 
@@ -8902,17 +8934,12 @@ class SequenceExpression extends NodeBase {
                 removeLineBreaks(code, start, node.start);
             }
             if (includedNodes === 1) {
-                if (node === lastNode) {
-                    node.render(code, options, {
-                        isCalleeOfRenderedParent,
-                        renderedParentType: renderedParentType || this.parent.type
-                    });
-                }
-                else {
-                    node.render(code, options, {
-                        renderedSurroundingElement: renderedParentType || this.parent.type
-                    });
-                }
+                const parentType = renderedParentType || this.parent.type;
+                node.render(code, options, {
+                    isCalleeOfRenderedParent: isCalleeOfRenderedParent && node === lastNode,
+                    renderedParentType: parentType,
+                    renderedSurroundingElement: parentType
+                });
             }
             else {
                 node.render(code, options);
@@ -9381,31 +9408,19 @@ class UpdateExpression extends NodeBase {
         if (options.format === 'system') {
             const variable = this.argument.variable;
             const exportNames = options.exportNamesByVariable.get(variable);
-            if (exportNames && exportNames.length) {
+            if (exportNames) {
                 const _ = options.compact ? '' : ' ';
-                const name = variable.getName();
                 if (this.prefix) {
                     if (exportNames.length === 1) {
-                        code.overwrite(this.start, this.end, `exports('${exportNames[0]}',${_}${this.operator}${name})`);
+                        renderSystemExportExpression(variable, this.start, this.end, code, options);
                     }
                     else {
-                        code.overwrite(this.start, this.end, `(${this.operator}${name},${_}${getSystemExportStatement([variable], options)},${_}${name})`);
+                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options);
                     }
                 }
-                else if (exportNames.length > 1) {
-                    code.overwrite(this.start, this.end, `(${getSystemExportFunctionLeft([variable], false, options)}${this.operator}${name}))`);
-                }
                 else {
-                    let op;
-                    switch (this.operator) {
-                        case '++':
-                            op = `${name}${_}+${_}1`;
-                            break;
-                        case '--':
-                            op = `${name}${_}-${_}1`;
-                            break;
-                    }
-                    code.overwrite(this.start, this.end, `(exports('${exportNames[0]}',${_}${op}),${_}${name}${this.operator})`);
+                    const operator = this.operator[0];
+                    renderSystemExportSequenceBeforeExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options, `${_}${operator}${_}1`);
                 }
             }
         }
@@ -9453,7 +9468,7 @@ class VariableDeclarator extends NodeBase {
             code.remove(this.start, findNonWhiteSpace(code.original, operatorPos + 1));
         }
         if (this.init) {
-            this.init.render(code, options, renderId ? BLANK : { renderedParentType: ExpressionStatement$1 });
+            this.init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
         }
         else if (this.id instanceof Identifier &&
             isReassignedExportsMember(this.id.variable, options.exportNamesByVariable)) {
@@ -10001,9 +10016,9 @@ class Module {
             code: null,
             get dynamicallyImportedIds() {
                 const dynamicallyImportedIds = [];
-                for (const { resolution } of module.dynamicImports) {
-                    if (resolution instanceof Module || resolution instanceof ExternalModule) {
-                        dynamicallyImportedIds.push(resolution.id);
+                for (const { id } of module.dynamicImports) {
+                    if (id) {
+                        dynamicallyImportedIds.push(id);
                     }
                 }
                 return dynamicallyImportedIds;
@@ -10476,7 +10491,7 @@ class Module {
         else if (argument instanceof Literal && typeof argument.value === 'string') {
             argument = argument.value;
         }
-        this.dynamicImports.push({ argument, node, resolution: null });
+        this.dynamicImports.push({ argument, id: null, node, resolution: null });
     }
     addExport(node) {
         if (node instanceof ExportDefaultDeclaration) {
@@ -11280,13 +11295,11 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasExports,
 
 function getStarExcludes({ dependencies, exports }) {
     const starExcludes = new Set(exports.map(expt => expt.exported));
-    if (!starExcludes.has('default'))
-        starExcludes.add('default');
-    // also include reexport names
+    starExcludes.add('default');
     for (const { reexports } of dependencies) {
         if (reexports) {
             for (const reexport of reexports) {
-                if (reexport.imported !== '*' && !starExcludes.has(reexport.reexported))
+                if (reexport.imported !== '*')
                     starExcludes.add(reexport.reexported);
             }
         }
@@ -11310,9 +11323,7 @@ function getExportsBlock(exports, _, t, n) {
         exports.map(({ name, value }) => `${t}${t}${t}${t}${name}:${_}${value}`).join(`,${n}`) +
         `${n}${t}${t}${t}});${n}${n}`);
 }
-const getHoistedExportsBlock = (exports, _, t, n) => getExportsBlock(exports
-    .filter(expt => expt.hoisted || expt.uninitialized)
-    .map(expt => ({ name: expt.exported, value: expt.uninitialized ? 'void 0' : expt.local })), _, t, n);
+const getHoistedExportsBlock = (exports, _, t, n) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), _, t, n);
 const getMissingExportsBlock = (exports, _, t, n) => getExportsBlock(exports
     .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
     .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), _, t, n);
@@ -11353,10 +11364,8 @@ function system(magicString, { accessedGlobals, dependencies, exports, hasExport
                     if (!starExcludes) {
                         starExcludes = getStarExcludes({ dependencies, exports });
                     }
-                    if (!createdSetter) {
-                        setter.push(`${varOrConst} _setter${_}=${_}{};`);
-                        createdSetter = true;
-                    }
+                    createdSetter = true;
+                    setter.push(`${varOrConst} _setter${_}=${_}{};`);
                     setter.push(`for${_}(var _$p${_}in${_}module)${_}{`);
                     setter.push(`${t}if${_}(!_starExcludes[_$p])${_}_setter[_$p]${_}=${_}module[_$p];`);
                     setter.push('}');
@@ -12699,12 +12708,8 @@ class Chunk {
             }
             let expression = null;
             let hoisted = false;
-            let uninitialized = false;
             let local = variable.getName();
             if (variable instanceof LocalVariable) {
-                if (variable.init === UNDEFINED_EXPRESSION) {
-                    uninitialized = true;
-                }
                 for (const declaration of variable.declarations) {
                     if (declaration.parent instanceof FunctionDeclaration ||
                         (declaration instanceof ExportDefaultDeclaration &&
@@ -12724,8 +12729,7 @@ class Chunk {
                 exported: exportName,
                 expression,
                 hoisted,
-                local,
-                uninitialized
+                local
             });
         }
         return exports;
@@ -19669,12 +19673,10 @@ class ModuleLoader {
         }));
     }
     async addModuleSource(id, importer, module) {
-        var _a;
         timeStart('load modules', 3);
         let source;
         try {
-            source =
-                (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await this.readQueue.run(async () => readFile(id)));
+            source = await this.readQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await readFile(id)); });
         }
         catch (err) {
             timeEnd('load modules', 3);
@@ -19723,11 +19725,8 @@ class ModuleLoader {
         });
         return loadNewModulesPromise;
     }
-    async fetchDynamicDependencies(module) {
-        const dependencies = await Promise.all(module.dynamicImports.map(async (dynamicImport) => {
-            const resolvedId = await this.resolveDynamicImport(module, typeof dynamicImport.argument === 'string'
-                ? dynamicImport.argument
-                : dynamicImport.argument.esTreeNode, module.id);
+    async fetchDynamicDependencies(module, resolveDynamicImportPromises) {
+        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([dynamicImport, resolvedId]) => {
             if (resolvedId === null)
                 return null;
             if (typeof resolvedId === 'string') {
@@ -19735,7 +19734,7 @@ class ModuleLoader {
                 return null;
             }
             return (dynamicImport.resolution = await this.fetchResolvedDependency(relativeId(resolvedId.id), module.id, resolvedId));
-        }));
+        })));
         for (const dependency of dependencies) {
             if (dependency) {
                 module.dynamicDependencies.add(dependency);
@@ -19760,10 +19759,15 @@ class ModuleLoader {
         this.modulesById.set(id, module);
         this.graph.watchFiles[id] = true;
         await this.addModuleSource(id, importer, module);
-        await this.pluginDriver.hookParallel('moduleParsed', [module.info]);
+        const resolveStaticDependencyPromises = this.getResolveStaticDependencyPromises(module);
+        const resolveDynamicImportPromises = this.getResolveDynamicImportPromises(module);
+        Promise.all([
+            ...resolveStaticDependencyPromises,
+            ...resolveDynamicImportPromises
+        ]).then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
         await Promise.all([
-            this.fetchStaticDependencies(module),
-            this.fetchDynamicDependencies(module)
+            this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
+            this.fetchDynamicDependencies(module, resolveDynamicImportPromises)
         ]);
         module.linkImports();
         return module;
@@ -19784,10 +19788,8 @@ class ModuleLoader {
             return this.fetchModule(resolvedId, importer, false);
         }
     }
-    async fetchStaticDependencies(module) {
-        for (const dependency of await Promise.all(Array.from(module.sources, async (source) => this.fetchResolvedDependency(source, module.id, (module.resolvedIds[source] =
-            module.resolvedIds[source] ||
-                this.handleResolveId(await this.resolveId(source, module.id, EMPTY_OBJECT), source, module.id)))))) {
+    async fetchStaticDependencies(module, resolveStaticDependencyPromises) {
+        for (const dependency of await Promise.all(resolveStaticDependencyPromises.map(resolveStaticDependencyPromise => resolveStaticDependencyPromise.then(([source, resolvedId]) => this.fetchResolvedDependency(source, module.id, resolvedId))))) {
             module.dependencies.add(dependency);
             dependency.importers.push(module.id);
         }
@@ -19835,6 +19837,25 @@ class ModuleLoader {
             id
         };
     }
+    getResolveDynamicImportPromises(module) {
+        return module.dynamicImports.map(async (dynamicImport) => {
+            const resolvedId = await this.resolveDynamicImport(module, typeof dynamicImport.argument === 'string'
+                ? dynamicImport.argument
+                : dynamicImport.argument.esTreeNode, module.id);
+            if (resolvedId && typeof resolvedId === 'object') {
+                dynamicImport.id = resolvedId.id;
+            }
+            return [dynamicImport, resolvedId];
+        });
+    }
+    getResolveStaticDependencyPromises(module) {
+        return Array.from(module.sources, async (source) => [
+            source,
+            (module.resolvedIds[source] =
+                module.resolvedIds[source] ||
+                    this.handleResolveId(await this.resolveId(source, module.id, EMPTY_OBJECT), source, module.id))
+        ]);
+    }
     handleResolveId(resolvedId, source, importer) {
         if (resolvedId === null) {
             if (isRelative(source)) {