rollup 2.45.1 → 2.48.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.45.1
-	Sat, 10 Apr 2021 05:04:58 GMT - commit 345ae5d7b760fabb35a778bc7379cf862db0b31f
+	Rollup.js v2.48.0
+	Sat, 15 May 2021 04:50:11 GMT - commit 07b3a02069594147665daa95d3fa3e041a82b2d0
 
 
 	https://github.com/rollup/rollup
@@ -14,7 +14,7 @@ import * as fs from 'fs';
 import { lstatSync, realpathSync, readdirSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.45.1";
+var version$1 = "2.48.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -4351,14 +4351,18 @@ class NamespaceVariable extends Variable {
         this.references.push(identifier);
         this.name = identifier.name;
     }
-    // This is only called if "UNKNOWN_PATH" is reassigned as in all other situations, either the
-    // build fails due to an illegal namespace reassignment or MemberExpression already forwards
-    // the reassignment to the right variable. This means we lost track of this variable and thus
-    // need to reassign all exports.
-    deoptimizePath() {
+    deoptimizePath(path) {
+        var _a;
         const memberVariables = this.getMemberVariables();
-        for (const key of Object.keys(memberVariables)) {
-            memberVariables[key].deoptimizePath(UNKNOWN_PATH);
+        const memberPath = path.length <= 1 ? UNKNOWN_PATH : path.slice(1);
+        const key = path[0];
+        if (typeof key === 'string') {
+            (_a = memberVariables[key]) === null || _a === void 0 ? void 0 : _a.deoptimizePath(memberPath);
+        }
+        else {
+            for (const key of Object.keys(memberVariables)) {
+                memberVariables[key].deoptimizePath(memberPath);
+            }
         }
     }
     getMemberVariables() {
@@ -4368,7 +4372,10 @@ class NamespaceVariable extends Variable {
         const memberVariables = Object.create(null);
         for (const name of this.context.getExports().concat(this.context.getReexports())) {
             if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
-                memberVariables[name] = this.context.traceExport(name);
+                const exportedVariable = this.context.traceExport(name);
+                if (exportedVariable) {
+                    memberVariables[name] = exportedVariable;
+                }
             }
         }
         return (this.memberVariables = memberVariables);
@@ -4541,6 +4548,32 @@ function normalize(path) {
     return path.replace(/\\/g, '/');
 }
 
+function printQuotedStringList(list, verbs) {
+    const isSingleItem = list.length <= 1;
+    const quotedList = list.map(item => `"${item}"`);
+    let output = isSingleItem
+        ? quotedList[0]
+        : `${quotedList.slice(0, -1).join(', ')} and ${quotedList.slice(-1)[0]}`;
+    if (verbs) {
+        output += ` ${isSingleItem ? verbs[0] : verbs[1]}`;
+    }
+    return output;
+}
+
+function getAliasName(id) {
+    const base = basename(id);
+    return base.substr(0, base.length - extname(id).length);
+}
+function relativeId(id) {
+    if (!isAbsolute(id))
+        return id;
+    return relative$1(resolve(), id);
+}
+function isPathFragment(name) {
+    // starting with "/", "./", "../", "C:/"
+    return name[0] === '/' || name[0] === '.' && (name[1] === '/' || name[1] === '.') || isAbsolute(name);
+}
+
 class ExternalModule {
     constructor(options, id, hasModuleSideEffects, meta, renormalizeRenderPath) {
         this.options = options;
@@ -4618,17 +4651,20 @@ class ExternalModule {
         });
         if (unused.length === 0)
             return;
-        const names = unused.length === 1
-            ? `'${unused[0]}' is`
-            : `${unused
-                .slice(0, -1)
-                .map(name => `'${name}'`)
-                .join(', ')} and '${unused.slice(-1)}' are`;
+        const importersSet = new Set();
+        for (const name of unused) {
+            const { importers } = this.declarations[name].module;
+            for (const importer of importers) {
+                importersSet.add(importer);
+            }
+        }
+        const importersArray = [...importersSet];
         this.options.onwarn({
             code: 'UNUSED_EXTERNAL_IMPORT',
-            message: `${names} imported from external module '${this.id}' but never used`,
+            message: `${printQuotedStringList(unused, ['is', 'are'])} imported from external module "${this.id}" but never used in ${printQuotedStringList(importersArray.map(importer => relativeId(importer)))}.`,
             names: unused,
-            source: this.id
+            source: this.id,
+            sources: importersArray
         });
     }
 }
@@ -4949,15 +4985,9 @@ function warnOnBuiltins(warn, dependencies) {
     const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins);
     if (!externalBuiltins.length)
         return;
-    const detail = externalBuiltins.length === 1
-        ? `module ('${externalBuiltins[0]}')`
-        : `modules (${externalBuiltins
-            .slice(0, -1)
-            .map(name => `'${name}'`)
-            .join(', ')} and '${externalBuiltins.slice(-1)}')`;
     warn({
         code: 'MISSING_NODE_BUILTINS',
-        message: `Creating a browser bundle that depends on Node.js built-in ${detail}. You might need to include https://github.com/ionic-team/rollup-plugin-node-polyfills`,
+        message: `Creating a browser bundle that depends on Node.js built-in modules (${printQuotedStringList(externalBuiltins)}). You might need to include https://github.com/ionic-team/rollup-plugin-node-polyfills`,
         modules: externalBuiltins
     });
 }
@@ -5192,31 +5222,6 @@ function getCodeFrame(source, line, column) {
         .join('\n');
 }
 
-function sanitizeFileName(name) {
-    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) {
-    const base = basename(id);
-    return base.substr(0, base.length - extname(id).length);
-}
-function relativeId(id) {
-    if (!isAbsolute(id))
-        return id;
-    return relative$1(resolve(), id);
-}
-function isPlainPathFragment(name) {
-    // not starting with "/", "./", "../"
-    return (name[0] !== '/' &&
-        !(name[0] === '.' && (name[1] === '/' || name[1] === '.')) &&
-        sanitizeFileName(name) === name &&
-        !isAbsolute(name));
-}
-
 function error(base) {
     if (!(base instanceof Error))
         base = Object.assign(new Error(base.message), base);
@@ -5265,6 +5270,7 @@ var Errors;
     Errors["MISSING_IMPLICIT_DEPENDANT"] = "MISSING_IMPLICIT_DEPENDANT";
     Errors["MIXED_EXPORTS"] = "MIXED_EXPORTS";
     Errors["NAMESPACE_CONFLICT"] = "NAMESPACE_CONFLICT";
+    Errors["AMBIGUOUS_EXTERNAL_NAMESPACES"] = "AMBIGUOUS_EXTERNAL_NAMESPACES";
     Errors["NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE"] = "NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE";
     Errors["PLUGIN_ERROR"] = "PLUGIN_ERROR";
     Errors["PREFER_NAMED_EXPORTS"] = "PREFER_NAMED_EXPORTS";
@@ -5430,9 +5436,7 @@ function errImplicitDependantIsNotIncluded(module) {
     const implicitDependencies = Array.from(module.implicitlyLoadedBefore, dependency => relativeId(dependency.id)).sort();
     return {
         code: Errors.MISSING_IMPLICIT_DEPENDANT,
-        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before "${implicitDependencies.length === 1
-            ? implicitDependencies[0]
-            : `${implicitDependencies.slice(0, -1).join('", "')}" and "${implicitDependencies.slice(-1)[0]}`}" is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
+        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before ${printQuotedStringList(implicitDependencies)} is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
     };
 }
 function errMixedExport(facadeModuleId, name) {
@@ -5446,12 +5450,21 @@ function errMixedExport(facadeModuleId, name) {
 function errNamespaceConflict(name, reexportingModule, additionalExportAllModule) {
     return {
         code: Errors.NAMESPACE_CONFLICT,
-        message: `Conflicting namespaces: ${relativeId(reexportingModule.id)} re-exports '${name}' from both ${relativeId(reexportingModule.exportsAll[name])} and ${relativeId(additionalExportAllModule.exportsAll[name])} (will be ignored)`,
+        message: `Conflicting namespaces: "${relativeId(reexportingModule.id)}" re-exports "${name}" from both "${relativeId(reexportingModule.exportsAll[name])}" and "${relativeId(additionalExportAllModule.exportsAll[name])}" (will be ignored)`,
         name,
         reexporter: reexportingModule.id,
         sources: [reexportingModule.exportsAll[name], additionalExportAllModule.exportsAll[name]]
     };
 }
+function errAmbiguousExternalNamespaces(name, reexportingModule, usedExternalModule, externalModules) {
+    return {
+        code: Errors.AMBIGUOUS_EXTERNAL_NAMESPACES,
+        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${name}" from one of the external modules ${printQuotedStringList(externalModules.map(module => relativeId(module)))}, guessing "${relativeId(usedExternalModule)}".`,
+        name,
+        reexporter: reexportingModule,
+        sources: externalModules
+    };
+}
 function errNoTransformMapOrAstWithoutCode(pluginName) {
     return {
         code: Errors.NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
@@ -6517,15 +6530,9 @@ class MemberExpression extends NodeBase {
         if (this.variable) {
             this.variable.deoptimizePath(path);
         }
-        else {
-            const propertyKey = this.getPropertyKey();
-            if (propertyKey === UnknownKey) {
-                this.object.deoptimizePath(UNKNOWN_PATH);
-            }
-            else {
-                this.wasPathDeoptimizedWhileOptimized = true;
-                this.object.deoptimizePath([propertyKey, ...path]);
-            }
+        else if (!this.replacement) {
+            this.wasPathDeoptimizedWhileOptimized = true;
+            this.object.deoptimizePath([this.getPropertyKey(), ...path]);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
@@ -6773,7 +6780,8 @@ class CallExpression extends NodeBase {
             if (argument.hasEffects(context))
                 return true;
         }
-        if (this.context.options.treeshake.annotations && ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
+        if (this.context.options.treeshake.annotations &&
+            ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
             return false;
         return (this.callee.hasEffects(context) ||
             this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
@@ -8066,7 +8074,8 @@ class NewExpression extends NodeBase {
             if (argument.hasEffects(context))
                 return true;
         }
-        if (this.context.options.treeshake.annotations && ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
+        if (this.context.options.treeshake.annotations &&
+            ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
             return false;
         return (this.callee.hasEffects(context) ||
             this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
@@ -9523,8 +9532,11 @@ function findSourceMappingURLComments(ast, code) {
         }
         let sourcemappingUrlMatch;
         const interStatmentCode = code.slice(start, end);
-        while (sourcemappingUrlMatch = SOURCEMAPPING_URL_COMMENT_RE.exec(interStatmentCode)) {
-            ret.push([start + sourcemappingUrlMatch.index, start + SOURCEMAPPING_URL_COMMENT_RE.lastIndex]);
+        while ((sourcemappingUrlMatch = SOURCEMAPPING_URL_COMMENT_RE.exec(interStatmentCode))) {
+            ret.push([
+                start + sourcemappingUrlMatch.index,
+                start + SOURCEMAPPING_URL_COMMENT_RE.lastIndex
+            ]);
         }
     };
     let prevStmtEnd = 0;
@@ -9535,7 +9547,7 @@ function findSourceMappingURLComments(ast, code) {
     addCommentsPos(prevStmtEnd, code.length);
     return ret;
 }
-function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map()) {
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map(), skipExternalNamespaceReexports) {
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
@@ -9546,7 +9558,12 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     else {
         searchedNamesAndModules.set(name, new Set([target]));
     }
-    return target.getVariableForExportName(name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules);
+    return target.getVariableForExportName(name, {
+        importerForSideEffects,
+        isExportAllSearch,
+        searchedNamesAndModules,
+        skipExternalNamespaceReexports
+    });
 }
 function getAndExtendSideEffectModules(variable, module) {
     const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, () => new Set());
@@ -9611,6 +9628,7 @@ class Module {
         this.exportAllModules = [];
         this.exportNamesByVariable = null;
         this.exportShimVariable = new ExportShimVariable(this);
+        this.namespaceReexportsByName = Object.create(null);
         this.relevantDependencies = null;
         this.syntheticExports = new Map();
         this.syntheticNamespace = null;
@@ -9702,7 +9720,10 @@ class Module {
             this.implicitlyLoadedAfter.size > 0) {
             dependencyVariables = new Set(dependencyVariables);
             for (const exportName of [...this.getReexports(), ...this.getExports()]) {
-                dependencyVariables.add(this.getVariableForExportName(exportName));
+                const exportedVariable = this.getVariableForExportName(exportName);
+                if (exportedVariable) {
+                    dependencyVariables.add(exportedVariable);
+                }
             }
         }
         for (let variable of dependencyVariables) {
@@ -9807,7 +9828,7 @@ class Module {
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules) {
+    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules, skipExternalNamespaceReexports } = EMPTY_OBJECT) {
         if (name[0] === '*') {
             if (name.length === 1) {
                 // export * from './other'
@@ -9822,7 +9843,7 @@ class Module {
         // export { foo } from './other'
         const reexportDeclaration = this.reexportDescriptions[name];
         if (reexportDeclaration) {
-            const variable = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
+            const variable = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules, false);
             if (!variable) {
                 return this.error(errMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
             }
@@ -9845,20 +9866,11 @@ class Module {
             return variable;
         }
         if (name !== 'default') {
-            let foundSyntheticDeclaration = null;
-            for (const module of this.exportAllModules) {
-                const declaration = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, searchedNamesAndModules);
-                if (declaration) {
-                    if (!(declaration instanceof SyntheticNamedExportVariable)) {
-                        return declaration;
-                    }
-                    if (!foundSyntheticDeclaration) {
-                        foundSyntheticDeclaration = declaration;
-                    }
-                }
-            }
-            if (foundSyntheticDeclaration) {
-                return foundSyntheticDeclaration;
+            const foundNamespaceReexport = name in this.namespaceReexportsByName
+                ? this.namespaceReexportsByName[name]
+                : (this.namespaceReexportsByName[name] = this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules, skipExternalNamespaceReexports));
+            if (foundNamespaceReexport) {
+                return foundNamespaceReexport;
             }
         }
         if (this.info.syntheticNamedExports) {
@@ -9906,12 +9918,14 @@ class Module {
         }
         for (const name of this.getReexports()) {
             const variable = this.getVariableForExportName(name);
-            variable.deoptimizePath(UNKNOWN_PATH);
-            if (!variable.included) {
-                this.includeVariable(variable);
-            }
-            if (variable instanceof ExternalVariable) {
-                variable.module.reexported = true;
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+                if (variable instanceof ExternalVariable) {
+                    variable.module.reexported = true;
+                }
             }
         }
         if (includeNamespaceMembers) {
@@ -10050,7 +10064,9 @@ class Module {
             if (otherModule instanceof Module && importDeclaration.name === '*') {
                 return otherModule.namespace;
             }
-            const declaration = otherModule.getVariableForExportName(importDeclaration.name, importerForSideEffects || this);
+            const declaration = otherModule.getVariableForExportName(importDeclaration.name, {
+                importerForSideEffects: importerForSideEffects || this
+            });
             if (!declaration) {
                 return this.error(errMissingExport(importDeclaration.name, this.id, otherModule.id), importDeclaration.start);
             }
@@ -10248,6 +10264,42 @@ class Module {
         addSideEffectDependencies(this.dependencies);
         addSideEffectDependencies(alwaysCheckedDependencies);
     }
+    getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules, skipExternalNamespaceReexports = false) {
+        let foundSyntheticDeclaration = null;
+        const skipExternalNamespaceValues = new Set([true, skipExternalNamespaceReexports]);
+        for (const skipExternalNamespaces of skipExternalNamespaceValues) {
+            const foundDeclarations = new Set();
+            for (const module of this.exportAllModules) {
+                if (module instanceof Module || !skipExternalNamespaces) {
+                    const declaration = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, searchedNamesAndModules, skipExternalNamespaces);
+                    if (declaration) {
+                        if (!(declaration instanceof SyntheticNamedExportVariable)) {
+                            foundDeclarations.add(declaration);
+                        }
+                        else if (!foundSyntheticDeclaration) {
+                            foundSyntheticDeclaration = declaration;
+                        }
+                    }
+                }
+            }
+            if (foundDeclarations.size === 1) {
+                return [...foundDeclarations][0];
+            }
+            if (foundDeclarations.size > 1) {
+                if (skipExternalNamespaces) {
+                    return null;
+                }
+                const foundDeclarationList = [...foundDeclarations];
+                const usedDeclaration = foundDeclarationList[0];
+                this.options.onwarn(errAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
+                return usedDeclaration;
+            }
+        }
+        if (foundSyntheticDeclaration) {
+            return foundSyntheticDeclaration;
+        }
+        return null;
+    }
     includeAndGetAdditionalMergedNamespaces() {
         const mergedNamespaces = [];
         for (const module of this.exportAllModules) {
@@ -10787,14 +10839,14 @@ function renderChunk({ code, options, outputPluginDriver, renderChunk, sourcemap
 }
 
 function renderNamePattern(pattern, patternName, replacements) {
-    if (!isPlainPathFragment(pattern))
-        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths and must not contain invalid characters.`));
+    if (isPathFragment(pattern))
+        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths.`));
     return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
         if (!replacements.hasOwnProperty(type)) {
             return error(errFailedValidation(`"[${type}]" is not a valid placeholder in "${patternName}" pattern.`));
         }
         const replacement = replacements[type]();
-        if (!isPlainPathFragment(replacement))
+        if (isPathFragment(replacement))
             return error(errFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
         return replacement;
     });
@@ -10849,6 +10901,7 @@ class Chunk {
         this.dependencies = new Set();
         this.dynamicDependencies = new Set();
         this.dynamicEntryModules = [];
+        this.dynamicName = null;
         this.exportNamesByVariable = new Map();
         this.exports = new Set();
         this.exportsByName = Object.create(null);
@@ -11013,7 +11066,7 @@ class Chunk {
                 this.facadeModule = module;
                 this.facadeChunkByModule.set(module, this);
                 this.strictFacade = true;
-                this.assignFacadeName({}, module);
+                this.dynamicName = getChunkNameFromModule(module);
             }
             else if (this.facadeModule === module &&
                 !this.strictFacade &&
@@ -11044,17 +11097,16 @@ class Chunk {
     }
     generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames, unsetOptions) {
         const id = this.orderedModules[0].id;
-        const sanitizedId = sanitizeFileName(id);
+        const sanitizedId = this.outputOptions.sanitizeFileName(id);
         let path;
         if (isAbsolute(id)) {
             const extension = extname(id);
             const pattern = unsetOptions.has('entryFileNames')
-                ? NON_ASSET_EXTENSIONS.includes(extension)
-                    ? '[name].js'
-                    : '[name][extname].js'
+                ? '[name][assetExtname].js'
                 : options.entryFileNames;
             const currentDir = dirname(sanitizedId);
             const fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getChunkInfo()) : pattern, 'output.entryFileNames', {
+                assetExtname: () => NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension,
                 ext: () => extension.substr(1),
                 extname: () => extension,
                 format: () => options.format,
@@ -11103,7 +11155,7 @@ class Chunk {
         });
     }
     getChunkName() {
-        return this.name || (this.name = sanitizeFileName(this.getFallbackChunkName()));
+        return this.name || (this.name = this.outputOptions.sanitizeFileName(this.getFallbackChunkName()));
     }
     getExportNames() {
         return (this.sortedExportNames || (this.sortedExportNames = Object.keys(this.exportsByName).sort()));
@@ -11362,7 +11414,7 @@ class Chunk {
             this.fileName = fileName;
         }
         else {
-            this.name = sanitizeFileName(name || facadedModule.chunkName || getAliasName(facadedModule.id));
+            this.name = this.outputOptions.sanitizeFileName(name || getChunkNameFromModule(facadedModule));
         }
     }
     checkCircularDependencyImport(variable, importingModule) {
@@ -11581,6 +11633,9 @@ class Chunk {
         if (this.manualChunkAlias) {
             return this.manualChunkAlias;
         }
+        if (this.dynamicName) {
+            return this.dynamicName;
+        }
         if (this.fileName) {
             return getAliasName(this.fileName);
         }
@@ -11830,6 +11885,9 @@ class Chunk {
         }
     }
 }
+function getChunkNameFromModule(module) {
+    return module.chunkName || getAliasName(module.id);
+}
 
 const concatSep = (out, next) => (next ? `${out}\n${next}` : out);
 const concatDblSep = (out, next) => (next ? `${out}\n\n${next}` : out);
@@ -12086,11 +12144,11 @@ var BuildPhase;
     BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
 })(BuildPhase || (BuildPhase = {}));
 
-function generateAssetFileName(name, source, output) {
-    const emittedName = name || 'asset';
-    return makeUnique(renderNamePattern(typeof output.assetFileNames === 'function'
-        ? output.assetFileNames({ name, source, type: 'asset' })
-        : output.assetFileNames, 'output.assetFileNames', {
+function generateAssetFileName(name, source, outputOptions, bundle) {
+    const emittedName = outputOptions.sanitizeFileName(name || 'asset');
+    return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
+        ? outputOptions.assetFileNames({ name, source, type: 'asset' })
+        : outputOptions.assetFileNames, 'output.assetFileNames', {
         hash() {
             const hash = createHash();
             hash.update(emittedName);
@@ -12101,7 +12159,7 @@ function generateAssetFileName(name, source, output) {
         ext: () => extname(emittedName).substr(1),
         extname: () => extname(emittedName),
         name: () => emittedName.substr(0, emittedName.length - extname(emittedName).length)
-    }), output.bundle);
+    }), bundle);
 }
 function reserveFileNameInBundle(fileName, bundle, warn) {
     if (fileName in bundle) {
@@ -12119,7 +12177,7 @@ function hasValidType(emittedFile) {
 }
 function hasValidName(emittedFile) {
     const validatedName = emittedFile.fileName || emittedFile.name;
-    return (!validatedName || (typeof validatedName === 'string' && isPlainPathFragment(validatedName)));
+    return !validatedName || typeof validatedName === 'string' && !isPathFragment(validatedName);
 }
 function getValidSource(source, emittedFile, fileReferenceId) {
     if (!(typeof source === 'string' || source instanceof Uint8Array)) {
@@ -12145,8 +12203,9 @@ class FileEmitter {
     constructor(graph, options, baseFileEmitter) {
         this.graph = graph;
         this.options = options;
+        this.bundle = null;
         this.facadeChunkByModule = null;
-        this.output = null;
+        this.outputOptions = null;
         this.assertAssetsFinalized = () => {
             for (const [referenceId, emittedFile] of this.filesByReferenceId.entries()) {
                 if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
@@ -12158,7 +12217,7 @@ class FileEmitter {
                 return error(errFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
             }
             if (!hasValidName(emittedFile)) {
-                return error(errFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths and do not contain invalid characters, received "${emittedFile.fileName || emittedFile.name}".`));
+                return error(errFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
             }
             if (emittedFile.type === 'chunk') {
                 return this.emitChunk(emittedFile);
@@ -12189,27 +12248,25 @@ class FileEmitter {
                 return error(errAssetSourceAlreadySet(consumedFile.name || referenceId));
             }
             const source = getValidSource(requestedSource, consumedFile, referenceId);
-            if (this.output) {
-                this.finalizeAsset(consumedFile, source, referenceId, this.output);
+            if (this.bundle) {
+                this.finalizeAsset(consumedFile, source, referenceId, this.bundle);
             }
             else {
                 consumedFile.source = source;
             }
         };
-        this.setOutputBundle = (outputBundle, assetFileNames, facadeChunkByModule) => {
-            this.output = {
-                assetFileNames,
-                bundle: outputBundle
-            };
+        this.setOutputBundle = (outputBundle, outputOptions, facadeChunkByModule) => {
+            this.outputOptions = outputOptions;
+            this.bundle = outputBundle;
             this.facadeChunkByModule = facadeChunkByModule;
             for (const emittedFile of this.filesByReferenceId.values()) {
                 if (emittedFile.fileName) {
-                    reserveFileNameInBundle(emittedFile.fileName, this.output.bundle, this.options.onwarn);
+                    reserveFileNameInBundle(emittedFile.fileName, this.bundle, this.options.onwarn);
                 }
             }
             for (const [referenceId, consumedFile] of this.filesByReferenceId.entries()) {
                 if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
-                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, this.output);
+                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, this.bundle);
                 }
             }
         };
@@ -12243,12 +12300,12 @@ class FileEmitter {
             type: 'asset'
         };
         const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || emittedAsset.type);
-        if (this.output) {
+        if (this.bundle) {
             if (emittedAsset.fileName) {
-                reserveFileNameInBundle(emittedAsset.fileName, this.output.bundle, this.options.onwarn);
+                reserveFileNameInBundle(emittedAsset.fileName, this.bundle, this.options.onwarn);
             }
             if (source !== undefined) {
-                this.finalizeAsset(consumedAsset, source, referenceId, this.output);
+                this.finalizeAsset(consumedAsset, source, referenceId, this.bundle);
             }
         }
         return referenceId;
@@ -12275,15 +12332,15 @@ class FileEmitter {
         });
         return this.assignReferenceId(consumedChunk, emittedChunk.id);
     }
-    finalizeAsset(consumedFile, source, referenceId, output) {
+    finalizeAsset(consumedFile, source, referenceId, bundle) {
         const fileName = consumedFile.fileName ||
-            findExistingAssetFileNameWithSource(output.bundle, source) ||
-            generateAssetFileName(consumedFile.name, source, output);
+            findExistingAssetFileNameWithSource(bundle, source) ||
+            generateAssetFileName(consumedFile.name, source, this.outputOptions, bundle);
         // We must not modify the original assets to avoid interaction between outputs
         const assetWithFileName = { ...consumedFile, source, fileName };
         this.filesByReferenceId.set(referenceId, assetWithFileName);
         const options = this.options;
-        output.bundle[fileName] = {
+        bundle[fileName] = {
             fileName,
             name: consumedFile.name,
             get isAsset() {
@@ -12337,7 +12394,7 @@ class Bundle {
     async generate(isWrite) {
         timeStart('GENERATE', 1);
         const outputBundle = Object.create(null);
-        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions.assetFileNames, this.facadeChunkByModule);
+        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions, this.facadeChunkByModule);
         try {
             await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
             timeStart('generate chunks', 2);
@@ -12685,6 +12742,7 @@ var types = {
   regexp: new TokenType("regexp", startsExpr),
   string: new TokenType("string", startsExpr),
   name: new TokenType("name", startsExpr),
+  privateId: new TokenType("privateId", startsExpr),
   eof: new TokenType("eof"),
 
   // Punctuation token types.
@@ -12879,7 +12937,8 @@ var defaultOptions = {
   // error.
   allowReturnOutsideFunction: false,
   // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
+  // appearing at the top of the program, and an import.meta expression
+  // in a script isn't considered an error.
   allowImportExportEverywhere: false,
   // When enabled, await identifiers are allowed to appear at the top-level scope,
   // but they are still not allowed in non-async functions.
@@ -13070,6 +13129,7 @@ var Parser = function Parser(options, input, startPos) {
 
   // Used to signify the start of a potential arrow function
   this.potentialArrowAt = -1;
+  this.potentialArrowInForAwait = false;
 
   // Positions to delayed-check that yield/await does not exist in default parameters.
   this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
@@ -13088,6 +13148,11 @@ var Parser = function Parser(options, input, startPos) {
 
   // For RegExp validation
   this.regexpState = null;
+
+  // The stack of private names.
+  // Each element has two properties: 'declared' and 'used'.
+  // When it exited from the outermost class definition, all used private names must be declared.
+  this.privateNameStack = [];
 };
 
 var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },inNonArrowFunction: { configurable: true } };
@@ -13099,12 +13164,22 @@ Parser.prototype.parse = function parse () {
 };
 
 prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
-prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };
-prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
-prototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };
+prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 && !this.currentVarScope().inClassFieldInit };
+prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 && !this.currentVarScope().inClassFieldInit };
+prototypeAccessors.allowSuper.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_SUPER) > 0 || inClassFieldInit
+};
 prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
 prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
-prototypeAccessors.inNonArrowFunction.get = function () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };
+prototypeAccessors.inNonArrowFunction.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_FUNCTION) > 0 || inClassFieldInit
+};
 
 Parser.extend = function extend () {
     var plugins = [], len = arguments.length;
@@ -13511,7 +13586,7 @@ pp$1.parseForStatement = function(node) {
     return this.parseFor(node, init$1)
   }
   var refDestructuringErrors = new DestructuringErrors;
-  var init = this.parseExpression(true, refDestructuringErrors);
+  var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
   if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
     if (this.options.ecmaVersion >= 9) {
       if (this.type === types._in) {
@@ -13857,6 +13932,7 @@ pp$1.parseClass = function(node, isStatement) {
 
   this.parseClassId(node, isStatement);
   this.parseClassSuper(node);
+  var privateNameMap = this.enterClassBody();
   var classBody = this.startNode();
   var hadConstructor = false;
   classBody.body = [];
@@ -13868,77 +13944,154 @@ pp$1.parseClass = function(node, isStatement) {
       if (element.type === "MethodDefinition" && element.kind === "constructor") {
         if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
         hadConstructor = true;
+      } else if (element.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element)) {
+        this.raiseRecoverable(element.key.start, ("Identifier '#" + (element.key.name) + "' has already been declared"));
       }
     }
   }
   this.strict = oldStrict;
   this.next();
   node.body = this.finishNode(classBody, "ClassBody");
+  this.exitClassBody();
   return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
 };
 
 pp$1.parseClassElement = function(constructorAllowsSuper) {
-  var this$1 = this;
-
   if (this.eat(types.semi)) { return null }
 
-  var method = this.startNode();
-  var tryContextual = function (k, noLineBreak) {
-    if ( noLineBreak === void 0 ) noLineBreak = false;
-
-    var start = this$1.start, startLoc = this$1.startLoc;
-    if (!this$1.eatContextual(k)) { return false }
-    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
-    if (method.key) { this$1.unexpected(); }
-    method.computed = false;
-    method.key = this$1.startNodeAt(start, startLoc);
-    method.key.name = k;
-    this$1.finishNode(method.key, "Identifier");
-    return false
-  };
-
-  method.kind = "method";
-  method.static = tryContextual("static");
-  var isGenerator = this.eat(types.star);
+  var ecmaVersion = this.options.ecmaVersion;
+  var node = this.startNode();
+  var keyName = "";
+  var isGenerator = false;
   var isAsync = false;
-  if (!isGenerator) {
-    if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+  var kind = "method";
+
+  // Parse modifiers
+  node.static = false;
+  if (this.eatContextual("static")) {
+    if (this.isClassElementNameStart() || this.type === types.star) {
+      node.static = true;
+    } else {
+      keyName = "static";
+    }
+  }
+  if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
+    if ((this.isClassElementNameStart() || this.type === types.star) && !this.canInsertSemicolon()) {
       isAsync = true;
-      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
-    } else if (tryContextual("get")) {
-      method.kind = "get";
-    } else if (tryContextual("set")) {
-      method.kind = "set";
+    } else {
+      keyName = "async";
     }
   }
-  if (!method.key) { this.parsePropertyName(method); }
+  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types.star)) {
+    isGenerator = true;
+  }
+  if (!keyName && !isAsync && !isGenerator) {
+    var lastValue = this.value;
+    if (this.eatContextual("get") || this.eatContextual("set")) {
+      if (this.isClassElementNameStart()) {
+        kind = lastValue;
+      } else {
+        keyName = lastValue;
+      }
+    }
+  }
+
+  // Parse element name
+  if (keyName) {
+    // 'async', 'get', 'set', or 'static' were not a keyword contextually.
+    // The last token is any of those. Make it the element name.
+    node.computed = false;
+    node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
+    node.key.name = keyName;
+    this.finishNode(node.key, "Identifier");
+  } else {
+    this.parseClassElementName(node);
+  }
+
+  // Parse element value
+  if (ecmaVersion < 13 || this.type === types.parenL || kind !== "method" || isGenerator || isAsync) {
+    var isConstructor = !node.static && checkKeyName(node, "constructor");
+    var allowsDirectSuper = isConstructor && constructorAllowsSuper;
+    // Couldn't move this check into the 'parseClassMethod' method for backward compatibility.
+    if (isConstructor && kind !== "method") { this.raise(node.key.start, "Constructor can't have get/set modifier"); }
+    node.kind = isConstructor ? "constructor" : kind;
+    this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper);
+  } else {
+    this.parseClassField(node);
+  }
+
+  return node
+};
+
+pp$1.isClassElementNameStart = function() {
+  return (
+    this.type === types.name ||
+    this.type === types.privateId ||
+    this.type === types.num ||
+    this.type === types.string ||
+    this.type === types.bracketL ||
+    this.type.keyword
+  )
+};
+
+pp$1.parseClassElementName = function(element) {
+  if (this.type === types.privateId) {
+    if (this.value === "constructor") {
+      this.raise(this.start, "Classes can't have an element named '#constructor'");
+    }
+    element.computed = false;
+    element.key = this.parsePrivateIdent();
+  } else {
+    this.parsePropertyName(element);
+  }
+};
+
+pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+  // Check key and flags
   var key = method.key;
-  var allowsDirectSuper = false;
-  if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
-      key.type === "Literal" && key.value === "constructor")) {
-    if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+  if (method.kind === "constructor") {
     if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
     if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
-    method.kind = "constructor";
-    allowsDirectSuper = constructorAllowsSuper;
-  } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+  } else if (method.static && checkKeyName(method, "prototype")) {
     this.raise(key.start, "Classes may not have a static property named prototype");
   }
-  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
-  if (method.kind === "get" && method.value.params.length !== 0)
-    { this.raiseRecoverable(method.value.start, "getter should have no params"); }
-  if (method.kind === "set" && method.value.params.length !== 1)
-    { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
-  if (method.kind === "set" && method.value.params[0].type === "RestElement")
-    { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
-  return method
-};
 
-pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
-  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+  // Parse value
+  var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+
+  // Check value
+  if (method.kind === "get" && value.params.length !== 0)
+    { this.raiseRecoverable(value.start, "getter should have no params"); }
+  if (method.kind === "set" && value.params.length !== 1)
+    { this.raiseRecoverable(value.start, "setter should have exactly one param"); }
+  if (method.kind === "set" && value.params[0].type === "RestElement")
+    { this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params"); }
+
   return this.finishNode(method, "MethodDefinition")
 };
 
+pp$1.parseClassField = function(field) {
+  if (checkKeyName(field, "constructor")) {
+    this.raise(field.key.start, "Classes can't have a field named 'constructor'");
+  } else if (field.static && checkKeyName(field, "prototype")) {
+    this.raise(field.key.start, "Classes can't have a static field named 'prototype'");
+  }
+
+  if (this.eat(types.eq)) {
+    // To raise SyntaxError if 'arguments' exists in the initializer.
+    var scope = this.currentThisScope();
+    var inClassFieldInit = scope.inClassFieldInit;
+    scope.inClassFieldInit = true;
+    field.value = this.parseMaybeAssign();
+    scope.inClassFieldInit = inClassFieldInit;
+  } else {
+    field.value = null;
+  }
+  this.semicolon();
+
+  return this.finishNode(field, "PropertyDefinition")
+};
+
 pp$1.parseClassId = function(node, isStatement) {
   if (this.type === types.name) {
     node.id = this.parseIdent();
@@ -13955,6 +14108,65 @@ pp$1.parseClassSuper = function(node) {
   node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
 };
 
+pp$1.enterClassBody = function() {
+  var element = {declared: Object.create(null), used: []};
+  this.privateNameStack.push(element);
+  return element.declared
+};
+
+pp$1.exitClassBody = function() {
+  var ref = this.privateNameStack.pop();
+  var declared = ref.declared;
+  var used = ref.used;
+  var len = this.privateNameStack.length;
+  var parent = len === 0 ? null : this.privateNameStack[len - 1];
+  for (var i = 0; i < used.length; ++i) {
+    var id = used[i];
+    if (!has(declared, id.name)) {
+      if (parent) {
+        parent.used.push(id);
+      } else {
+        this.raiseRecoverable(id.start, ("Private field '#" + (id.name) + "' must be declared in an enclosing class"));
+      }
+    }
+  }
+};
+
+function isPrivateNameConflicted(privateNameMap, element) {
+  var name = element.key.name;
+  var curr = privateNameMap[name];
+
+  var next = "true";
+  if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) {
+    next = (element.static ? "s" : "i") + element.kind;
+  }
+
+  // `class { get #a(){}; static set #a(_){} }` is also conflict.
+  if (
+    curr === "iget" && next === "iset" ||
+    curr === "iset" && next === "iget" ||
+    curr === "sget" && next === "sset" ||
+    curr === "sset" && next === "sget"
+  ) {
+    privateNameMap[name] = "true";
+    return false
+  } else if (!curr) {
+    privateNameMap[name] = next;
+    return false
+  } else {
+    return true
+  }
+}
+
+function checkKeyName(node, name) {
+  var computed = node.computed;
+  var key = node.key;
+  return !computed && (
+    key.type === "Identifier" && key.name === name ||
+    key.type === "Literal" && key.value === name
+  )
+}
+
 // Parses module export declaration.
 
 pp$1.parseExport = function(node, exports) {
@@ -14573,13 +14785,13 @@ pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 // and object pattern might appear (so it's possible to raise
 // delayed syntax error at correct position).
 
-pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+pp$3.parseExpression = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+  var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
   if (this.type === types.comma) {
     var node = this.startNodeAt(startPos, startLoc);
     node.expressions = [expr];
-    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }
+    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
     return this.finishNode(node, "SequenceExpression")
   }
   return expr
@@ -14588,9 +14800,9 @@ pp$3.parseExpression = function(noIn, refDestructuringErrors) {
 // Parse an assignment expression. This includes applications of
 // operators like `+=`.
 
-pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+pp$3.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
   if (this.isContextual("yield")) {
-    if (this.inGenerator) { return this.parseYield(noIn) }
+    if (this.inGenerator) { return this.parseYield(forInit) }
     // The tokenizer will assume an expression is allowed after
     // `yield`, but this isn't that kind of yield
     else { this.exprAllowed = false; }
@@ -14607,9 +14819,11 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
   }
 
   var startPos = this.start, startLoc = this.startLoc;
-  if (this.type === types.parenL || this.type === types.name)
-    { this.potentialArrowAt = this.start; }
-  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+  if (this.type === types.parenL || this.type === types.name) {
+    this.potentialArrowAt = this.start;
+    this.potentialArrowInForAwait = forInit === "await";
+  }
+  var left = this.parseMaybeConditional(forInit, refDestructuringErrors);
   if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
   if (this.type.isAssign) {
     var node = this.startNodeAt(startPos, startLoc);
@@ -14627,7 +14841,7 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
       { this.checkLValSimple(left); }
     node.left = left;
     this.next();
-    node.right = this.parseMaybeAssign(noIn);
+    node.right = this.parseMaybeAssign(forInit);
     return this.finishNode(node, "AssignmentExpression")
   } else {
     if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
@@ -14639,16 +14853,16 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
 
 // Parse a ternary conditional (`?:`) operator.
 
-pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+pp$3.parseMaybeConditional = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseExprOps(noIn, refDestructuringErrors);
+  var expr = this.parseExprOps(forInit, refDestructuringErrors);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
   if (this.eat(types.question)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.test = expr;
     node.consequent = this.parseMaybeAssign();
     this.expect(types.colon);
-    node.alternate = this.parseMaybeAssign(noIn);
+    node.alternate = this.parseMaybeAssign(forInit);
     return this.finishNode(node, "ConditionalExpression")
   }
   return expr
@@ -14656,11 +14870,11 @@ pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
 
 // Start the precedence parser.
 
-pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+pp$3.parseExprOps = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseMaybeUnary(refDestructuringErrors, false);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit)
 };
 
 // Parse binary operators with the operator precedence parsing
@@ -14669,9 +14883,9 @@ pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
 // defer further parser to one of its callers when it encounters an
 // operator that has a lower precedence than the set it is parsing.
 
-pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
   var prec = this.type.binop;
-  if (prec != null && (!noIn || this.type !== types._in)) {
+  if (prec != null && (!forInit || this.type !== types._in)) {
     if (prec > minPrec) {
       var logical = this.type === types.logicalOR || this.type === types.logicalAND;
       var coalesce = this.type === types.coalesce;
@@ -14683,12 +14897,12 @@ pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
       var op = this.value;
       this.next();
       var startPos = this.start, startLoc = this.startLoc;
-      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
+      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, forInit);
       var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
       if ((logical && this.type === types.coalesce) || (coalesce && (this.type === types.logicalOR || this.type === types.logicalAND))) {
         this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
       }
-      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit)
     }
   }
   return left
@@ -14704,7 +14918,7 @@ pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
 
 // Parse unary operators, both prefix and postfix.
 
-pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec) {
   var startPos = this.start, startLoc = this.startLoc, expr;
   if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
     expr = this.parseAwait();
@@ -14714,12 +14928,14 @@ pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
     node.operator = this.value;
     node.prefix = true;
     this.next();
-    node.argument = this.parseMaybeUnary(null, true);
+    node.argument = this.parseMaybeUnary(null, true, update);
     this.checkExpressionErrors(refDestructuringErrors, true);
     if (update) { this.checkLValSimple(node.argument); }
     else if (this.strict && node.operator === "delete" &&
              node.argument.type === "Identifier")
       { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+    else if (node.operator === "delete" && isPrivateFieldAccess(node.argument))
+      { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
     else { sawUnary = true; }
     expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
   } else {
@@ -14736,12 +14952,23 @@ pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
     }
   }
 
-  if (!sawUnary && this.eat(types.starstar))
-    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
-  else
-    { return expr }
+  if (!incDec && this.eat(types.starstar)) {
+    if (sawUnary)
+      { this.unexpected(this.lastTokStart); }
+    else
+      { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  } else {
+    return expr
+  }
 };
 
+function isPrivateFieldAccess(node) {
+  return (
+    node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" ||
+    node.type === "ChainExpression" && isPrivateFieldAccess(node.expression)
+  )
+}
+
 // Parse call, dot, and `[]`-subscript expressions.
 
 pp$3.parseExprSubscripts = function(refDestructuringErrors) {
@@ -14753,6 +14980,7 @@ pp$3.parseExprSubscripts = function(refDestructuringErrors) {
   if (refDestructuringErrors && result.type === "MemberExpression") {
     if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
     if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+    if (refDestructuringErrors.trailingComma >= result.start) { refDestructuringErrors.trailingComma = -1; }
   }
   return result
 };
@@ -14789,9 +15017,15 @@ pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
   if (computed || (optional && this.type !== types.parenL && this.type !== types.backQuote) || this.eat(types.dot)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.object = base;
-    node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
+    if (computed) {
+      node.property = this.parseExpression();
+      this.expect(types.bracketR);
+    } else if (this.type === types.privateId && base.type !== "Super") {
+      node.property = this.parsePrivateIdent();
+    } else {
+      node.property = this.parseIdent(this.options.allowReserved !== "never");
+    }
     node.computed = !!computed;
-    if (computed) { this.expect(types.bracketR); }
     if (optionalSupported) {
       node.optional = optional;
     }
@@ -14877,7 +15111,8 @@ pp$3.parseExprAtom = function(refDestructuringErrors) {
     if (canBeArrow && !this.canInsertSemicolon()) {
       if (this.eat(types.arrow))
         { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
-      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc &&
+          (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
         id = this.parseIdent(false);
         if (this.canInsertSemicolon() || !this.eat(types.arrow))
           { this.unexpected(); }
@@ -14995,7 +15230,7 @@ pp$3.parseImportMeta = function(node) {
     { this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'"); }
   if (containsEsc)
     { this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters"); }
-  if (this.options.sourceType !== "module")
+  if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere)
     { this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module"); }
 
   return this.finishNode(node, "MetaProperty")
@@ -15463,6 +15698,8 @@ pp$3.checkUnreserved = function(ref) {
     { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
   if (this.inAsync && name === "await")
     { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+  if (this.currentThisScope().inClassFieldInit && name === "arguments")
+    { this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer"); }
   if (this.keywords.test(name))
     { this.raise(start, ("Unexpected keyword '" + name + "'")); }
   if (this.options.ecmaVersion < 6 &&
@@ -15507,9 +15744,29 @@ pp$3.parseIdent = function(liberal, isBinding) {
   return node
 };
 
+pp$3.parsePrivateIdent = function() {
+  var node = this.startNode();
+  if (this.type === types.privateId) {
+    node.name = this.value;
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  this.finishNode(node, "PrivateIdentifier");
+
+  // For validating existence
+  if (this.privateNameStack.length === 0) {
+    this.raise(node.start, ("Private field '#" + (node.name) + "' must be declared in an enclosing class"));
+  } else {
+    this.privateNameStack[this.privateNameStack.length - 1].used.push(node);
+  }
+
+  return node
+};
+
 // Parses yield expression inside generator.
 
-pp$3.parseYield = function(noIn) {
+pp$3.parseYield = function(forInit) {
   if (!this.yieldPos) { this.yieldPos = this.start; }
 
   var node = this.startNode();
@@ -15519,7 +15776,7 @@ pp$3.parseYield = function(noIn) {
     node.argument = null;
   } else {
     node.delegate = this.eat(types.star);
-    node.argument = this.parseMaybeAssign(noIn);
+    node.argument = this.parseMaybeAssign(forInit);
   }
   return this.finishNode(node, "YieldExpression")
 };
@@ -15567,6 +15824,8 @@ var Scope = function Scope(flags) {
   this.lexical = [];
   // A list of lexically-declared FunctionDeclaration names in the current lexical scope
   this.functions = [];
+  // A switch to disallow the identifier reference 'arguments'
+  this.inClassFieldInit = false;
 };
 
 // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
@@ -17043,9 +17302,9 @@ pp$9.readToken = function(code) {
 
 pp$9.fullCharCodeAtPos = function() {
   var code = this.input.charCodeAt(this.pos);
-  if (code <= 0xd7ff || code >= 0xe000) { return code }
+  if (code <= 0xd7ff || code >= 0xdc00) { return code }
   var next = this.input.charCodeAt(this.pos + 1);
-  return (code << 10) + next - 0x35fdc00
+  return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00
 };
 
 pp$9.skipBlockComment = function() {
@@ -17264,6 +17523,20 @@ pp$9.readToken_question = function() { // '?'
   return this.finishOp(types.question, 1)
 };
 
+pp$9.readToken_numberSign = function() { // '#'
+  var ecmaVersion = this.options.ecmaVersion;
+  var code = 35; // '#'
+  if (ecmaVersion >= 13) {
+    ++this.pos;
+    code = this.fullCharCodeAtPos();
+    if (isIdentifierStart(code, true) || code === 92 /* '\' */) {
+      return this.finishToken(types.privateId, this.readWord1())
+    }
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+};
+
 pp$9.getTokenFromCode = function(code) {
   switch (code) {
   // The interpretation of a dot depends on whether it is followed
@@ -17335,6 +17608,9 @@ pp$9.getTokenFromCode = function(code) {
 
   case 126: // '~'
     return this.finishOp(types.prefix, 1)
+
+  case 35: // '#'
+    return this.readToken_numberSign()
   }
 
   this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
@@ -17746,7 +18022,7 @@ pp$9.readWord = function() {
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version = "8.0.5";
+var version = "8.2.4";
 
 Parser.acorn = {
   Parser: Parser,
@@ -17781,47 +18057,6 @@ function parse(input, options) {
   return Parser.parse(input, options)
 }
 
-// This function tries to parse a single expression at a given
-// offset in a string. Useful for parsing mixed-language formats
-// that embed JavaScript expressions.
-
-function parseExpressionAt(input, pos, options) {
-  return Parser.parseExpressionAt(input, pos, options)
-}
-
-// Acorn is organized as a tokenizer and a recursive-descent parser.
-// The `tokenizer` export provides an interface to the tokenizer.
-
-function tokenizer(input, options) {
-  return Parser.tokenizer(input, options)
-}
-
-var acorn = {
-  __proto__: null,
-  Node: Node,
-  Parser: Parser,
-  Position: Position,
-  SourceLocation: SourceLocation,
-  TokContext: TokContext,
-  Token: Token,
-  TokenType: TokenType,
-  defaultOptions: defaultOptions,
-  getLineInfo: getLineInfo,
-  isIdentifierChar: isIdentifierChar,
-  isIdentifierStart: isIdentifierStart,
-  isNewLine: isNewLine,
-  keywordTypes: keywords$1,
-  lineBreak: lineBreak,
-  lineBreakG: lineBreakG,
-  nonASCIIwhitespace: nonASCIIwhitespace,
-  parse: parse,
-  parseExpressionAt: parseExpressionAt,
-  tokContexts: types$1,
-  tokTypes: types,
-  tokenizer: tokenizer,
-  version: version
-};
-
 class GlobalScope extends Scope$1 {
     constructor() {
         super();
@@ -18571,7 +18806,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
         cache: cacheInstance,
         emitAsset: getDeprecatedContextHandler((name, source) => fileEmitter.emitFile({ type: 'asset', name, source }), 'emitAsset', 'emitFile', plugin.name, true, options),
         emitChunk: getDeprecatedContextHandler((id, options) => fileEmitter.emitFile({ type: 'chunk', id, name: options && options.name }), 'emitChunk', 'emitFile', plugin.name, true, options),
-        emitFile: fileEmitter.emitFile,
+        emitFile: fileEmitter.emitFile.bind(fileEmitter),
         error(err) {
             return throwPluginError(err, plugin.name);
         },
@@ -18646,10 +18881,10 @@ class PluginDriver {
         warnDeprecatedHooks(userPlugins, options);
         this.pluginCache = pluginCache;
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
-        this.emitFile = this.fileEmitter.emitFile;
-        this.getFileName = this.fileEmitter.getFileName;
-        this.finaliseAssets = this.fileEmitter.assertAssetsFinalized;
-        this.setOutputBundle = this.fileEmitter.setOutputBundle;
+        this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
+        this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
+        this.finaliseAssets = this.fileEmitter.assertAssetsFinalized.bind(this.fileEmitter);
+        this.setOutputBundle = this.fileEmitter.setOutputBundle.bind(this.fileEmitter);
         this.plugins = userPlugins.concat(basePluginDriver ? basePluginDriver.plugins : []);
         const existingPluginNames = new Set();
         for (const plugin of this.plugins) {
@@ -19049,7 +19284,7 @@ base.ImportDeclaration = function (node, st, c) {
 base.ImportExpression = function (node, st, c) {
   c(node.source, st, "Expression");
 };
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
 
 base.TaggedTemplateExpression = function (node, st, c) {
   c(node.tag, st, "Expression");
@@ -19069,9 +19304,9 @@ base.ClassBody = function (node, st, c) {
     c(elt, st);
   }
 };
-base.MethodDefinition = base.Property = function (node, st, c) {
+base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
   if (node.computed) { c(node.key, st, "Expression"); }
-  c(node.value, st, "Expression");
+  if (node.value) { c(node.value, st, "Expression"); }
 };
 
 // patch up acorn-walk until class-fields are officially supported
@@ -19083,10 +19318,30 @@ base.PropertyDefinition = function (node, st, c) {
         c(node.value, st, 'Expression');
     }
 };
+function isOnlyWhitespaceOrComments(code) {
+    // streamline the typical case
+    if (/^\s*$/.test(code))
+        return true;
+    try {
+        // successful only if it's a valid Program without statements
+        const ast = parse(code, { ecmaVersion: 'latest' });
+        return ast.body && ast.body.length === 0;
+    }
+    catch (_a) {
+        // should only be reached by invalid annotations like:
+        //
+        //   foo() /*@__PURE__*/ /* other */, bar();
+        //
+        // where `code` is " /* other */, "
+    }
+    return false;
+}
 function handlePureAnnotationsOfNode(node, state, type = node.type) {
     let commentNode = state.commentNodes[state.commentIndex];
     while (commentNode && node.start >= commentNode.end) {
-        markPureNode(node, commentNode);
+        const between = state.code.substring(commentNode.end, node.start);
+        if (isOnlyWhitespaceOrComments(between))
+            markPureNode(node, commentNode);
         commentNode = state.commentNodes[++state.commentIndex];
     }
     if (commentNode && commentNode.end <= node.end) {
@@ -19114,8 +19369,9 @@ function markPureNode(node, comment) {
 }
 const pureCommentRegex = /[@#]__PURE__/;
 const isPureComment = (comment) => pureCommentRegex.test(comment.value);
-function markPureCallExpressions(comments, esTreeAst) {
+function markPureCallExpressions(comments, esTreeAst, code) {
     handlePureAnnotationsOfNode(esTreeAst, {
+        code,
         commentIndex: 0,
         commentNodes: comments.filter(isPureComment)
     });
@@ -19222,7 +19478,7 @@ class Graph {
             onCommentOrig.push(...comments);
         }
         options.onComment = onCommentOrig;
-        markPureCallExpressions(comments, ast);
+        markPureCallExpressions(comments, ast, code);
         return ast;
     }
     getCache() {
@@ -19346,363 +19602,6 @@ function ensureArray(items) {
     return [];
 }
 
-function getAugmentedNamespace(n) {
-	if (n.__esModule) return n;
-	var a = Object.defineProperty({}, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(acorn);
-
-const getPrototype = Object.getPrototypeOf || (o => o.__proto__);
-
-const getAcorn$1 = Parser => {
-  if (Parser.acorn) return Parser.acorn
-
-  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}`)
-  }
-
-  // Make sure `Parser` comes from the same acorn as we `require`d,
-  // otherwise the comparisons fail.
-  for (let cur = Parser; cur && cur !== acorn.Parser; cur = getPrototype(cur)) {
-    if (cur !== acorn.Parser) {
-      throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
-    }
-  }
-  return acorn
-};
-
-var acornPrivateClassElements = function(Parser) {
-  // Only load this plugin once.
-  if (Parser.prototype.parsePrivateName) {
-    return Parser
-  }
-
-  const acorn = getAcorn$1(Parser);
-
-  Parser = class extends Parser {
-    _branch() {
-      this.__branch = this.__branch || new Parser({ecmaVersion: this.options.ecmaVersion}, this.input);
-      this.__branch.end = this.end;
-      this.__branch.pos = this.pos;
-      this.__branch.type = this.type;
-      this.__branch.value = this.value;
-      this.__branch.containsEsc = this.containsEsc;
-      return this.__branch
-    }
-
-    parsePrivateClassElementName(element) {
-      element.computed = false;
-      element.key = this.parsePrivateName();
-      if (element.key.name == "constructor") this.raise(element.key.start, "Classes may not have a private element named constructor");
-      const accept = {get: "set", set: "get"}[element.kind];
-      const privateBoundNames = this._privateBoundNames;
-      if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
-        this.raise(element.start, "Duplicate private element");
-      }
-      privateBoundNames[element.key.name] = element.kind || true;
-      delete this._unresolvedPrivateNames[element.key.name];
-      return element.key
-    }
-
-    parsePrivateName() {
-      const node = this.startNode();
-      node.name = this.value;
-      this.next();
-      this.finishNode(node, "PrivateIdentifier");
-      if (this.options.allowReserved == "never") this.checkUnreserved(node);
-      return node
-    }
-
-    // Parse # token
-    getTokenFromCode(code) {
-      if (code === 35) {
-        ++this.pos;
-        const word = this.readWord1();
-        return this.finishToken(this.privateIdentifierToken, word)
-      }
-      return super.getTokenFromCode(code)
-    }
-
-    // Manage stacks and check for undeclared private names
-    parseClass(node, isStatement) {
-      const oldOuterPrivateBoundNames = this._outerPrivateBoundNames;
-      this._outerPrivateBoundNames = this._privateBoundNames;
-      this._privateBoundNames = Object.create(this._privateBoundNames || null);
-      const oldOuterUnresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      this._outerUnresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._unresolvedPrivateNames = Object.create(null);
-
-      const _return = super.parseClass(node, isStatement);
-
-      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._privateBoundNames = this._outerPrivateBoundNames;
-      this._outerPrivateBoundNames = oldOuterPrivateBoundNames;
-      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      this._outerUnresolvedPrivateNames = oldOuterUnresolvedPrivateNames;
-      if (!this._unresolvedPrivateNames) {
-        const names = Object.keys(unresolvedPrivateNames);
-        if (names.length) {
-          names.sort((n1, n2) => unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2]);
-          this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name");
-        }
-      } else Object.assign(this._unresolvedPrivateNames, unresolvedPrivateNames);
-      return _return
-    }
-
-    // Class heritage is evaluated with outer private environment
-    parseClassSuper(node) {
-      const privateBoundNames = this._privateBoundNames;
-      this._privateBoundNames = this._outerPrivateBoundNames;
-      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      const _return = super.parseClassSuper(node);
-      this._privateBoundNames = privateBoundNames;
-      this._unresolvedPrivateNames = unresolvedPrivateNames;
-      return _return
-    }
-
-    // Parse private element access
-    parseSubscript(base, startPos, startLoc, _noCalls, _maybeAsyncArrow, _optionalChained) {
-      const optionalSupported = this.options.ecmaVersion >= 11 && acorn.tokTypes.questionDot;
-      const branch = this._branch();
-      if (!(
-        (branch.eat(acorn.tokTypes.dot) || (optionalSupported && branch.eat(acorn.tokTypes.questionDot))) &&
-        branch.type == this.privateIdentifierToken
-      )) {
-        return super.parseSubscript.apply(this, arguments)
-      }
-      let optional = false;
-      if (!this.eat(acorn.tokTypes.dot)) {
-        this.expect(acorn.tokTypes.questionDot);
-        optional = true;
-      }
-      let node = this.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.computed = false;
-      if (optionalSupported) {
-        node.optional = optional;
-      }
-      if (this.type == this.privateIdentifierToken) {
-        if (base.type == "Super") {
-          this.raise(this.start, "Cannot access private element on super");
-        }
-        node.property = this.parsePrivateName();
-        if (!this._privateBoundNames || !this._privateBoundNames[node.property.name]) {
-          if (!this._unresolvedPrivateNames) {
-            this.raise(node.property.start, "Usage of undeclared private name");
-          }
-          this._unresolvedPrivateNames[node.property.name] = node.property.start;
-        }
-      } else {
-        node.property = this.parseIdent(true);
-      }
-      return this.finishNode(node, "MemberExpression")
-    }
-
-    // Prohibit delete of private class elements
-    parseMaybeUnary(refDestructuringErrors, sawUnary) {
-      const _return = super.parseMaybeUnary(refDestructuringErrors, sawUnary);
-      if (_return.operator == "delete") {
-        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateIdentifier") {
-          this.raise(_return.start, "Private elements may not be deleted");
-        }
-      }
-      return _return
-    }
-  };
-  Parser.prototype.privateIdentifierToken = new acorn.TokenType("privateIdentifier");
-  return Parser
-};
-
-const privateClassElements$1 = acornPrivateClassElements;
-
-var acornClassFields = function(Parser) {
-  const acorn = Parser.acorn || require$$1;
-  const tt = acorn.tokTypes;
-
-  Parser = privateClassElements$1(Parser);
-  return class extends Parser {
-    _maybeParseFieldValue(field) {
-      if (this.eat(tt.eq)) {
-        const oldInFieldValue = this._inFieldValue;
-        this._inFieldValue = true;
-        if (this.type === tt.name && this.value === "await" && (this.inAsync || this.options.allowAwaitOutsideFunction)) {
-          field.value = this.parseAwait();
-        } else field.value = this.parseExpression();
-        this._inFieldValue = oldInFieldValue;
-      } else field.value = null;
-    }
-
-    // Parse fields
-    parseClassElement(_constructorAllowsSuper) {
-      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;
-          do {
-            if (branch.eat(tt.bracketL)) ++count;
-            else if (branch.eat(tt.bracketR)) --count;
-            else branch.next();
-          } while (count > 0)
-        } else branch.next(true);
-        let isField = branch.type == tt.eq || branch.type == tt.semi;
-        if (!isField && branch.canInsertSemicolon()) {
-          isField = branch.type != tt.parenL;
-        }
-        if (isField) {
-          const node = this.startNode();
-          if (this.type == this.privateIdentifierToken) {
-            this.parsePrivateClassElementName(node);
-          } else {
-            this.parsePropertyName(node);
-          }
-          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-              (node.key.type === "Literal" && node.key.value === "constructor")) {
-            this.raise(node.key.start, "Classes may not have a field called constructor");
-          }
-          this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-          this._maybeParseFieldValue(node);
-          this.exitScope();
-          this.finishNode(node, "PropertyDefinition");
-          this.semicolon();
-          return node
-        }
-      }
-
-      return super.parseClassElement.apply(this, arguments)
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding);
-      if (this._inFieldValue && ident.name == "arguments") this.raise(ident.start, "A class field initializer may not contain arguments");
-      return ident
-    }
-  }
-};
-
-// eslint-disable-next-line node/no-unsupported-features/es-syntax
-
-// eslint-disable-next-line node/no-unsupported-features/es-syntax
-function privateMethods(Parser) {
-  const ExtendedParser = acornPrivateClassElements(Parser);
-
-  return class extends ExtendedParser {
-    // Parse private methods
-    parseClassElement(_constructorAllowsSuper) {
-      const oldInClassMemberName = this._inClassMemberName;
-      this._inClassMemberName = true;
-      const result = super.parseClassElement.apply(this, arguments);
-      this._inClassMemberName = oldInClassMemberName;
-      return result
-    }
-
-    parsePropertyName(prop) {
-      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static;
-      this._inClassMemberName = false;
-      if (!isPrivate) return super.parsePropertyName(prop)
-      return this.parsePrivateClassElementName(prop)
-    }
-  }
-}
-
-const privateClassElements = acornPrivateClassElements;
-
-var acornStaticClassFeatures = function(Parser) {
-  const ExtendedParser = privateClassElements(Parser);
-
-  const acorn = Parser.acorn || require$$1;
-  const tt = acorn.tokTypes;
-
-  return class extends ExtendedParser {
-    _maybeParseFieldValue(field) {
-      if (this.eat(tt.eq)) {
-        const oldInFieldValue = this._inStaticFieldScope;
-        this._inStaticFieldScope = this.currentThisScope();
-        field.value = this.parseExpression();
-        this._inStaticFieldScope = oldInFieldValue;
-      } else field.value = null;
-    }
-
-    // Parse fields
-    parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion < 8 || !this.isContextual("static")) {
-        return super.parseClassElement.apply(this, arguments)
-      }
-
-      const branch = this._branch();
-      branch.next();
-      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) {
-        let count = 0;
-        do {
-          if (branch.eat(tt.bracketL)) ++count;
-          else if (branch.eat(tt.bracketR)) --count;
-          else branch.next();
-        } while (count > 0)
-      } else branch.next();
-      if (branch.type != tt.eq && !branch.canInsertSemicolon() && branch.type != tt.semi) {
-        return super.parseClassElement.apply(this, arguments)
-      }
-
-      const node = this.startNode();
-      node.static = this.eatContextual("static");
-      if (this.type == this.privateIdentifierToken) {
-        this.parsePrivateClassElementName(node);
-      } else {
-        this.parsePropertyName(node);
-      }
-      if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-          (node.key.type === "Literal" && !node.computed && node.key.value === "constructor")) {
-        this.raise(node.key.start, "Classes may not have a field called constructor");
-      }
-      if ((node.key.name || node.key.value) === "prototype" && !node.computed) {
-        this.raise(node.key.start, "Classes may not have a static property named prototype");
-      }
-
-      this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-      this._maybeParseFieldValue(node);
-      this.exitScope();
-      this.finishNode(node, "PropertyDefinition");
-      this.semicolon();
-      return node
-    }
-
-    // Parse private static methods
-    parsePropertyName(prop) {
-      if (prop.static && this.type == this.privateIdentifierToken) {
-        this.parsePrivateClassElementName(prop);
-      } else {
-        super.parsePropertyName(prop);
-      }
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding);
-      if (this._inStaticFieldScope && this.currentThisScope() === this._inStaticFieldScope && ident.name == "arguments") {
-        this.raise(ident.start, "A static class field initializer may not contain arguments");
-      }
-      return ident
-    }
-  }
-};
-
 const defaultOnWarn = warning => console.warn(warning.message || warning);
 function warnUnknownOptions(passedOptions, validOptions, optionType, warn, ignoredKeys = /$./) {
     const validOptionSet = new Set(validOptions);
@@ -19775,12 +19674,7 @@ const getAcorn = (config) => ({
     sourceType: 'module',
     ...config.acorn
 });
-const getAcornInjectPlugins = (config) => [
-    acornClassFields,
-    privateMethods,
-    acornStaticClassFeatures,
-    ...ensureArray(config.acornInjectPlugins)
-];
+const getAcornInjectPlugins = (config) => ensureArray(config.acornInjectPlugins);
 const getCache = (config) => {
     var _a;
     return ((_a = config.cache) === null || _a === void 0 ? void 0 : _a.cache) || config.cache;
@@ -19900,6 +19794,14 @@ const getHasModuleSideEffects = (moduleSideEffectsOption, pureExternalModules, w
     return (id, external) => !(external && isPureExternalModule(id));
 };
 
+function sanitizeFileName(name) {
+    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 normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
     var _a, _b, _c, _d, _e, _f, _g;
     // These are options that may trigger special warnings or behaviour later
@@ -19944,6 +19846,7 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         preferConst: config.preferConst || false,
         preserveModules,
         preserveModulesRoot: getPreserveModulesRoot(config),
+        sanitizeFileName: (typeof config.sanitizeFileName === 'function' ? config.sanitizeFileName : config.sanitizeFileName === false ? (id) => id : sanitizeFileName),
         sourcemap: config.sourcemap || false,
         sourcemapExcludeSources: config.sourcemapExcludeSources || false,
         sourcemapFile: config.sourcemapFile,
@@ -20172,7 +20075,10 @@ const getManualChunks = (config, inlineDynamicImports, preserveModules, inputOpt
     }
     return configManualChunks || {};
 };
-const getMinifyInternalExports = (config, format, compact) => { var _a; return (_a = config.minifyInternalExports) !== null && _a !== void 0 ? _a : (compact || format === 'es' || format === 'system'); };
+const getMinifyInternalExports = (config, format, compact) => {
+    var _a;
+    return (_a = config.minifyInternalExports) !== null && _a !== void 0 ? _a : (compact || format === 'es' || format === 'system');
+};
 
 function rollup(rawInputOptions) {
     return rollupInternal(rawInputOptions, null);
@@ -20389,4 +20295,4 @@ function watch(configs) {
     return emitter;
 }
 
-export { defaultOnWarn, ensureArray, fseventsImporter, getAugmentedNamespace, rollup, rollupInternal, version$1 as version, warnUnknownOptions, watch };
+export { defaultOnWarn, ensureArray, fseventsImporter, rollup, rollupInternal, version$1 as version, warnUnknownOptions, watch };