rollup 2.38.4 → 2.40.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.38.4
-	Tue, 02 Feb 2021 05:54:38 GMT - commit 991bb98fad1f3f76226bfe6243fd6cc45a19a39b
+	Rollup.js v2.40.0
+	Fri, 26 Feb 2021 14:39:44 GMT - commit 0a0958ff926554abe9916178f56762ba71301ddd
 
 
 	https://github.com/rollup/rollup
@@ -13,12 +13,12 @@ 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.38.4";
+var version$1 = "2.40.0";
 
 var charToInteger = {};
-var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i = 0; i < chars.length; i++) {
-    charToInteger[chars.charCodeAt(i)] = i;
+var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i = 0; i < chars$1.length; i++) {
+    charToInteger[chars$1.charCodeAt(i)] = i;
 }
 function decode(mappings) {
     var decoded = [];
@@ -132,7 +132,7 @@ function encodeInteger(num) {
         if (num > 0) {
             clamped |= 32;
         }
-        result += chars[clamped];
+        result += chars$1[clamped];
     } while (num > 0);
     return result;
 }
@@ -149,7 +149,7 @@ BitSet.prototype.has = function has (n) {
 	return !!(this.bits[n >> 5] & (1 << (n & 31)));
 };
 
-var Chunk = function Chunk(start, end, content) {
+var Chunk$1 = function Chunk(start, end, content) {
 	this.start = start;
 	this.end = end;
 	this.original = content;
@@ -168,16 +168,16 @@ var Chunk = function Chunk(start, end, content) {
 	});
 };
 
-Chunk.prototype.appendLeft = function appendLeft (content) {
+Chunk$1.prototype.appendLeft = function appendLeft (content) {
 	this.outro += content;
 };
 
-Chunk.prototype.appendRight = function appendRight (content) {
+Chunk$1.prototype.appendRight = function appendRight (content) {
 	this.intro = this.intro + content;
 };
 
-Chunk.prototype.clone = function clone () {
-	var chunk = new Chunk(this.start, this.end, this.original);
+Chunk$1.prototype.clone = function clone () {
+	var chunk = new Chunk$1(this.start, this.end, this.original);
 
 	chunk.intro = this.intro;
 	chunk.outro = this.outro;
@@ -188,11 +188,11 @@ Chunk.prototype.clone = function clone () {
 	return chunk;
 };
 
-Chunk.prototype.contains = function contains (index) {
+Chunk$1.prototype.contains = function contains (index) {
 	return this.start < index && index < this.end;
 };
 
-Chunk.prototype.eachNext = function eachNext (fn) {
+Chunk$1.prototype.eachNext = function eachNext (fn) {
 	var chunk = this;
 	while (chunk) {
 		fn(chunk);
@@ -200,7 +200,7 @@ Chunk.prototype.eachNext = function eachNext (fn) {
 	}
 };
 
-Chunk.prototype.eachPrevious = function eachPrevious (fn) {
+Chunk$1.prototype.eachPrevious = function eachPrevious (fn) {
 	var chunk = this;
 	while (chunk) {
 		fn(chunk);
@@ -208,7 +208,7 @@ Chunk.prototype.eachPrevious = function eachPrevious (fn) {
 	}
 };
 
-Chunk.prototype.edit = function edit (content, storeName, contentOnly) {
+Chunk$1.prototype.edit = function edit (content, storeName, contentOnly) {
 	this.content = content;
 	if (!contentOnly) {
 		this.intro = '';
@@ -221,15 +221,15 @@ Chunk.prototype.edit = function edit (content, storeName, contentOnly) {
 	return this;
 };
 
-Chunk.prototype.prependLeft = function prependLeft (content) {
+Chunk$1.prototype.prependLeft = function prependLeft (content) {
 	this.outro = content + this.outro;
 };
 
-Chunk.prototype.prependRight = function prependRight (content) {
+Chunk$1.prototype.prependRight = function prependRight (content) {
 	this.intro = content + this.intro;
 };
 
-Chunk.prototype.split = function split (index) {
+Chunk$1.prototype.split = function split (index) {
 	var sliceIndex = index - this.start;
 
 	var originalBefore = this.original.slice(0, sliceIndex);
@@ -237,7 +237,7 @@ Chunk.prototype.split = function split (index) {
 
 	this.original = originalBefore;
 
-	var newChunk = new Chunk(index, this.end, originalAfter);
+	var newChunk = new Chunk$1(index, this.end, originalAfter);
 	newChunk.outro = this.outro;
 	this.outro = '';
 
@@ -259,11 +259,11 @@ Chunk.prototype.split = function split (index) {
 	return newChunk;
 };
 
-Chunk.prototype.toString = function toString () {
+Chunk$1.prototype.toString = function toString () {
 	return this.intro + this.content + this.outro;
 };
 
-Chunk.prototype.trimEnd = function trimEnd (rx) {
+Chunk$1.prototype.trimEnd = function trimEnd (rx) {
 	this.outro = this.outro.replace(rx, '');
 	if (this.outro.length) { return true; }
 
@@ -283,7 +283,7 @@ Chunk.prototype.trimEnd = function trimEnd (rx) {
 	}
 };
 
-Chunk.prototype.trimStart = function trimStart (rx) {
+Chunk$1.prototype.trimStart = function trimStart (rx) {
 	this.intro = this.intro.replace(rx, '');
 	if (this.intro.length) { return true; }
 
@@ -375,13 +375,13 @@ function getRelativePath(from, to) {
 	return fromParts.concat(toParts).join('/');
 }
 
-var toString = Object.prototype.toString;
+var toString$1 = Object.prototype.toString;
 
 function isObject(thing) {
-	return toString.call(thing) === '[object Object]';
+	return toString$1.call(thing) === '[object Object]';
 }
 
-function getLocator(source) {
+function getLocator$1(source) {
 	var originalLines = source.split('\n');
 	var lineOffsets = [];
 
@@ -486,7 +486,7 @@ var warned = {
 var MagicString = function MagicString(string, options) {
 	if ( options === void 0 ) options = {};
 
-	var chunk = new Chunk(0, string.length, string);
+	var chunk = new Chunk$1(0, string.length, string);
 
 	Object.defineProperties(this, {
 		original:              { writable: true, value: string },
@@ -595,7 +595,7 @@ MagicString.prototype.generateDecodedMap = function generateDecodedMap (options)
 	var names = Object.keys(this.storedNames);
 	var mappings = new Mappings(options.hires);
 
-	var locate = getLocator(this.original);
+	var locate = getLocator$1(this.original);
 
 	if (this.intro) {
 		mappings.advance(this.intro);
@@ -831,7 +831,7 @@ MagicString.prototype.overwrite = function overwrite (start, end, content, optio
 		}
 	} else {
 		// must be inserting at the end
-		var newChunk = new Chunk(start, end, '').edit(content, storeName);
+		var newChunk = new Chunk$1(start, end, '').edit(content, storeName);
 
 		// TODO last chunk in the array may not be the last chunk, if it's moved...
 		last.next = newChunk;
@@ -1029,7 +1029,7 @@ MagicString.prototype._split = function _split (index) {
 MagicString.prototype._splitChunk = function _splitChunk (chunk, index) {
 	if (chunk.edited && chunk.content.length) {
 		// zero-length edited chunks are a special case (overlapping replacements)
-		var loc = getLocator(this.original)(index);
+		var loc = getLocator$1(this.original)(index);
 		throw new Error(
 			("Cannot split a chunk that has already been edited (" + (loc.line) + ":" + (loc.column) + " – \"" + (chunk.original) + "\")")
 		);
@@ -1156,7 +1156,7 @@ MagicString.prototype.trimStart = function trimStart (charType) {
 
 var hasOwnProp = Object.prototype.hasOwnProperty;
 
-var Bundle = function Bundle(options) {
+var Bundle$1 = function Bundle(options) {
 	if ( options === void 0 ) options = {};
 
 	this.intro = options.intro || '';
@@ -1166,7 +1166,7 @@ var Bundle = function Bundle(options) {
 	this.uniqueSourceIndexByFilename = {};
 };
 
-Bundle.prototype.addSource = function addSource (source) {
+Bundle$1.prototype.addSource = function addSource (source) {
 	if (source instanceof MagicString) {
 		return this.addSource({
 			content: source,
@@ -1204,7 +1204,7 @@ Bundle.prototype.addSource = function addSource (source) {
 	return this;
 };
 
-Bundle.prototype.append = function append (str, options) {
+Bundle$1.prototype.append = function append (str, options) {
 	this.addSource({
 		content: new MagicString(str),
 		separator: (options && options.separator) || ''
@@ -1213,8 +1213,8 @@ Bundle.prototype.append = function append (str, options) {
 	return this;
 };
 
-Bundle.prototype.clone = function clone () {
-	var bundle = new Bundle({
+Bundle$1.prototype.clone = function clone () {
+	var bundle = new Bundle$1({
 		intro: this.intro,
 		separator: this.separator
 	});
@@ -1230,7 +1230,7 @@ Bundle.prototype.clone = function clone () {
 	return bundle;
 };
 
-Bundle.prototype.generateDecodedMap = function generateDecodedMap (options) {
+Bundle$1.prototype.generateDecodedMap = function generateDecodedMap (options) {
 		var this$1 = this;
 		if ( options === void 0 ) options = {};
 
@@ -1254,7 +1254,7 @@ Bundle.prototype.generateDecodedMap = function generateDecodedMap (options) {
 
 		var sourceIndex = source.filename ? this$1.uniqueSourceIndexByFilename[source.filename] : -1;
 		var magicString = source.content;
-		var locate = getLocator(magicString.original);
+		var locate = getLocator$1(magicString.original);
 
 		if (magicString.intro) {
 			mappings.advance(magicString.intro);
@@ -1307,11 +1307,11 @@ Bundle.prototype.generateDecodedMap = function generateDecodedMap (options) {
 	};
 };
 
-Bundle.prototype.generateMap = function generateMap (options) {
+Bundle$1.prototype.generateMap = function generateMap (options) {
 	return new SourceMap(this.generateDecodedMap(options));
 };
 
-Bundle.prototype.getIndentString = function getIndentString () {
+Bundle$1.prototype.getIndentString = function getIndentString () {
 	var indentStringCounts = {};
 
 	this.sources.forEach(function (source) {
@@ -1330,7 +1330,7 @@ Bundle.prototype.getIndentString = function getIndentString () {
 	);
 };
 
-Bundle.prototype.indent = function indent (indentStr) {
+Bundle$1.prototype.indent = function indent (indentStr) {
 		var this$1 = this;
 
 	if (!arguments.length) {
@@ -1364,12 +1364,12 @@ Bundle.prototype.indent = function indent (indentStr) {
 	return this;
 };
 
-Bundle.prototype.prepend = function prepend (str) {
+Bundle$1.prototype.prepend = function prepend (str) {
 	this.intro = str + this.intro;
 	return this;
 };
 
-Bundle.prototype.toString = function toString () {
+Bundle$1.prototype.toString = function toString () {
 		var this$1 = this;
 
 	var body = this.sources
@@ -1384,7 +1384,7 @@ Bundle.prototype.toString = function toString () {
 	return this.intro + body;
 };
 
-Bundle.prototype.isEmpty = function isEmpty () {
+Bundle$1.prototype.isEmpty = function isEmpty () {
 	if (this.intro.length && this.intro.trim())
 		{ return false; }
 	if (this.sources.some(function (source) { return !source.content.isEmpty(); }))
@@ -1392,19 +1392,19 @@ Bundle.prototype.isEmpty = function isEmpty () {
 	return true;
 };
 
-Bundle.prototype.length = function length () {
+Bundle$1.prototype.length = function length () {
 	return this.sources.reduce(function (length, source) { return length + source.content.length(); }, this.intro.length);
 };
 
-Bundle.prototype.trimLines = function trimLines () {
+Bundle$1.prototype.trimLines = function trimLines () {
 	return this.trim('[\\r\\n]');
 };
 
-Bundle.prototype.trim = function trim (charType) {
+Bundle$1.prototype.trim = function trim (charType) {
 	return this.trimStart(charType).trimEnd(charType);
 };
 
-Bundle.prototype.trimStart = function trimStart (charType) {
+Bundle$1.prototype.trimStart = function trimStart (charType) {
 	var rx = new RegExp('^' + (charType || '\\s') + '+');
 	this.intro = this.intro.replace(rx, '');
 
@@ -1423,7 +1423,7 @@ Bundle.prototype.trimStart = function trimStart (charType) {
 	return this;
 };
 
-Bundle.prototype.trimEnd = function trimEnd (charType) {
+Bundle$1.prototype.trimEnd = function trimEnd (charType) {
 	var rx = new RegExp((charType || '\\s') + '+$');
 
 	var source;
@@ -1461,17 +1461,17 @@ function relative(from, to) {
     return toParts.join('/');
 }
 
-const ArrowFunctionExpression = 'ArrowFunctionExpression';
-const BlockStatement = 'BlockStatement';
-const CallExpression = 'CallExpression';
-const ExpressionStatement = 'ExpressionStatement';
-const FunctionExpression = 'FunctionExpression';
-const Identifier = 'Identifier';
-const ImportDefaultSpecifier = 'ImportDefaultSpecifier';
-const ImportNamespaceSpecifier = 'ImportNamespaceSpecifier';
-const Program = 'Program';
-const Property = 'Property';
-const ReturnStatement = 'ReturnStatement';
+const ArrowFunctionExpression$1 = 'ArrowFunctionExpression';
+const BlockStatement$1 = 'BlockStatement';
+const CallExpression$1 = 'CallExpression';
+const ExpressionStatement$1 = 'ExpressionStatement';
+const Identifier$1 = 'Identifier';
+const ImportDefaultSpecifier$1 = 'ImportDefaultSpecifier';
+const ImportNamespaceSpecifier$1 = 'ImportNamespaceSpecifier';
+const NewExpression$1 = 'NewExpression';
+const Program$1 = 'Program';
+const Property$1 = 'Property';
+const ReturnStatement$1 = 'ReturnStatement';
 
 function treeshakeNode(node, code, start, end) {
     code.remove(start, end);
@@ -1487,7 +1487,7 @@ function treeshakeNode(node, code, start, end) {
     }
 }
 function removeAnnotations(node, code) {
-    if (!node.annotations && node.parent.type === ExpressionStatement) {
+    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
         node = node.parent;
     }
     if (node.annotations) {
@@ -1661,14 +1661,14 @@ function getSystemExportFunctionLeft(exportedVariables, setFromExpression, optio
         .join(`,${_}`)}${_}}),${_}v${s}${_}}(`;
 }
 
-const chars$1 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
-const base = 64;
+const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const base$1 = 64;
 function toBase64(num) {
     let outStr = '';
     do {
-        const curDigit = num % base;
-        num = Math.floor(num / base);
-        outStr = chars$1[curDigit] + outStr;
+        const curDigit = num % base$1;
+        num = Math.floor(num / base$1);
+        outStr = chars[curDigit] + outStr;
     } while (num !== 0);
     return outStr;
 }
@@ -2403,7 +2403,7 @@ class LocalVariable extends Variable {
                     // We do not want to properly include parents in case they are part of a dead branch
                     // in which case .include() might pull in more dead code
                     node.included = true;
-                    if (node.type === Program)
+                    if (node.type === Program$1)
                         break;
                     node = node.parent;
                 }
@@ -2427,7 +2427,7 @@ class LocalVariable extends Variable {
     }
 }
 
-class Scope {
+class Scope$1 {
     constructor() {
         this.children = [];
         this.variables = new Map();
@@ -2452,7 +2452,7 @@ class Scope {
     }
 }
 
-class ChildScope extends Scope {
+class ChildScope extends Scope$1 {
     constructor(parent) {
         super();
         this.accessedOutsideVariables = new Map();
@@ -2534,7 +2534,7 @@ class ChildScope extends Scope {
     }
 }
 
-function getLocator$1(source, options) {
+function getLocator(source, options) {
     if (options === void 0) { options = {}; }
     var offsetLine = options.offsetLine || 0;
     var offsetColumn = options.offsetColumn || 0;
@@ -2572,7 +2572,7 @@ function locate(source, search, options) {
     if (typeof options === 'number') {
         throw new Error('locate takes a { startIndex, offsetLine, offsetColumn } object as the third argument');
     }
-    return getLocator$1(source, options)(search, options && options.startIndex);
+    return getLocator(source, options)(search, options && options.startIndex);
 }
 
 const keys = {
@@ -2952,34 +2952,55 @@ class FunctionScope extends ReturnValueScope {
     }
 }
 
-function isReference(node, parent) {
-    if (node.type === 'MemberExpression') {
-        return !node.computed && isReference(node.object, node);
-    }
-    if (node.type === 'Identifier') {
-        if (!parent)
-            return true;
-        switch (parent.type) {
-            // disregard `bar` in `foo.bar`
-            case 'MemberExpression': return parent.computed || node === parent.object;
-            // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
-            case 'MethodDefinition': return parent.computed;
-            // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
-            case 'FieldDefinition': return parent.computed || node === parent.value;
-            // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-            case 'Property': return parent.computed || node === parent.value;
-            // disregard the `bar` in `export { foo as bar }` or
-            // the foo in `import { foo as bar }`
-            case 'ExportSpecifier':
-            case 'ImportSpecifier': return node === parent.local;
-            // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
-            case 'LabeledStatement':
-            case 'BreakStatement':
-            case 'ContinueStatement': return false;
-            default: return true;
-        }
-    }
-    return false;
+//@ts-check
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
+
+/**
+ *
+ * @param {NodeWithPropertyDefinition} node
+ * @param {NodeWithPropertyDefinition} parent
+ * @returns boolean
+ */
+function is_reference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
+
+	if (node.type === 'Identifier') {
+		if (!parent) return true;
+
+		switch (parent.type) {
+			// disregard `bar` in `foo.bar`
+			case 'MemberExpression': return parent.computed || node === parent.object;
+
+			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+			case 'MethodDefinition': return parent.computed;
+
+			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+			case 'PropertyDefinition': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+			case 'Property': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `export { foo as bar }` or
+			// the foo in `import { foo as bar }`
+			case 'ExportSpecifier':
+			case 'ImportSpecifier': return node === parent.local;
+
+			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+			case 'LabeledStatement':
+			case 'BreakStatement':
+			case 'ContinueStatement': return false;
+			default: return true;
+		}
+	}
+
+	return false;
 }
 
 const BLANK = Object.freeze(Object.create(null));
@@ -3867,7 +3888,7 @@ class GlobalVariable extends Variable {
     }
 }
 
-class Identifier$1 extends NodeBase {
+class Identifier extends NodeBase {
     constructor() {
         super(...arguments);
         this.variable = null;
@@ -3882,7 +3903,7 @@ class Identifier$1 extends NodeBase {
         if (this.bound)
             return;
         this.bound = true;
-        if (this.variable === null && isReference(this, this.parent)) {
+        if (this.variable === null && is_reference(this, this.parent)) {
             this.variable = this.scope.findVariable(this.name);
             this.variable.addReference(this);
         }
@@ -3974,7 +3995,7 @@ class Identifier$1 extends NodeBase {
             }
             // In strict mode, any variable named "eval" must be the actual "eval" function
             if (name === 'eval' &&
-                renderedParentType === CallExpression &&
+                renderedParentType === CallExpression$1 &&
                 isCalleeOfRenderedParent) {
                 code.appendRight(this.start, '0, ');
             }
@@ -4086,7 +4107,7 @@ class FunctionNode extends NodeBase {
             this.id.include();
         const hasArguments = this.scope.argumentsVariable.included;
         for (const param of this.params) {
-            if (!(param instanceof Identifier$1) || hasArguments) {
+            if (!(param instanceof Identifier) || hasArguments) {
                 param.include(context, includeChildrenRecursively);
             }
         }
@@ -4176,7 +4197,7 @@ class ExportDefaultDeclaration extends NodeBase {
             code.remove(this.start, declarationStart);
             this.declaration.render(code, options, {
                 isCalleeOfRenderedParent: false,
-                renderedParentType: ExpressionStatement
+                renderedParentType: ExpressionStatement$1
             });
             if (code.original[this.end - 1] !== ';') {
                 code.appendLeft(this.end, ';');
@@ -4236,7 +4257,7 @@ class ExportDefaultVariable extends LocalVariable {
             this.hasId = true;
             this.originalId = declaration.id;
         }
-        else if (declaration instanceof Identifier$1) {
+        else if (declaration instanceof Identifier) {
             this.originalId = declaration;
         }
     }
@@ -4470,9 +4491,9 @@ class ExternalVariable extends Variable {
     }
 }
 
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'.split(' ');
-const builtins = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');
-const blacklisted = new Set(reservedWords.concat(builtins));
+const reservedWords$1 = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'.split(' ');
+const builtins$1 = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');
+const blacklisted = new Set(reservedWords$1.concat(builtins$1));
 const illegalCharacters = /[^$_a-zA-Z0-9]/g;
 const startsWithDigit = (str) => /\d/.test(str[0]);
 function isLegal(str) {
@@ -4705,38 +4726,13 @@ function getFrozen(fragment, freeze) {
 }
 const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
 
-function getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, mechanism = 'return ') {
+function getExportBlock$1(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, mechanism = 'return ') {
     const _ = compact ? '' : ' ';
     const n = compact ? '' : '\n';
     if (!namedExportsMode) {
         return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings)};`;
     }
     let exportBlock = '';
-    // star exports must always output first for precedence
-    for (const { name, reexports } of dependencies) {
-        if (reexports && namedExportsMode) {
-            for (const specifier of reexports) {
-                if (specifier.reexported === '*') {
-                    if (exportBlock)
-                        exportBlock += n;
-                    if (specifier.needsLiveBinding) {
-                        exportBlock +=
-                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
-                                `${t}if${_}(k${_}!==${_}'default')${_}Object.defineProperty(exports,${_}k,${_}{${n}` +
-                                `${t}${t}enumerable:${_}true,${n}` +
-                                `${t}${t}get:${_}function${_}()${_}{${n}` +
-                                `${t}${t}${t}return ${name}[k];${n}` +
-                                `${t}${t}}${n}${t}});${n}});`;
-                    }
-                    else {
-                        exportBlock +=
-                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
-                                `${t}if${_}(k${_}!==${_}'default')${_}exports[k]${_}=${_}${name}[k];${n}});`;
-                    }
-                }
-            }
-        }
-    }
     for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
         if (reexports && namedExportsMode) {
             for (const specifier of reexports) {
@@ -4764,6 +4760,30 @@ function getExportBlock(exports, dependencies, namedExportsMode, interop, compac
             exportBlock += `${lhs}${_}=${_}${rhs};`;
         }
     }
+    for (const { name, reexports } of dependencies) {
+        if (reexports && namedExportsMode) {
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (specifier.needsLiveBinding) {
+                        exportBlock +=
+                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
+                                `${t}if${_}(k${_}!==${_}'default'${_}&&${_}!exports.hasOwnProperty(k))${_}Object.defineProperty(exports,${_}k,${_}{${n}` +
+                                `${t}${t}enumerable:${_}true,${n}` +
+                                `${t}${t}get:${_}function${_}()${_}{${n}` +
+                                `${t}${t}${t}return ${name}[k];${n}` +
+                                `${t}${t}}${n}${t}});${n}});`;
+                    }
+                    else {
+                        exportBlock +=
+                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
+                                `${t}if${_}(k${_}!==${_}'default'${_}&&${_}!exports.hasOwnProperty(k))${_}exports[k]${_}=${_}${name}[k];${n}});`;
+                    }
+                }
+            }
+        }
+    }
     if (exportBlock) {
         return `${n}${n}${exportBlock}`;
     }
@@ -4888,7 +4908,7 @@ function removeExtensionFromRelativeAmdId(id) {
     return id[0] === '.' ? removeJsExtension(id) : id;
 }
 
-const builtins$1 = {
+const builtins = {
     assert: true,
     buffer: true,
     console: true,
@@ -4912,7 +4932,7 @@ const builtins$1 = {
     zlib: true
 };
 function warnOnBuiltins(warn, dependencies) {
-    const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins$1);
+    const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins);
     if (!externalBuiltins.length)
         return;
     const detail = externalBuiltins.length === 1
@@ -4952,7 +4972,7 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         (deps.length ? `[${deps.join(`,${_}`)}],${_}` : ``);
     const useStrict = strict ? `${_}'use strict';` : '';
     magicString.prepend(`${intro}${getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t)}`);
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
     let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && esModule, isModuleFacade && namespaceToStringTag, _, n);
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
@@ -4973,13 +4993,13 @@ function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (namespaceMarkers) {
         namespaceMarkers += n + n;
     }
-    const importBlock = getImportBlock(dependencies, compact, varOrConst, n, _);
+    const importBlock = getImportBlock$1(dependencies, compact, varOrConst, n, _);
     const interopBlock = getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t);
     magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, `module.exports${_}=${_}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, `module.exports${_}=${_}`);
     return magicString.append(`${exportBlock}${outro}`);
 }
-function getImportBlock(dependencies, compact, varOrConst, n, _) {
+function getImportBlock$1(dependencies, compact, varOrConst, n, _) {
     let importBlock = '';
     let definingVariable = false;
     for (const { id, name, reexports, imports } of dependencies) {
@@ -5006,19 +5026,19 @@ function getImportBlock(dependencies, compact, varOrConst, n, _) {
 function es(magicString, { intro, outro, dependencies, exports, varOrConst }, { compact }) {
     const _ = compact ? '' : ' ';
     const n = compact ? '' : '\n';
-    const importBlock = getImportBlock$1(dependencies, _);
+    const importBlock = getImportBlock(dependencies, _);
     if (importBlock.length > 0)
         intro += importBlock.join(n) + n + n;
     if (intro)
         magicString.prepend(intro);
-    const exportBlock = getExportBlock$1(exports, _, varOrConst);
+    const exportBlock = getExportBlock(exports, _, varOrConst);
     if (exportBlock.length)
         magicString.append(n + n + exportBlock.join(n).trim());
     if (outro)
         magicString.append(outro);
     return magicString.trim();
 }
-function getImportBlock$1(dependencies, _) {
+function getImportBlock(dependencies, _) {
     const importBlock = [];
     for (const { id, reexports, imports, name } of dependencies) {
         if (!reexports && !imports) {
@@ -5102,7 +5122,7 @@ function getImportBlock$1(dependencies, _) {
     }
     return importBlock;
 }
-function getExportBlock$1(exports, _, varOrConst) {
+function getExportBlock(exports, _, varOrConst) {
     const exportBlock = [];
     const exportDeclaration = [];
     for (const specifier of exports) {
@@ -5159,7 +5179,11 @@ function getCodeFrame(source, line, column) {
 }
 
 function sanitizeFileName(name) {
-    return name.replace(/[\0?*]/g, '_');
+    const match = /^[a-z]:/i.exec(name);
+    const driveLetter = match ? match[0] : "";
+    // A `:` is only allowed as part of a windows drive letter (ex: C:\foo)
+    // Otherwise, avoid them because they can refer to NTFS alternate data streams.
+    return driveLetter + name.substr(driveLetter.length).replace(/[\0?*:]/g, '_');
 }
 
 function getAliasName(id) {
@@ -5209,6 +5233,7 @@ var Errors;
     Errors["BAD_LOADER"] = "BAD_LOADER";
     Errors["CANNOT_EMIT_FROM_OPTIONS_HOOK"] = "CANNOT_EMIT_FROM_OPTIONS_HOOK";
     Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
+    Errors["CHUNK_INVALID"] = "CHUNK_INVALID";
     Errors["CIRCULAR_REEXPORT"] = "CIRCULAR_REEXPORT";
     Errors["CYCLIC_CROSS_CHUNK_REEXPORT"] = "CYCLIC_CROSS_CHUNK_REEXPORT";
     Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
@@ -5253,6 +5278,14 @@ function errChunkNotGeneratedForFileName(name) {
         message: `Plugin error - Unable to get file name for chunk "${name}". Ensure that generate is called first.`
     };
 }
+function errChunkInvalid({ fileName, code }, exception) {
+    const errorProps = {
+        code: Errors.CHUNK_INVALID,
+        message: `Chunk "${fileName}" is not valid JavaScript: ${exception.message}.`
+    };
+    augmentCodeLocation(errorProps, exception.loc, code, fileName);
+    return errorProps;
+}
 function errCircularReexport(exportName, importedModule) {
     return {
         code: Errors.CIRCULAR_REEXPORT,
@@ -5609,7 +5642,7 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (hasExports && !extend && namedExportsMode) {
         wrapperOutro = `${n}${n}${t}return exports;${wrapperOutro}`;
     }
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
     let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule, namespaceToStringTag, _, n);
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
@@ -5850,7 +5883,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         `}(${globalArg}(function${_}(${factoryArgs.join(', ')})${_}{${useStrict}${n}`;
     const wrapperOutro = n + n + '})));';
     magicString.prepend(`${intro}${getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t)}`);
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
     let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule, namespaceToStringTag, _, n);
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
@@ -5980,11 +6013,11 @@ class BlockScope extends ChildScope {
     }
 }
 
-class ExpressionStatement$1 extends NodeBase {
+class ExpressionStatement extends NodeBase {
     initialise() {
         if (this.directive &&
             this.directive !== 'use strict' &&
-            this.parent.type === Program) {
+            this.parent.type === Program$1) {
             this.context.warn(
             // This is necessary, because either way (deleting or not) can lead to errors.
             {
@@ -6000,19 +6033,19 @@ class ExpressionStatement$1 extends NodeBase {
     }
     shouldBeIncluded(context) {
         if (this.directive && this.directive !== 'use strict')
-            return this.parent.type !== Program;
+            return this.parent.type !== Program$1;
         return super.shouldBeIncluded(context);
     }
 }
 
-class BlockStatement$1 extends NodeBase {
+class BlockStatement extends NodeBase {
     constructor() {
         super(...arguments);
         this.directlyIncluded = false;
     }
     addImplicitReturnExpressionToScope() {
         const lastStatement = this.body[this.body.length - 1];
-        if (!lastStatement || lastStatement.type !== ReturnStatement) {
+        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
             this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
         }
     }
@@ -6047,7 +6080,7 @@ class BlockStatement$1 extends NodeBase {
     initialise() {
         const firstBodyStatement = this.body[0];
         this.deoptimizeBody =
-            firstBodyStatement instanceof ExpressionStatement$1 &&
+            firstBodyStatement instanceof ExpressionStatement &&
                 firstBodyStatement.directive === 'use asm';
     }
     render(code, options) {
@@ -6060,7 +6093,7 @@ class BlockStatement$1 extends NodeBase {
     }
 }
 
-class ArrowFunctionExpression$1 extends NodeBase {
+class ArrowFunctionExpression extends NodeBase {
     createScope(parentScope) {
         this.scope = new ReturnValueScope(parentScope, this.context);
     }
@@ -6106,7 +6139,7 @@ class ArrowFunctionExpression$1 extends NodeBase {
     include(context, includeChildrenRecursively) {
         this.included = true;
         for (const param of this.params) {
-            if (!(param instanceof Identifier$1)) {
+            if (!(param instanceof Identifier)) {
                 param.include(context, includeChildrenRecursively);
             }
         }
@@ -6120,7 +6153,7 @@ class ArrowFunctionExpression$1 extends NodeBase {
     }
     initialise() {
         this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
-        if (this.body instanceof BlockStatement$1) {
+        if (this.body instanceof BlockStatement) {
             this.body.addImplicitReturnExpressionToScope();
         }
         else {
@@ -6128,13 +6161,13 @@ class ArrowFunctionExpression$1 extends NodeBase {
         }
     }
     parseNode(esTreeNode) {
-        if (esTreeNode.body.type === BlockStatement) {
+        if (esTreeNode.body.type === BlockStatement$1) {
             this.body = new this.context.nodeConstructors.BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
         }
         super.parseNode(esTreeNode);
     }
 }
-ArrowFunctionExpression$1.prototype.preventChildBlockScope = true;
+ArrowFunctionExpression.prototype.preventChildBlockScope = true;
 
 class AssignmentExpression extends NodeBase {
     constructor() {
@@ -6166,17 +6199,20 @@ class AssignmentExpression extends NodeBase {
         }
         this.right.include(context, includeChildrenRecursively);
     }
-    render(code, options, { renderedParentType } = BLANK) {
+    render(code, options, { preventASI, renderedParentType } = BLANK) {
         if (this.left.included) {
             this.left.render(code, options);
             this.right.render(code, options);
         }
         else {
+            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', this.left.end) + 1);
+            code.remove(this.start, inclusionStart);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, this.right.start);
+            }
             this.right.render(code, options, {
                 renderedParentType: renderedParentType || this.parent.type
             });
-            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', this.left.end);
-            code.remove(this.start, findNonWhiteSpace(code.original, operatorPos + 1));
         }
         if (options.format === 'system') {
             const exportNames = this.left.variable && options.exportNamesByVariable.get(this.left.variable);
@@ -6193,8 +6229,8 @@ class AssignmentExpression extends NodeBase {
                 const systemPatternExports = [];
                 this.left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
                 if (systemPatternExports.length > 0) {
-                    code.prependRight(this.start, getSystemExportFunctionLeft(systemPatternExports, true, options));
-                    code.appendLeft(this.end, ')');
+                    code.prependRight(this.start, `(${getSystemExportFunctionLeft(systemPatternExports, true, options)}`);
+                    code.appendLeft(this.end, '))');
                 }
             }
         }
@@ -6240,7 +6276,7 @@ class AwaitExpression extends NodeBase {
             checkTopLevelAwait: if (!this.context.usesTopLevelAwait) {
                 let parent = this.parent;
                 do {
-                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression$1)
+                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
                         break checkTopLevelAwait;
                 } while ((parent = parent.parent));
                 this.context.usesTopLevelAwait = true;
@@ -6294,7 +6330,7 @@ class BinaryExpression extends NodeBase {
     hasEffects(context) {
         // support some implicit type coercion runtime errors
         if (this.operator === '+' &&
-            this.parent instanceof ExpressionStatement$1 &&
+            this.parent instanceof ExpressionStatement &&
             this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '')
             return true;
         return super.hasEffects(context);
@@ -6391,7 +6427,7 @@ function getPathIfNotComputed(memberExpression) {
     const nextPathKey = memberExpression.propertyKey;
     const object = memberExpression.object;
     if (typeof nextPathKey === 'string') {
-        if (object instanceof Identifier$1) {
+        if (object instanceof Identifier) {
             return [
                 { key: object.name, pos: object.start },
                 { key: nextPathKey, pos: memberExpression.property.start }
@@ -6543,8 +6579,8 @@ class MemberExpression extends NodeBase {
     initialise() {
         this.propertyKey = getResolvablePropertyKey(this);
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
-        const isCalleeOfDifferentParent = renderedParentType === CallExpression && isCalleeOfRenderedParent;
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = BLANK) {
+        const isCalleeOfDifferentParent = renderedParentType === CallExpression$1 && isCalleeOfRenderedParent;
         if (this.variable || this.replacement) {
             let replacement = this.variable ? this.variable.getName() : this.replacement;
             if (isCalleeOfDifferentParent)
@@ -6558,11 +6594,13 @@ class MemberExpression extends NodeBase {
             if (isCalleeOfDifferentParent) {
                 code.appendRight(this.start, '0, ');
             }
-            super.render(code, options);
+            const surroundingElement = renderedParentType || renderedSurroundingElement;
+            this.object.render(code, options, surroundingElement ? { renderedSurroundingElement: surroundingElement } : BLANK);
+            this.property.render(code, options);
         }
     }
     disallowNamespaceReassignment() {
-        if (this.object instanceof Identifier$1) {
+        if (this.object instanceof Identifier) {
             const variable = this.scope.findVariable(this.object.name);
             if (variable.isNamespace) {
                 if (this.variable) {
@@ -6610,7 +6648,7 @@ class MemberExpression extends NodeBase {
     }
 }
 
-class CallExpression$1 extends NodeBase {
+class CallExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.expressionsToBeDeoptimized = [];
@@ -6619,7 +6657,7 @@ class CallExpression$1 extends NodeBase {
     }
     bind() {
         super.bind();
-        if (this.callee instanceof Identifier$1) {
+        if (this.callee instanceof Identifier) {
             const variable = this.scope.findVariable(this.callee.name);
             if (variable.isNamespace) {
                 this.context.warn({
@@ -6750,7 +6788,7 @@ class CallExpression$1 extends NodeBase {
         if (includeChildrenRecursively) {
             super.include(context, includeChildrenRecursively);
             if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
-                this.callee instanceof Identifier$1 &&
+                this.callee instanceof Identifier &&
                 this.callee.variable) {
                 this.callee.variable.markCalledFromTryStatement();
             }
@@ -6770,8 +6808,9 @@ class CallExpression$1 extends NodeBase {
             withNew: false
         };
     }
-    render(code, options, { renderedParentType } = BLANK) {
-        this.callee.render(code, options);
+    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+        const surroundingELement = renderedParentType || renderedSurroundingElement;
+        this.callee.render(code, options, surroundingELement ? { renderedSurroundingElement: surroundingELement } : BLANK);
         if (this.arguments.length > 0) {
             if (this.arguments[this.arguments.length - 1].included) {
                 for (const arg of this.arguments) {
@@ -6794,11 +6833,6 @@ class CallExpression$1 extends NodeBase {
                 }
             }
         }
-        if (renderedParentType === ExpressionStatement &&
-            this.callee.type === FunctionExpression) {
-            code.appendRight(this.start, '(');
-            code.prependLeft(this.end, ')');
-        }
     }
     getReturnExpression(recursionTracker) {
         if (this.returnExpression === null) {
@@ -6876,6 +6910,14 @@ class ClassBody extends NodeBase {
 }
 
 class ClassExpression extends ClassNode {
+    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+        super.render(code, options);
+        const surroundingElement = renderedParentType || renderedSurroundingElement;
+        if (surroundingElement === ExpressionStatement$1) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
 }
 
 class MultiExpression {
@@ -7042,9 +7084,9 @@ class ConditionalExpression extends NodeBase {
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
         if (!this.test.included) {
             const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
-            const inclusionStart = (this.consequent.included
+            const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
                 ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
-                : colonPos) + 1;
+                : colonPos) + 1);
             if (preventASI) {
                 removeLineBreaks(code, inclusionStart, this.usedBranch.start);
             }
@@ -7159,13 +7201,6 @@ ExportNamedDeclaration.prototype.needsBoundaries = true;
 class ExportSpecifier extends NodeBase {
 }
 
-class FieldDefinition extends NodeBase {
-    hasEffects(context) {
-        return (this.key.hasEffects(context) ||
-            (this.static && this.value !== null && this.value.hasEffects(context)));
-    }
-}
-
 class ForInStatement extends NodeBase {
     bind() {
         this.left.bind();
@@ -7288,7 +7323,15 @@ class ForStatement extends NodeBase {
     }
 }
 
-class FunctionExpression$1 extends FunctionNode {
+class FunctionExpression extends FunctionNode {
+    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
+        super.render(code, options);
+        const surroundingElement = renderedParentType || renderedSurroundingElement;
+        if (surroundingElement === ExpressionStatement$1) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
 }
 
 class TrackingScope extends BlockScope {
@@ -7454,7 +7497,7 @@ class IfStatement extends NodeBase {
             .join(', ');
         if (hoistedVars) {
             const parentType = this.parent.type;
-            const needsBraces = parentType !== Program && parentType !== BlockStatement;
+            const needsBraces = parentType !== Program$1 && parentType !== BlockStatement$1;
             code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVars}; `);
             if (needsBraces) {
                 code.appendLeft(this.end, ` }`);
@@ -7467,7 +7510,7 @@ class IfStatement extends NodeBase {
             if (currentParent instanceof IfStatement && currentParent.alternate) {
                 return true;
             }
-            if (currentParent instanceof BlockStatement$1) {
+            if (currentParent instanceof BlockStatement) {
                 return false;
             }
             currentParent = currentParent.parent;
@@ -7490,7 +7533,7 @@ class ImportDeclaration extends NodeBase {
 }
 ImportDeclaration.prototype.needsBoundaries = true;
 
-class ImportDefaultSpecifier$1 extends NodeBase {
+class ImportDefaultSpecifier extends NodeBase {
 }
 
 class ImportExpression extends NodeBase {
@@ -7632,7 +7675,7 @@ const accessedImportGlobals = {
     system: ['module']
 };
 
-class ImportNamespaceSpecifier$1 extends NodeBase {
+class ImportNamespaceSpecifier extends NodeBase {
 }
 
 class ImportSpecifier extends NodeBase {
@@ -7666,7 +7709,7 @@ class LabeledStatement extends NodeBase {
             this.label.render(code, options);
         }
         else {
-            code.remove(this.start, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1);
+            code.remove(this.start, findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1));
         }
         this.body.render(code, options);
     }
@@ -7778,9 +7821,10 @@ class LogicalExpression extends NodeBase {
         if (!this.left.included || !this.right.included) {
             const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
             if (this.right.included) {
-                code.remove(this.start, operatorPos + 2);
+                const removePos = findNonWhiteSpace(code.original, operatorPos + 2);
+                code.remove(this.start, removePos);
                 if (preventASI) {
-                    removeLineBreaks(code, operatorPos + 2, this.right.start);
+                    removeLineBreaks(code, removePos, this.right.start);
                 }
             }
             else {
@@ -8180,10 +8224,11 @@ class ObjectExpression extends NodeBase {
             return hasMemberEffectWhenCalled(objectMembers, key, this.included, callOptions, context);
         return false;
     }
-    render(code, options, { renderedParentType } = BLANK) {
+    render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
         super.render(code, options);
-        if (renderedParentType === ExpressionStatement ||
-            renderedParentType === ArrowFunctionExpression) {
+        const surroundingElement = renderedParentType || renderedSurroundingElement;
+        if (surroundingElement === ExpressionStatement$1 ||
+            surroundingElement === ArrowFunctionExpression$1) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
@@ -8226,7 +8271,7 @@ class ObjectExpression extends NodeBase {
                 }
                 key = String(keyValue);
             }
-            else if (property.key instanceof Identifier$1) {
+            else if (property.key instanceof Identifier) {
                 key = property.key.name;
             }
             else {
@@ -8258,7 +8303,7 @@ class ObjectExpression extends NodeBase {
 class ObjectPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         for (const property of this.properties) {
-            if (property.type === Property) {
+            if (property.type === Property$1) {
                 property.value.addExportedVariables(variables, exportNamesByVariable);
             }
             else {
@@ -8291,10 +8336,10 @@ class ObjectPattern extends NodeBase {
     }
 }
 
-class PrivateName extends NodeBase {
+class PrivateIdentifier extends NodeBase {
 }
 
-class Program$1 extends NodeBase {
+class Program extends NodeBase {
     constructor() {
         super(...arguments);
         this.hasCachedEffect = false;
@@ -8328,7 +8373,7 @@ class Program$1 extends NodeBase {
     }
 }
 
-class Property$1 extends NodeBase {
+class Property extends NodeBase {
     constructor() {
         super(...arguments);
         this.declarationInit = null;
@@ -8435,7 +8480,14 @@ class Property$1 extends NodeBase {
     }
 }
 
-class ReturnStatement$1 extends NodeBase {
+class PropertyDefinition extends NodeBase {
+    hasEffects(context) {
+        return (this.key.hasEffects(context) ||
+            (this.static && this.value !== null && this.value.hasEffects(context)));
+    }
+}
+
+class ReturnStatement extends NodeBase {
     hasEffects(context) {
         if (!context.ignore.returnAwaitYield ||
             (this.argument !== null && this.argument.hasEffects(context)))
@@ -8638,7 +8690,7 @@ class SwitchStatement extends NodeBase {
 class TaggedTemplateExpression extends NodeBase {
     bind() {
         super.bind();
-        if (this.tag.type === Identifier) {
+        if (this.tag.type === Identifier$1) {
             const name = this.tag.name;
             const variable = this.scope.findVariable(name);
             if (variable.isNamespace) {
@@ -8843,7 +8895,7 @@ class UnaryExpression extends NodeBase {
         return unaryOperators[this.operator](argumentValue);
     }
     hasEffects(context) {
-        if (this.operator === 'typeof' && this.argument instanceof Identifier$1)
+        if (this.operator === 'typeof' && this.argument instanceof Identifier)
             return false;
         return (this.argument.hasEffects(context) ||
             (this.operator === 'delete' &&
@@ -8870,7 +8922,7 @@ class UpdateExpression extends NodeBase {
     bind() {
         super.bind();
         this.argument.deoptimizePath(EMPTY_PATH);
-        if (this.argument instanceof Identifier$1) {
+        if (this.argument instanceof Identifier) {
             const variable = this.scope.findVariable(this.argument.name);
             variable.isReassigned = true;
         }
@@ -8899,7 +8951,7 @@ class UpdateExpression extends NodeBase {
                     }
                 }
                 else if (exportNames.length > 1) {
-                    code.overwrite(this.start, this.end, `${getSystemExportFunctionLeft([variable], false, options)}${this.operator}${name})`);
+                    code.overwrite(this.start, this.end, `(${getSystemExportFunctionLeft([variable], false, options)}${this.operator}${name}))`);
                 }
                 else {
                     let op;
@@ -8921,11 +8973,12 @@ class UpdateExpression extends NodeBase {
 function isReassignedExportsMember(variable, exportNamesByVariable) {
     return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
 }
+
 function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
     for (const declarator of declarations) {
         if (!declarator.id.included)
             return false;
-        if (declarator.id.type === Identifier) {
+        if (declarator.id.type === Identifier$1) {
             if (exportNamesByVariable.has(declarator.id.variable))
                 return false;
         }
@@ -9013,7 +9066,7 @@ class VariableDeclaration extends NodeBase {
             code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
         }
     }
-    renderReplacedDeclarations(code, options, { start = this.start, end = this.end, isNoStatement }) {
+    renderReplacedDeclarations(code, options, { isNoStatement }) {
         const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.declarations, code, this.start + this.kind.length, this.end - (code.original.charCodeAt(this.end - 1) === 59 /*";"*/ ? 1 : 0));
         let actualContentEnd, renderedContentEnd;
         renderedContentEnd = findNonWhiteSpace(code.original, this.start + this.kind.length);
@@ -9024,17 +9077,14 @@ class VariableDeclaration extends NodeBase {
         let separatorString = '', leadingString, nextSeparatorString;
         const systemPatternExports = [];
         for (const { node, start, separator, contentEnd, end } of separatedNodes) {
-            if (!node.included ||
-                (node.id instanceof Identifier$1 &&
-                    isReassignedExportsMember(node.id.variable, options.exportNamesByVariable) &&
-                    node.init === null)) {
+            if (!node.included) {
                 code.remove(start, end);
                 continue;
             }
             leadingString = '';
             nextSeparatorString = '';
             if (!node.id.included ||
-                (node.id instanceof Identifier$1 &&
+                (node.id instanceof Identifier &&
                     isReassignedExportsMember(node.id.variable, options.exportNamesByVariable))) {
                 if (hasRenderedContent) {
                     separatorString += ';';
@@ -9043,7 +9093,7 @@ class VariableDeclaration extends NodeBase {
             }
             else {
                 if (options.format === 'system' && node.init !== null) {
-                    if (node.id.type !== Identifier) {
+                    if (node.id.type !== Identifier$1) {
                         node.id.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
                     }
                     else {
@@ -9083,12 +9133,7 @@ class VariableDeclaration extends NodeBase {
             lastSeparatorPos = separator;
             separatorString = nextSeparatorString;
         }
-        if (hasRenderedContent) {
-            this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options, isNoStatement);
-        }
-        else {
-            code.remove(start, end);
-        }
+        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options, isNoStatement);
     }
 }
 
@@ -9121,7 +9166,12 @@ 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 });
+            this.init.render(code, options, renderId ? BLANK : { renderedParentType: ExpressionStatement$1 });
+        }
+        else if (this.id instanceof Identifier &&
+            isReassignedExportsMember(this.id.variable, options.exportNamesByVariable)) {
+            const _ = options.compact ? '' : ' ';
+            code.appendLeft(this.end, `${_}=${_}void 0`);
         }
     }
 }
@@ -9173,14 +9223,14 @@ class YieldExpression extends NodeBase {
 const nodeConstructors = {
     ArrayExpression,
     ArrayPattern,
-    ArrowFunctionExpression: ArrowFunctionExpression$1,
+    ArrowFunctionExpression,
     AssignmentExpression,
     AssignmentPattern,
     AwaitExpression,
     BinaryExpression,
-    BlockStatement: BlockStatement$1,
+    BlockStatement,
     BreakStatement,
-    CallExpression: CallExpression$1,
+    CallExpression,
     CatchClause,
     ChainExpression,
     ClassBody,
@@ -9194,19 +9244,18 @@ const nodeConstructors = {
     ExportDefaultDeclaration,
     ExportNamedDeclaration,
     ExportSpecifier,
-    ExpressionStatement: ExpressionStatement$1,
-    FieldDefinition,
+    ExpressionStatement,
     ForInStatement,
     ForOfStatement,
     ForStatement,
     FunctionDeclaration,
-    FunctionExpression: FunctionExpression$1,
-    Identifier: Identifier$1,
+    FunctionExpression,
+    Identifier,
     IfStatement,
     ImportDeclaration,
-    ImportDefaultSpecifier: ImportDefaultSpecifier$1,
+    ImportDefaultSpecifier,
     ImportExpression,
-    ImportNamespaceSpecifier: ImportNamespaceSpecifier$1,
+    ImportNamespaceSpecifier,
     ImportSpecifier,
     LabeledStatement,
     Literal,
@@ -9217,11 +9266,12 @@ const nodeConstructors = {
     NewExpression,
     ObjectExpression,
     ObjectPattern,
-    PrivateName,
-    Program: Program$1,
-    Property: Property$1,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
     RestElement,
-    ReturnStatement: ReturnStatement$1,
+    ReturnStatement,
     SequenceExpression,
     SpreadElement,
     Super,
@@ -9283,9 +9333,9 @@ function ignore(_node, _st, _c) {}
 
 // Node walkers.
 
-var base$1 = {};
+var base = {};
 
-base$1.Program = base$1.BlockStatement = function (node, st, c) {
+base.Program = base.BlockStatement = function (node, st, c) {
   for (var i = 0, list = node.body; i < list.length; i += 1)
     {
     var stmt = list[i];
@@ -9293,22 +9343,22 @@ base$1.Program = base$1.BlockStatement = function (node, st, c) {
     c(stmt, st, "Statement");
   }
 };
-base$1.Statement = skipThrough;
-base$1.EmptyStatement = ignore;
-base$1.ExpressionStatement = base$1.ParenthesizedExpression = base$1.ChainExpression =
+base.Statement = skipThrough;
+base.EmptyStatement = ignore;
+base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
   function (node, st, c) { return c(node.expression, st, "Expression"); };
-base$1.IfStatement = function (node, st, c) {
+base.IfStatement = function (node, st, c) {
   c(node.test, st, "Expression");
   c(node.consequent, st, "Statement");
   if (node.alternate) { c(node.alternate, st, "Statement"); }
 };
-base$1.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
-base$1.BreakStatement = base$1.ContinueStatement = ignore;
-base$1.WithStatement = function (node, st, c) {
+base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
+base.BreakStatement = base.ContinueStatement = ignore;
+base.WithStatement = function (node, st, c) {
   c(node.object, st, "Expression");
   c(node.body, st, "Statement");
 };
-base$1.SwitchStatement = function (node, st, c) {
+base.SwitchStatement = function (node, st, c) {
   c(node.discriminant, st, "Expression");
   for (var i$1 = 0, list$1 = node.cases; i$1 < list$1.length; i$1 += 1) {
     var cs = list$1[i$1];
@@ -9322,7 +9372,7 @@ base$1.SwitchStatement = function (node, st, c) {
     }
   }
 };
-base$1.SwitchCase = function (node, st, c) {
+base.SwitchCase = function (node, st, c) {
   if (node.test) { c(node.test, st, "Expression"); }
   for (var i = 0, list = node.consequent; i < list.length; i += 1)
     {
@@ -9331,43 +9381,43 @@ base$1.SwitchCase = function (node, st, c) {
     c(cons, st, "Statement");
   }
 };
-base$1.ReturnStatement = base$1.YieldExpression = base$1.AwaitExpression = function (node, st, c) {
+base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
   if (node.argument) { c(node.argument, st, "Expression"); }
 };
-base$1.ThrowStatement = base$1.SpreadElement =
+base.ThrowStatement = base.SpreadElement =
   function (node, st, c) { return c(node.argument, st, "Expression"); };
-base$1.TryStatement = function (node, st, c) {
+base.TryStatement = function (node, st, c) {
   c(node.block, st, "Statement");
   if (node.handler) { c(node.handler, st); }
   if (node.finalizer) { c(node.finalizer, st, "Statement"); }
 };
-base$1.CatchClause = function (node, st, c) {
+base.CatchClause = function (node, st, c) {
   if (node.param) { c(node.param, st, "Pattern"); }
   c(node.body, st, "Statement");
 };
-base$1.WhileStatement = base$1.DoWhileStatement = function (node, st, c) {
+base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
   c(node.test, st, "Expression");
   c(node.body, st, "Statement");
 };
-base$1.ForStatement = function (node, st, c) {
+base.ForStatement = function (node, st, c) {
   if (node.init) { c(node.init, st, "ForInit"); }
   if (node.test) { c(node.test, st, "Expression"); }
   if (node.update) { c(node.update, st, "Expression"); }
   c(node.body, st, "Statement");
 };
-base$1.ForInStatement = base$1.ForOfStatement = function (node, st, c) {
+base.ForInStatement = base.ForOfStatement = function (node, st, c) {
   c(node.left, st, "ForInit");
   c(node.right, st, "Expression");
   c(node.body, st, "Statement");
 };
-base$1.ForInit = function (node, st, c) {
+base.ForInit = function (node, st, c) {
   if (node.type === "VariableDeclaration") { c(node, st); }
   else { c(node, st, "Expression"); }
 };
-base$1.DebuggerStatement = ignore;
+base.DebuggerStatement = ignore;
 
-base$1.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
-base$1.VariableDeclaration = function (node, st, c) {
+base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
+base.VariableDeclaration = function (node, st, c) {
   for (var i = 0, list = node.declarations; i < list.length; i += 1)
     {
     var decl = list[i];
@@ -9375,12 +9425,12 @@ base$1.VariableDeclaration = function (node, st, c) {
     c(decl, st);
   }
 };
-base$1.VariableDeclarator = function (node, st, c) {
+base.VariableDeclarator = function (node, st, c) {
   c(node.id, st, "Pattern");
   if (node.init) { c(node.init, st, "Expression"); }
 };
 
-base$1.Function = function (node, st, c) {
+base.Function = function (node, st, c) {
   if (node.id) { c(node.id, st, "Pattern"); }
   for (var i = 0, list = node.params; i < list.length; i += 1)
     {
@@ -9391,7 +9441,7 @@ base$1.Function = function (node, st, c) {
   c(node.body, st, node.expression ? "Expression" : "Statement");
 };
 
-base$1.Pattern = function (node, st, c) {
+base.Pattern = function (node, st, c) {
   if (node.type === "Identifier")
     { c(node, st, "VariablePattern"); }
   else if (node.type === "MemberExpression")
@@ -9399,17 +9449,17 @@ base$1.Pattern = function (node, st, c) {
   else
     { c(node, st); }
 };
-base$1.VariablePattern = ignore;
-base$1.MemberPattern = skipThrough;
-base$1.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
-base$1.ArrayPattern = function (node, st, c) {
+base.VariablePattern = ignore;
+base.MemberPattern = skipThrough;
+base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
+base.ArrayPattern = function (node, st, c) {
   for (var i = 0, list = node.elements; i < list.length; i += 1) {
     var elt = list[i];
 
     if (elt) { c(elt, st, "Pattern"); }
   }
 };
-base$1.ObjectPattern = function (node, st, c) {
+base.ObjectPattern = function (node, st, c) {
   for (var i = 0, list = node.properties; i < list.length; i += 1) {
     var prop = list[i];
 
@@ -9422,16 +9472,16 @@ base$1.ObjectPattern = function (node, st, c) {
   }
 };
 
-base$1.Expression = skipThrough;
-base$1.ThisExpression = base$1.Super = base$1.MetaProperty = ignore;
-base$1.ArrayExpression = function (node, st, c) {
+base.Expression = skipThrough;
+base.ThisExpression = base.Super = base.MetaProperty = ignore;
+base.ArrayExpression = function (node, st, c) {
   for (var i = 0, list = node.elements; i < list.length; i += 1) {
     var elt = list[i];
 
     if (elt) { c(elt, st, "Expression"); }
   }
 };
-base$1.ObjectExpression = function (node, st, c) {
+base.ObjectExpression = function (node, st, c) {
   for (var i = 0, list = node.properties; i < list.length; i += 1)
     {
     var prop = list[i];
@@ -9439,8 +9489,8 @@ base$1.ObjectExpression = function (node, st, c) {
     c(prop, st);
   }
 };
-base$1.FunctionExpression = base$1.ArrowFunctionExpression = base$1.FunctionDeclaration;
-base$1.SequenceExpression = function (node, st, c) {
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
+base.SequenceExpression = function (node, st, c) {
   for (var i = 0, list = node.expressions; i < list.length; i += 1)
     {
     var expr = list[i];
@@ -9448,7 +9498,7 @@ base$1.SequenceExpression = function (node, st, c) {
     c(expr, st, "Expression");
   }
 };
-base$1.TemplateLiteral = function (node, st, c) {
+base.TemplateLiteral = function (node, st, c) {
   for (var i = 0, list = node.quasis; i < list.length; i += 1)
     {
     var quasi = list[i];
@@ -9463,24 +9513,24 @@ base$1.TemplateLiteral = function (node, st, c) {
     c(expr, st, "Expression");
   }
 };
-base$1.TemplateElement = ignore;
-base$1.UnaryExpression = base$1.UpdateExpression = function (node, st, c) {
+base.TemplateElement = ignore;
+base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
   c(node.argument, st, "Expression");
 };
-base$1.BinaryExpression = base$1.LogicalExpression = function (node, st, c) {
+base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
   c(node.left, st, "Expression");
   c(node.right, st, "Expression");
 };
-base$1.AssignmentExpression = base$1.AssignmentPattern = function (node, st, c) {
+base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
   c(node.left, st, "Pattern");
   c(node.right, st, "Expression");
 };
-base$1.ConditionalExpression = function (node, st, c) {
+base.ConditionalExpression = function (node, st, c) {
   c(node.test, st, "Expression");
   c(node.consequent, st, "Expression");
   c(node.alternate, st, "Expression");
 };
-base$1.NewExpression = base$1.CallExpression = function (node, st, c) {
+base.NewExpression = base.CallExpression = function (node, st, c) {
   c(node.callee, st, "Expression");
   if (node.arguments)
     { for (var i = 0, list = node.arguments; i < list.length; i += 1)
@@ -9490,21 +9540,21 @@ base$1.NewExpression = base$1.CallExpression = function (node, st, c) {
         c(arg, st, "Expression");
       } }
 };
-base$1.MemberExpression = function (node, st, c) {
+base.MemberExpression = function (node, st, c) {
   c(node.object, st, "Expression");
   if (node.computed) { c(node.property, st, "Expression"); }
 };
-base$1.ExportNamedDeclaration = base$1.ExportDefaultDeclaration = function (node, st, c) {
+base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
   if (node.declaration)
     { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
   if (node.source) { c(node.source, st, "Expression"); }
 };
-base$1.ExportAllDeclaration = function (node, st, c) {
+base.ExportAllDeclaration = function (node, st, c) {
   if (node.exported)
     { c(node.exported, st); }
   c(node.source, st, "Expression");
 };
-base$1.ImportDeclaration = function (node, st, c) {
+base.ImportDeclaration = function (node, st, c) {
   for (var i = 0, list = node.specifiers; i < list.length; i += 1)
     {
     var spec = list[i];
@@ -9513,22 +9563,22 @@ base$1.ImportDeclaration = function (node, st, c) {
   }
   c(node.source, st, "Expression");
 };
-base$1.ImportExpression = function (node, st, c) {
+base.ImportExpression = function (node, st, c) {
   c(node.source, st, "Expression");
 };
-base$1.ImportSpecifier = base$1.ImportDefaultSpecifier = base$1.ImportNamespaceSpecifier = base$1.Identifier = base$1.Literal = ignore;
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;
 
-base$1.TaggedTemplateExpression = function (node, st, c) {
+base.TaggedTemplateExpression = function (node, st, c) {
   c(node.tag, st, "Expression");
   c(node.quasi, st, "Expression");
 };
-base$1.ClassDeclaration = base$1.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
-base$1.Class = function (node, st, c) {
+base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
+base.Class = function (node, st, c) {
   if (node.id) { c(node.id, st, "Pattern"); }
   if (node.superClass) { c(node.superClass, st, "Expression"); }
   c(node.body, st);
 };
-base$1.ClassBody = function (node, st, c) {
+base.ClassBody = function (node, st, c) {
   for (var i = 0, list = node.body; i < list.length; i += 1)
     {
     var elt = list[i];
@@ -9536,14 +9586,13 @@ base$1.ClassBody = function (node, st, c) {
     c(elt, st);
   }
 };
-base$1.MethodDefinition = base$1.Property = function (node, st, c) {
+base.MethodDefinition = base.Property = function (node, st, c) {
   if (node.computed) { c(node.key, st, "Expression"); }
   c(node.value, st, "Expression");
 };
 
-// @ts-ignore
 // patch up acorn-walk until class-fields are officially supported
-base$1.FieldDefinition = function (node, st, c) {
+base.PropertyDefinition = function (node, st, c) {
     if (node.computed) {
         c(node.key, st, 'Expression');
     }
@@ -9558,7 +9607,7 @@ function handlePureAnnotationsOfNode(node, state, type = node.type) {
         commentNode = state.commentNodes[++state.commentIndex];
     }
     if (commentNode && commentNode.end <= node.end) {
-        base$1[type](node, state, handlePureAnnotationsOfNode);
+        base[type](node, state, handlePureAnnotationsOfNode);
     }
 }
 function markPureNode(node, comment) {
@@ -9568,10 +9617,10 @@ function markPureNode(node, comment) {
     else {
         node.annotations = [comment];
     }
-    if (node.type === 'ExpressionStatement') {
+    if (node.type === ExpressionStatement$1) {
         node = node.expression;
     }
-    if (node.type === 'CallExpression' || node.type === 'NewExpression') {
+    if (node.type === CallExpression$1 || node.type === NewExpression$1) {
         node.annotatedPure = true;
     }
 }
@@ -10230,7 +10279,7 @@ class Module {
         };
         this.scope = new ModuleScope(this.graph.scope, this.astContext);
         this.namespace = new NamespaceVariable(this.astContext, this.info.syntheticNamedExports);
-        this.ast = new Program$1(ast, { type: 'Module', context: this.astContext }, this.scope);
+        this.ast = new Program(ast, { type: 'Module', context: this.astContext }, this.scope);
         this.info.ast = ast;
         timeEnd('analyse ast', 3);
     }
@@ -10369,8 +10418,8 @@ class Module {
         const source = node.source.value;
         this.sources.add(source);
         for (const specifier of node.specifiers) {
-            const isDefault = specifier.type === ImportDefaultSpecifier;
-            const isNamespace = specifier.type === ImportNamespaceSpecifier;
+            const isDefault = specifier.type === ImportDefaultSpecifier$1;
+            const isNamespace = specifier.type === ImportNamespaceSpecifier$1;
             const name = isDefault
                 ? 'default'
                 : isNamespace
@@ -10691,12 +10740,13 @@ const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
     umd: deconflictImportsOther
 };
 function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
-    for (const module of modules) {
+    const reversedModules = modules.slice().reverse();
+    for (const module of reversedModules) {
         module.scope.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
     }
-    deconflictTopLevelVariables(usedNames, modules, includedNamespaces);
+    deconflictTopLevelVariables(usedNames, reversedModules, includedNamespaces);
     DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](usedNames, imports, dependenciesToBeDeconflicted, interop, preserveModules, externalLiveBindings, chunkByModule, syntheticExports);
-    for (const module of modules) {
+    for (const module of reversedModules) {
         module.scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
     }
 }
@@ -11021,7 +11071,7 @@ function getGlobalName(module, globals, hasExports, warn) {
         return module.variableName;
     }
 }
-class Chunk$1 {
+class Chunk {
     constructor(orderedModules, inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, manualChunkAlias) {
         this.orderedModules = orderedModules;
         this.inputOptions = inputOptions;
@@ -11092,7 +11142,7 @@ class Chunk$1 {
         this.suggestedVariableName = makeLegal(this.generateVariableName());
     }
     static generateFacade(inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, facadedModule, facadeName) {
-        const chunk = new Chunk$1([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, null);
+        const chunk = new Chunk([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, null);
         chunk.assignFacadeName(facadeName, facadedModule);
         if (!facadeChunkByModule.has(facadedModule)) {
             facadeChunkByModule.set(facadedModule, chunk);
@@ -11197,7 +11247,7 @@ class Chunk$1 {
                 }
             }
             for (const facadeName of requiredFacades) {
-                facades.push(Chunk$1.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName));
+                facades.push(Chunk.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName));
             }
         }
         for (const module of this.dynamicEntryModules) {
@@ -11338,7 +11388,7 @@ class Chunk$1 {
     }
     // prerender allows chunk hashes and names to be generated before finalizing
     preRender(options, inputBase) {
-        const magicString = new Bundle({ separator: options.compact ? '' : '\n\n' });
+        const magicString = new Bundle$1({ separator: options.compact ? '' : '\n\n' });
         this.usedModules = [];
         this.indentString = getIndentString(this.orderedModules, options);
         const n = options.compact ? '' : '\n';
@@ -11359,7 +11409,7 @@ class Chunk$1 {
             !this.outputOptions.preserveModules &&
             this.facadeModule !== null) {
             for (const dep of this.dependencies) {
-                if (dep instanceof Chunk$1)
+                if (dep instanceof Chunk)
                     this.inlineChunkDependencies(dep);
             }
         }
@@ -11671,7 +11721,7 @@ class Chunk$1 {
                     getGlobalName(dep, options.globals, (imports || reexports) !== null, this.inputOptions.onwarn)),
                 id: undefined,
                 imports,
-                isChunk: dep instanceof Chunk$1,
+                isChunk: dep instanceof Chunk,
                 name: dep.variableName,
                 namedExportsMode,
                 namespaceVariableName: dep.namespaceVariableName,
@@ -11893,7 +11943,7 @@ class Chunk$1 {
             if (this.dependencies.has(dep))
                 continue;
             this.dependencies.add(dep);
-            if (dep instanceof Chunk$1) {
+            if (dep instanceof Chunk) {
                 this.inlineChunkDependencies(dep);
             }
         }
@@ -11930,7 +11980,7 @@ class Chunk$1 {
             }
         }
     }
-    setIdentifierRenderResolutions({ format, interop }) {
+    setIdentifierRenderResolutions({ format, interop, namespaceToStringTag }) {
         const syntheticExports = new Set();
         for (const exportName of this.getExportNames()) {
             const exportVariable = this.exportsByName[exportName];
@@ -11950,10 +12000,13 @@ class Chunk$1 {
                 exportVariable.setRenderNames(null, null);
             }
         }
-        const usedNames = new Set();
+        const usedNames = new Set(['Object', 'Promise']);
         if (this.needsExportsShim) {
             usedNames.add(MISSING_EXPORT_SHIM_VARIABLE);
         }
+        if (namespaceToStringTag) {
+            usedNames.add('Symbol');
+        }
         switch (format) {
             case 'system':
                 usedNames.add('module').add('exports');
@@ -12510,7 +12563,7 @@ function areSourcesEqual(sourceA, sourceB) {
     return true;
 }
 
-class Bundle$1 {
+class Bundle {
     constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
         this.outputOptions = outputOptions;
         this.unsetOptions = unsetOptions;
@@ -12623,6 +12676,17 @@ class Bundle$1 {
                 warnDeprecation('A plugin is directly adding properties to the bundle object in the "generateBundle" hook. This is deprecated and will be removed in a future Rollup version, please use "this.emitFile" instead.', true, this.inputOptions);
                 file.type = 'asset';
             }
+            if (this.outputOptions.validate && typeof file.code == 'string') {
+                try {
+                    this.graph.contextParse(file.code, {
+                        allowHashBang: true,
+                        ecmaVersion: 'latest'
+                    });
+                }
+                catch (exception) {
+                    this.inputOptions.onwarn(errChunkInvalid(file, exception));
+                }
+            }
         }
         this.pluginDriver.finaliseAssets();
     }
@@ -12642,7 +12706,7 @@ class Bundle$1 {
                 }))
                 : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry)) {
             sortByExecutionOrder(modules);
-            const chunk = new Chunk$1(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias);
+            const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias);
             chunks.push(chunk);
             for (const module of modules) {
                 chunkByModule.set(module, chunk);
@@ -12714,7 +12778,7 @@ function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
 
 // Reserved word lists for various dialects of the language
 
-var reservedWords$1 = {
+var reservedWords = {
   3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
   5: "class enum extends super const export import",
   6: "enum",
@@ -12969,7 +13033,7 @@ var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 
 var ref = Object.prototype;
 var hasOwnProperty = ref.hasOwnProperty;
-var toString$1 = ref.toString;
+var toString = ref.toString;
 
 // Checks if an object has a property.
 
@@ -12978,7 +13042,7 @@ function has(obj, propName) {
 }
 
 var isArray = Array.isArray || (function (obj) { return (
-  toString$1.call(obj) === "[object Array]"
+  toString.call(obj) === "[object Array]"
 ); });
 
 function wordsRegexp(words) {
@@ -13192,13 +13256,13 @@ var Parser = function Parser(options, input, startPos) {
   this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
   var reserved = "";
   if (options.allowReserved !== true) {
-    reserved = reservedWords$1[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
+    reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
     if (options.sourceType === "module") { reserved += " await"; }
   }
   this.reservedWords = wordsRegexp(reserved);
-  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords$1.strict;
+  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
   this.reservedWordsStrict = wordsRegexp(reservedStrict);
-  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords$1.strictBind);
+  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
   this.input = String(input);
 
   // Used to signal to callers of `readWord1` whether the word
@@ -13251,7 +13315,7 @@ var Parser = function Parser(options, input, startPos) {
   // Labels in scope.
   this.labels = [];
   // Thus-far undefined exports.
-  this.undefinedExports = {};
+  this.undefinedExports = Object.create(null);
 
   // If enabled, skip leading hashbang line.
   if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
@@ -13465,7 +13529,7 @@ var pp$1 = Parser.prototype;
 // to its body instead of creating a new node.
 
 pp$1.parseTopLevel = function(node) {
-  var exports = {};
+  var exports = Object.create(null);
   if (!node.body) { node.body = []; }
   while (this.type !== types.eof) {
     var stmt = this.parseStatement(null, true, exports);
@@ -15591,7 +15655,7 @@ pp$3.isSimpleParamList = function(params) {
 // or "arguments" and duplicate parameters.
 
 pp$3.checkParams = function(node, allowDuplicates) {
-  var nameHash = {};
+  var nameHash = Object.create(null);
   for (var i = 0, list = node.params; i < list.length; i += 1)
     {
     var param = list[i];
@@ -15734,7 +15798,7 @@ pp$4.curPosition = function() {
 
 var pp$5 = Parser.prototype;
 
-var Scope$1 = function Scope(flags) {
+var Scope = function Scope(flags) {
   this.flags = flags;
   // A list of var-declared names in the current lexical scope
   this.var = [];
@@ -15747,7 +15811,7 @@ var Scope$1 = function Scope(flags) {
 // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
 
 pp$5.enterScope = function(flags) {
-  this.scopeStack.push(new Scope$1(flags));
+  this.scopeStack.push(new Scope(flags));
 };
 
 pp$5.exitScope = function() {
@@ -17921,11 +17985,11 @@ pp$9.readWord = function() {
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version$1 = "8.0.4";
+var version = "8.0.5";
 
 Parser.acorn = {
   Parser: Parser,
-  version: version$1,
+  version: version,
   defaultOptions: defaultOptions,
   Position: Position,
   SourceLocation: SourceLocation,
@@ -17994,10 +18058,10 @@ var acorn = {
   tokContexts: types$1,
   tokTypes: types,
   tokenizer: tokenizer,
-  version: version$1
+  version: version
 };
 
-class GlobalScope extends Scope {
+class GlobalScope extends Scope$1 {
     constructor() {
         super();
         this.variables.set('undefined', new UndefinedVariable());
@@ -18719,7 +18783,7 @@ function getPluginContexts(pluginCache, graph, options, fileEmitter) {
             getWatchFiles: () => Object.keys(graph.watchFiles),
             isExternal: getDeprecatedContextHandler((id, parentId, isResolved = false) => options.external(id, parentId, isResolved), 'isExternal', 'resolve', plugin.name, true, options),
             meta: {
-                rollupVersion: version,
+                rollupVersion: version$1,
                 watchMode: graph.watchMode
             },
             get moduleIds() {
@@ -19165,19 +19229,14 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(acorn);
+var require$$1 = /*@__PURE__*/getAugmentedNamespace(acorn);
 
 const getPrototype = Object.getPrototypeOf || (o => o.__proto__);
 
-const getAcorn = Parser => {
+const getAcorn$1 = Parser => {
   if (Parser.acorn) return Parser.acorn
 
-  const acorn = require$$0;
+  const acorn = require$$1;
 
   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}`)
@@ -19199,7 +19258,7 @@ var acornPrivateClassElements = function(Parser) {
     return Parser
   }
 
-  const acorn = getAcorn(Parser);
+  const acorn = getAcorn$1(Parser);
 
   Parser = class extends Parser {
     _branch() {
@@ -19230,7 +19289,7 @@ var acornPrivateClassElements = function(Parser) {
       const node = this.startNode();
       node.name = this.value;
       this.next();
-      this.finishNode(node, "PrivateName");
+      this.finishNode(node, "PrivateIdentifier");
       if (this.options.allowReserved == "never") this.checkUnreserved(node);
       return node
     }
@@ -19240,7 +19299,7 @@ var acornPrivateClassElements = function(Parser) {
       if (code === 35) {
         ++this.pos;
         const word = this.readWord1();
-        return this.finishToken(this.privateNameToken, word)
+        return this.finishToken(this.privateIdentifierToken, word)
       }
       return super.getTokenFromCode(code)
     }
@@ -19289,7 +19348,7 @@ var acornPrivateClassElements = function(Parser) {
       const branch = this._branch();
       if (!(
         (branch.eat(acorn.tokTypes.dot) || (optionalSupported && branch.eat(acorn.tokTypes.questionDot))) &&
-        branch.type == this.privateNameToken
+        branch.type == this.privateIdentifierToken
       )) {
         return super.parseSubscript.apply(this, arguments)
       }
@@ -19304,7 +19363,7 @@ var acornPrivateClassElements = function(Parser) {
       if (optionalSupported) {
         node.optional = optional;
       }
-      if (this.type == this.privateNameToken) {
+      if (this.type == this.privateIdentifierToken) {
         if (base.type == "Super") {
           this.raise(this.start, "Cannot access private element on super");
         }
@@ -19325,22 +19384,24 @@ var acornPrivateClassElements = function(Parser) {
     parseMaybeUnary(refDestructuringErrors, sawUnary) {
       const _return = super.parseMaybeUnary(refDestructuringErrors, sawUnary);
       if (_return.operator == "delete") {
-        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateName") {
+        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateIdentifier") {
           this.raise(_return.start, "Private elements may not be deleted");
         }
       }
       return _return
     }
   };
-  Parser.prototype.privateNameToken = new acorn.TokenType("privateName");
+  Parser.prototype.privateIdentifierToken = new acorn.TokenType("privateIdentifier");
   return Parser
 };
 
+const privateClassElements$1 = acornPrivateClassElements;
+
 var acornClassFields = function(Parser) {
-  const acorn = Parser.acorn || require$$0;
+  const acorn = Parser.acorn || require$$1;
   const tt = acorn.tokTypes;
 
-  Parser = acornPrivateClassElements(Parser);
+  Parser = privateClassElements$1(Parser);
   return class extends Parser {
     _maybeParseFieldValue(field) {
       if (this.eat(tt.eq)) {
@@ -19355,7 +19416,7 @@ var acornClassFields = function(Parser) {
 
     // Parse fields
     parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type.keyword || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string || this.type == tt.num)) {
+      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type.keyword || this.type == this.privateIdentifierToken || this.type == tt.bracketL || this.type == tt.string || this.type == tt.num)) {
         const branch = this._branch();
         if (branch.type == tt.bracketL) {
           let count = 0;
@@ -19371,7 +19432,7 @@ var acornClassFields = function(Parser) {
         }
         if (isField) {
           const node = this.startNode();
-          if (this.type == this.privateNameToken) {
+          if (this.type == this.privateIdentifierToken) {
             this.parsePrivateClassElementName(node);
           } else {
             this.parsePropertyName(node);
@@ -19383,7 +19444,7 @@ var acornClassFields = function(Parser) {
           this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
           this._maybeParseFieldValue(node);
           this.exitScope();
-          this.finishNode(node, "FieldDefinition");
+          this.finishNode(node, "PropertyDefinition");
           this.semicolon();
           return node
         }
@@ -19401,10 +19462,12 @@ var acornClassFields = function(Parser) {
   }
 };
 
+const privateClassElements = acornPrivateClassElements;
+
 var acornStaticClassFeatures = function(Parser) {
-  const ExtendedParser = acornPrivateClassElements(Parser);
+  const ExtendedParser = privateClassElements(Parser);
 
-  const acorn = Parser.acorn || require$$0;
+  const acorn = Parser.acorn || require$$1;
   const tt = acorn.tokTypes;
 
   return class extends ExtendedParser {
@@ -19425,7 +19488,7 @@ var acornStaticClassFeatures = function(Parser) {
 
       const branch = this._branch();
       branch.next();
-      if ([tt.name, tt.bracketL, tt.string, tt.num, this.privateNameToken].indexOf(branch.type) == -1 && !branch.type.keyword) {
+      if ([tt.name, tt.bracketL, tt.string, tt.num, this.privateIdentifierToken].indexOf(branch.type) == -1 && !branch.type.keyword) {
         return super.parseClassElement.apply(this, arguments)
       }
       if (branch.type == tt.bracketL) {
@@ -19442,7 +19505,7 @@ var acornStaticClassFeatures = function(Parser) {
 
       const node = this.startNode();
       node.static = this.eatContextual("static");
-      if (this.type == this.privateNameToken) {
+      if (this.type == this.privateIdentifierToken) {
         this.parsePrivateClassElementName(node);
       } else {
         this.parsePropertyName(node);
@@ -19458,14 +19521,14 @@ var acornStaticClassFeatures = function(Parser) {
       this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
       this._maybeParseFieldValue(node);
       this.exitScope();
-      this.finishNode(node, "FieldDefinition");
+      this.finishNode(node, "PropertyDefinition");
       this.semicolon();
       return node
     }
 
     // Parse private static methods
     parsePropertyName(prop) {
-      if (prop.static && this.type == this.privateNameToken) {
+      if (prop.static && this.type == this.privateIdentifierToken) {
         this.parsePrivateClassElementName(prop);
       } else {
         super.parsePropertyName(prop);
@@ -19508,21 +19571,21 @@ function normalizeInputOptions(config) {
     const onwarn = getOnwarn(config);
     const strictDeprecations = config.strictDeprecations || false;
     const options = {
-        acorn: getAcorn$1(config),
+        acorn: getAcorn(config),
         acornInjectPlugins: getAcornInjectPlugins(config),
         cache: getCache(config),
         context,
         experimentalCacheExpiry: (_b = config.experimentalCacheExpiry) !== null && _b !== void 0 ? _b : 10,
         external: getIdMatcher(config.external),
-        inlineDynamicImports: getInlineDynamicImports(config, onwarn, strictDeprecations),
+        inlineDynamicImports: getInlineDynamicImports$1(config, onwarn, strictDeprecations),
         input: getInput(config),
-        manualChunks: getManualChunks(config, onwarn, strictDeprecations),
+        manualChunks: getManualChunks$1(config, onwarn, strictDeprecations),
         moduleContext: getModuleContext(config, context),
         onwarn,
         perf: config.perf || false,
         plugins: ensureArray(config.plugins),
         preserveEntrySignatures: getPreserveEntrySignatures(config, unsetOptions),
-        preserveModules: getPreserveModules(config, onwarn, strictDeprecations),
+        preserveModules: getPreserveModules$1(config, onwarn, strictDeprecations),
         preserveSymlinks: config.preserveSymlinks || false,
         shimMissingExports: config.shimMissingExports || false,
         strictDeprecations,
@@ -19547,7 +19610,7 @@ const getOnwarn = (config) => {
         }
         : defaultOnWarn;
 };
-const getAcorn$1 = (config) => ({
+const getAcorn = (config) => ({
     allowAwaitOutsideFunction: true,
     ecmaVersion: 'latest',
     preserveParens: false,
@@ -19585,7 +19648,7 @@ const getIdMatcher = (option) => {
     }
     return () => false;
 };
-const getInlineDynamicImports = (config, warn, strictDeprecations) => {
+const getInlineDynamicImports$1 = (config, warn, strictDeprecations) => {
     const configInlineDynamicImports = config.inlineDynamicImports;
     if (configInlineDynamicImports) {
         warnDeprecationWithOptions('The "inlineDynamicImports" option is deprecated. Use the "output.inlineDynamicImports" option instead.', false, warn, strictDeprecations);
@@ -19596,7 +19659,7 @@ const getInput = (config) => {
     const configInput = config.input;
     return configInput == null ? [] : typeof configInput === 'string' ? [configInput] : configInput;
 };
-const getManualChunks = (config, warn, strictDeprecations) => {
+const getManualChunks$1 = (config, warn, strictDeprecations) => {
     const configManualChunks = config.manualChunks;
     if (configManualChunks) {
         warnDeprecationWithOptions('The "manualChunks" option is deprecated. Use the "output.manualChunks" option instead.', false, warn, strictDeprecations);
@@ -19624,7 +19687,7 @@ const getPreserveEntrySignatures = (config, unsetOptions) => {
     }
     return configPreserveEntrySignatures !== null && configPreserveEntrySignatures !== void 0 ? configPreserveEntrySignatures : 'strict';
 };
-const getPreserveModules = (config, warn, strictDeprecations) => {
+const getPreserveModules$1 = (config, warn, strictDeprecations) => {
     const configPreserveModules = config.preserveModules;
     if (configPreserveModules) {
         warnDeprecationWithOptions('The "preserveModules" option is deprecated. Use the "output.preserveModules" option instead.', false, warn, strictDeprecations);
@@ -19684,8 +19747,8 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
     const unsetOptions = new Set(unsetInputOptions);
     const compact = config.compact || false;
     const format = getFormat(config);
-    const inlineDynamicImports = getInlineDynamicImports$1(config, inputOptions);
-    const preserveModules = getPreserveModules$1(config, inlineDynamicImports, inputOptions);
+    const inlineDynamicImports = getInlineDynamicImports(config, inputOptions);
+    const preserveModules = getPreserveModules(config, inlineDynamicImports, inputOptions);
     const file = getFile(config, preserveModules, inputOptions);
     const outputOptions = {
         amd: getAmd(config),
@@ -19710,7 +19773,7 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         inlineDynamicImports,
         interop: getInterop(config, inputOptions),
         intro: getAddon(config, 'intro'),
-        manualChunks: getManualChunks$1(config, inlineDynamicImports, preserveModules, inputOptions),
+        manualChunks: getManualChunks(config, inlineDynamicImports, preserveModules, inputOptions),
         minifyInternalExports: getMinifyInternalExports(config, format, compact),
         name: config.name,
         namespaceToStringTag: config.namespaceToStringTag || false,
@@ -19726,7 +19789,8 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         sourcemapFile: config.sourcemapFile,
         sourcemapPathTransform: config.sourcemapPathTransform,
         strict: (_g = config.strict) !== null && _g !== void 0 ? _g : true,
-        systemNullSetters: config.systemNullSetters || false
+        systemNullSetters: config.systemNullSetters || false,
+        validate: config.validate || false
     };
     warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onwarn);
     return { options: outputOptions, unsetOptions };
@@ -19773,7 +19837,7 @@ const getFormat = (config) => {
             });
     }
 };
-const getInlineDynamicImports$1 = (config, inputOptions) => {
+const getInlineDynamicImports = (config, inputOptions) => {
     var _a;
     const inlineDynamicImports = ((_a = config.inlineDynamicImports) !== null && _a !== void 0 ? _a : inputOptions.inlineDynamicImports) ||
         false;
@@ -19786,7 +19850,7 @@ const getInlineDynamicImports$1 = (config, inputOptions) => {
     }
     return inlineDynamicImports;
 };
-const getPreserveModules$1 = (config, inlineDynamicImports, inputOptions) => {
+const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
     var _a;
     const preserveModules = ((_a = config.preserveModules) !== null && _a !== void 0 ? _a : inputOptions.preserveModules) || false;
     if (preserveModules) {
@@ -19930,7 +19994,7 @@ const getInterop = (config, inputOptions) => {
     }
     return configInterop === undefined ? () => true : () => validateInterop(configInterop);
 };
-const getManualChunks$1 = (config, inlineDynamicImports, preserveModules, inputOptions) => {
+const getManualChunks = (config, inlineDynamicImports, preserveModules, inputOptions) => {
     const configManualChunks = config.manualChunks || inputOptions.manualChunks;
     if (configManualChunks) {
         if (inlineDynamicImports) {
@@ -20014,7 +20078,7 @@ async function getInputOptions(rawInputOptions, watchMode) {
 function applyOptionHook(watchMode) {
     return async (inputOptions, plugin) => {
         if (plugin.options)
-            return (plugin.options.call({ meta: { rollupVersion: version, watchMode } }, await inputOptions) || inputOptions);
+            return (plugin.options.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions) || inputOptions);
         return inputOptions;
     };
 }
@@ -20028,7 +20092,7 @@ function normalizePlugins(plugins, anonymousPrefix) {
 }
 async function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutputOptions, graph) {
     const { options: outputOptions, outputPluginDriver, unsetOptions } = getOutputOptionsAndPluginDriver(rawOutputOptions, graph.pluginDriver, inputOptions, unsetInputOptions);
-    const bundle = new Bundle$1(outputOptions, unsetOptions, inputOptions, outputPluginDriver, graph);
+    const bundle = new Bundle(outputOptions, unsetOptions, inputOptions, outputPluginDriver, graph);
     const generated = await bundle.generate(isWrite);
     if (isWrite) {
         if (!outputOptions.dir && !outputOptions.file) {
@@ -20164,4 +20228,4 @@ function watch(configs) {
     return emitter;
 }
 
-export { createCommonjsModule, defaultOnWarn, ensureArray, fseventsImporter, getAugmentedNamespace, rollup, rollupInternal, version, warnUnknownOptions, watch };
+export { defaultOnWarn, ensureArray, fseventsImporter, getAugmentedNamespace, rollup, rollupInternal, version$1 as version, warnUnknownOptions, watch };