rollup 3.9.1 → 3.10.0

package/dist/es/shared/rollup.js

@@ -1,14 +1,14 @@
 /*
   @license
-	Rollup.js v3.9.1
-	Mon, 02 Jan 2023 13:46:34 GMT - commit c6c884433e748cde70f3f4299dd48b81af97ec14
+	Rollup.js v3.10.0
+	Thu, 12 Jan 2023 07:56:20 GMT - commit ffc19b0091267d9bf5072b16969599e457a63f5c
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
 import { resolve, basename, extname, dirname, relative as relative$1 } from 'node:path';
-import require$$0$2, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$1 } from 'path';
+import require$$0$1, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$1 } from 'path';
 import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
 import { createHash as createHash$1 } from 'node:crypto';
@@ -16,15 +16,15 @@ import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/pr
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.9.1";
+var version$1 = "3.10.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
-const chars$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 const intToChar = new Uint8Array(64); // 64 possible chars.
 const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars$2.length; i++) {
-    const c = chars$2.charCodeAt(i);
+for (let i = 0; i < chars$1.length; i++) {
+    const c = chars$1.charCodeAt(i);
     intToChar[i] = c;
     charToInt[c] = i;
 }
@@ -47,6 +47,80 @@ const td = typeof TextDecoder !== 'undefined'
                 return out;
             },
         };
+function decode(mappings) {
+    const state = new Int32Array(5);
+    const decoded = [];
+    let index = 0;
+    do {
+        const semi = indexOf(mappings, index);
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        state[0] = 0;
+        for (let i = index; i < semi; i++) {
+            let seg;
+            i = decodeInteger(mappings, i, state, 0); // genColumn
+            const col = state[0];
+            if (col < lastCol)
+                sorted = false;
+            lastCol = col;
+            if (hasMoreVlq(mappings, i, semi)) {
+                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
+                i = decodeInteger(mappings, i, state, 2); // sourceLine
+                i = decodeInteger(mappings, i, state, 3); // sourceColumn
+                if (hasMoreVlq(mappings, i, semi)) {
+                    i = decodeInteger(mappings, i, state, 4); // namesIndex
+                    seg = [col, state[1], state[2], state[3], state[4]];
+                }
+                else {
+                    seg = [col, state[1], state[2], state[3]];
+                }
+            }
+            else {
+                seg = [col];
+            }
+            line.push(seg);
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        index = semi + 1;
+    } while (index <= mappings.length);
+    return decoded;
+}
+function indexOf(mappings, index) {
+    const idx = mappings.indexOf(';', index);
+    return idx === -1 ? mappings.length : idx;
+}
+function decodeInteger(mappings, pos, state, j) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = mappings.charCodeAt(pos++);
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    state[j] += value;
+    return pos;
+}
+function hasMoreVlq(mappings, i, length) {
+    if (i >= length)
+        return false;
+    return mappings.charCodeAt(i) !== comma;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
 function encode(decoded) {
     const state = new Int32Array(5);
     const bufLength = 1024 * 16;
@@ -2703,7 +2777,7 @@ var picomatch$1 = {
 
 var utils$3 = {};
 
-const path$1 = require$$0$2;
+const path$1 = require$$0$1;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -2883,7 +2957,7 @@ var constants$2 = {
 
 (function (exports) {
 
-	const path = require$$0$2;
+	const path = require$$0$1;
 	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
@@ -4420,7 +4494,7 @@ parse$2.fastpaths = (input, options) => {
 
 var parse_1 = parse$2;
 
-const path = require$$0$2;
+const path = require$$0$1;
 const scan = scan_1;
 const parse$1 = parse_1;
 const utils = utils$3;
@@ -6561,14 +6635,14 @@ class LocalVariable extends Variable {
     }
 }
 
-const chars$1 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
 const base = 64;
 function toBase64(value) {
     let outString = '';
     do {
         const currentDigit = value % base;
         value = (value / base) | 0;
-        outString = chars$1[currentDigit] + outString;
+        outString = chars[currentDigit] + outString;
     } while (value !== 0);
     return outString;
 }
@@ -6792,7 +6866,6 @@ class ReturnValueScope extends ParameterScope {
     }
 }
 
-//@ts-check
 /** @typedef { import('estree').Node} Node */
 /** @typedef {Node | {
  *   type: 'PropertyDefinition';
@@ -6804,7 +6877,7 @@ class ReturnValueScope extends ParameterScope {
  *
  * @param {NodeWithPropertyDefinition} node
  * @param {NodeWithPropertyDefinition} parent
- * @returns boolean
+ * @returns {boolean}
  */
 function is_reference (node, parent) {
 	if (node.type === 'MemberExpression') {
@@ -9408,7 +9481,34 @@ class CatchClause extends NodeBase {
     }
 }
 
+const unset$1 = Symbol('unset');
 class ChainExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectValue = unset$1;
+    }
+    deoptimizeCache() {
+        this.objectValue = UnknownValue;
+    }
+    getLiteralValueAtPath() {
+        if (this.getObjectValue() == null)
+            return undefined;
+        return UnknownValue;
+    }
+    hasEffects(context) {
+        if (this.getObjectValue() == null)
+            return false;
+        return this.expression.hasEffects(context);
+    }
+    getObjectValue() {
+        if (this.objectValue === unset$1) {
+            let object = this.expression.type === 'CallExpression' ? this.expression.callee : this.expression.object;
+            if (object.type === 'MemberExpression')
+                object = object.object;
+            this.objectValue = object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        }
+        return this.objectValue;
+    }
 }
 
 class ClassBodyScope extends ChildScope {
@@ -13244,10 +13344,10 @@ class Module {
         this.transformDependencies = transformDependencies;
         this.customTransformCache = customTransformCache;
         this.updateOptions(moduleOptions);
-        const moduleAst = ast || this.tryParse();
+        const moduleAst = ast ?? this.tryParse();
         timeEnd('generate ast', 3);
         timeStart('analyze ast', 3);
-        this.resolvedIds = resolvedIds || Object.create(null);
+        this.resolvedIds = resolvedIds ?? Object.create(null);
         // By default, `id` is the file name. Custom resolvers and loaders
         // can change that, but it makes sense to use it for the source file name
         const fileName = this.id;
@@ -13348,14 +13448,6 @@ class Module {
         }
         return null;
     }
-    tryParse() {
-        try {
-            return this.graph.contextParse(this.info.code);
-        }
-        catch (error_) {
-            return this.error(errorParseError(error_, this.id), error_.pos);
-        }
-    }
     updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
         if (moduleSideEffects != null) {
             this.info.moduleSideEffects = moduleSideEffects;
@@ -13637,6 +13729,14 @@ class Module {
         this.options.onwarn(errorShimmedExport(this.id, name));
         this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
+    tryParse() {
+        try {
+            return this.graph.contextParse(this.info.code);
+        }
+        catch (error_) {
+            return this.error(errorParseError(error_, this.id), error_.pos);
+        }
+    }
 }
 // if there is a cyclic import in the reexport chain, we should not
 // import from the original module but from the cyclic module to not
@@ -13880,7 +13980,7 @@ var _static = {
   set exports(v){ _staticExports = v; },
 };
 
-const require$$0$1 = [
+const require$$0 = [
 	"assert",
 	"async_hooks",
 	"buffer",
@@ -13925,7 +14025,7 @@ const require$$0$1 = [
 ];
 
 (function (module) {
-	module.exports = require$$0$1;
+	module.exports = require$$0;
 } (_static));
 
 const builtinModules = /*@__PURE__*/getDefaultExportFromCjs(_staticExports);
@@ -16403,78 +16503,6 @@ function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain,
 
 const createHash = () => createHash$1('sha256');
 
-var charToInteger = {};
-var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$1 = 0; i$1 < chars.length; i$1++) {
-    charToInteger[chars.charCodeAt(i$1)] = i$1;
-}
-function decode(mappings) {
-    var decoded = [];
-    var line = [];
-    var segment = [
-        0,
-        0,
-        0,
-        0,
-        0,
-    ];
-    var j = 0;
-    for (var i = 0, shift = 0, value = 0; i < mappings.length; i++) {
-        var c = mappings.charCodeAt(i);
-        if (c === 44) { // ","
-            segmentify(line, segment, j);
-            j = 0;
-        }
-        else if (c === 59) { // ";"
-            segmentify(line, segment, j);
-            j = 0;
-            decoded.push(line);
-            line = [];
-            segment[0] = 0;
-        }
-        else {
-            var integer = charToInteger[c];
-            if (integer === undefined) {
-                throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
-            }
-            var hasContinuationBit = integer & 32;
-            integer &= 31;
-            value += integer << shift;
-            if (hasContinuationBit) {
-                shift += 5;
-            }
-            else {
-                var shouldNegate = value & 1;
-                value >>>= 1;
-                if (shouldNegate) {
-                    value = value === 0 ? -0x80000000 : -value;
-                }
-                segment[j] += value;
-                j++;
-                value = shift = 0; // reset
-            }
-        }
-    }
-    segmentify(line, segment, j);
-    decoded.push(line);
-    return decoded;
-}
-function segmentify(line, segment, j) {
-    // This looks ugly, but we're creating specialized arrays with a specific
-    // length. This is much faster than creating a new array (which v8 expands to
-    // a capacity of 17 after pushing the first item), or slicing out a subarray
-    // (which is slow). Length 4 is assumed to be the most frequent, followed by
-    // length 5 (since not everything will have an associated name), followed by
-    // length 1 (it's probably rare for a source substring to not have an
-    // associated segment data).
-    if (j === 4)
-        line.push([segment[0], segment[1], segment[2], segment[3]]);
-    else if (j === 5)
-        line.push([segment[0], segment[1], segment[2], segment[3], segment[4]]);
-    else if (j === 1)
-        line.push([segment[0]]);
-}
-
 function decodedSourcemap(map) {
     if (!map)
         return null;
@@ -16767,7 +16795,6 @@ class Bundle {
                 if ('code' in file) {
                     try {
                         this.graph.contextParse(file.code, {
-                            allowHashBang: true,
                             ecmaVersion: 'latest'
                         });
                     }
@@ -22428,7 +22455,7 @@ function tokenizer(input, options) {
   return Parser.tokenizer(input, options)
 }
 
-const acorn = /*#__PURE__*/Object.defineProperty({
+const _acorn = /*#__PURE__*/Object.defineProperty({
   __proto__: null,
   Node,
   Parser,
@@ -22513,13 +22540,27 @@ function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolve
             resolve: (source, importer, { assertions, custom, isEntry, skipSelf } = BLANK) => moduleLoaderResolveId(source, importer, custom, isEntry, assertions || EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip)
         });
     }
-    return pluginDriver.hookFirst('resolveId', [source, importer, { assertions, custom: customOptions, isEntry }], replaceContext, skipped);
+    return pluginDriver.hookFirstAndGetPlugin('resolveId', [source, importer, { assertions, custom: customOptions, isEntry }], replaceContext, skipped);
 }
 
 async function resolveId(source, importer, preserveSymlinks, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, assertions) {
     const pluginResult = await resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, assertions);
-    if (pluginResult != null)
-        return pluginResult;
+    if (pluginResult != null) {
+        const [resolveIdResult, plugin] = pluginResult;
+        if (typeof resolveIdResult === 'object' && !resolveIdResult.resolvedBy) {
+            return {
+                ...resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        if (typeof resolveIdResult === 'string') {
+            return {
+                id: resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        return resolveIdResult;
+    }
     // external modules (non-entry modules that start with neither '.' or '/')
     // are skipped at this stage.
     if (importer !== undefined && !isAbsolute(source) && source[0] !== '.')
@@ -23069,6 +23110,7 @@ class ModuleLoader {
             id: resolvedId.id,
             meta: resolvedId.meta || {},
             moduleSideEffects: resolvedId.moduleSideEffects ?? this.hasModuleSideEffects(resolvedId.id, !!external),
+            resolvedBy: resolvedId.resolvedBy ?? 'rollup',
             syntheticNamedExports: resolvedId.syntheticNamedExports ?? false
         };
     }
@@ -23101,6 +23143,7 @@ class ModuleLoader {
                 id: source,
                 meta: {},
                 moduleSideEffects: this.hasModuleSideEffects(source, true),
+                resolvedBy: 'rollup',
                 syntheticNamedExports: false
             };
         }
@@ -23551,17 +23594,18 @@ class PluginDriver {
     }
     // chains, first non-null result stops and returns
     hookFirst(hookName, parameters, replaceContext, skipped) {
-        let promise = Promise.resolve(null);
+        return this.hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped).then(result => result && result[0]);
+    }
+    // chains, first non-null result stops and returns result and last plugin
+    async hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped) {
         for (const plugin of this.getSortedPlugins(hookName)) {
-            if (skipped && skipped.has(plugin))
+            if (skipped?.has(plugin))
                 continue;
-            promise = promise.then(result => {
-                if (result != null)
-                    return result;
-                return this.runHook(hookName, parameters, plugin, replaceContext);
-            });
+            const result = await this.runHook(hookName, parameters, plugin, replaceContext);
+            if (result != null)
+                return [result, plugin];
         }
-        return promise;
+        return null;
     }
     // chains synchronously, first non-null result stops and returns
     hookFirstSync(hookName, parameters, replaceContext) {
@@ -24024,26 +24068,11 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
     return result;
 }
 
-var lib = {};
-
-const require$$0 = /*@__PURE__*/getAugmentedNamespace(acorn);
-
-Object.defineProperty(lib, "__esModule", {
-  value: true
-});
-var importAssertions_1 = lib.importAssertions = importAssertions;
-
-var _acorn = _interopRequireWildcard(require$$0);
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 const leftCurlyBrace = "{".charCodeAt(0);
 const space = " ".charCodeAt(0);
+
 const keyword = "assert";
-const FUNC_STATEMENT = 1,
-      FUNC_NULLABLE_ID = 4;
+const FUNC_STATEMENT = 1, FUNC_NULLABLE_ID = 4;
 
 function importAssertions(Parser) {
   // Use supplied version acorn version if present, to avoid
@@ -24052,10 +24081,8 @@ function importAssertions(Parser) {
   // its own internal version of acorn and thereby sidesteps
   // the package manager.
   const acorn = Parser.acorn || _acorn;
-  const {
-    tokTypes: tt,
-    TokenType
-  } = acorn;
+  const { tokTypes: tt, TokenType } = acorn;
+
   return class extends Parser {
     constructor(...args) {
       super(...args);
@@ -24070,21 +24097,19 @@ function importAssertions(Parser) {
       if (this.type !== t) {
         this.unexpected();
       }
-
       this.next();
     }
 
     readToken(code) {
       let i = 0;
-
       for (; i < keyword.length; i++) {
         if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
           return super.readToken(code);
         }
-      } // ensure that the keyword is at the correct location
-      // ie `assert{...` or `assert {...`
-
+      }
 
+      // ensure that the keyword is at the correct location
+      // ie `assert{...` or `assert {...`
       for (;; i++) {
         if (this._codeAt(this.pos + i) === leftCurlyBrace) {
           // Found '{'
@@ -24095,11 +24120,11 @@ function importAssertions(Parser) {
         } else {
           return super.readToken(code);
         }
-      } // If we're inside a dynamic import expression we'll parse
+      }
+
+      // If we're inside a dynamic import expression we'll parse
       // the `assert` keyword as a standard object property name
       // ie `import(""./foo.json", { assert: { type: "json" } })`
-
-
       if (this.type.label === "{") {
         return super.readToken(code);
       }
@@ -24110,24 +24135,22 @@ function importAssertions(Parser) {
 
     parseDynamicImport(node) {
       this.next(); // skip `(`
-      // Parse node.source.
 
+      // Parse node.source.
       node.source = this.parseMaybeAssign();
 
       if (this.eat(tt.comma)) {
         const obj = this.parseObj(false);
         node.arguments = [obj];
       }
-
       this._eat(tt.parenR);
-
       return this.finishNode(node, "ImportExpression");
-    } // ported from acorn/src/statement.js pp.parseExport
-
+    }
 
+    // ported from acorn/src/statement.js pp.parseExport
     parseExport(node, exports) {
-      this.next(); // export * from '...'
-
+      this.next();
+      // export * from '...'
       if (this.eat(tt.star)) {
         if (this.options.ecmaVersion >= 11) {
           if (this.eatContextual("as")) {
@@ -24137,41 +24160,28 @@ function importAssertions(Parser) {
             node.exported = null;
           }
         }
-
         this.expectContextual("from");
-
-        if (this.type !== tt.string) {
-          this.unexpected();
-        }
-
+        if (this.type !== tt.string) { this.unexpected(); }
         node.source = this.parseExprAtom();
 
         if (this.type === this.assertToken) {
           this.next();
           const assertions = this.parseImportAssertions();
-
           if (assertions) {
             node.assertions = assertions;
           }
         }
 
         this.semicolon();
-        return this.finishNode(node, "ExportAllDeclaration");
+        return this.finishNode(node, "ExportAllDeclaration")
       }
-
-      if (this.eat(tt._default)) {
-        // export default ...
+      if (this.eat(tt._default)) { // export default ...
         this.checkExport(exports, "default", this.lastTokStart);
         var isAsync;
-
         if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
           var fNode = this.startNode();
           this.next();
-
-          if (isAsync) {
-            this.next();
-          }
-
+          if (isAsync) { this.next(); }
           node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
         } else if (this.type === tt._class) {
           var cNode = this.startNode();
@@ -24180,38 +24190,27 @@ function importAssertions(Parser) {
           node.declaration = this.parseMaybeAssign();
           this.semicolon();
         }
-
-        return this.finishNode(node, "ExportDefaultDeclaration");
-      } // export var|const|let|function|class ...
-
-
+        return this.finishNode(node, "ExportDefaultDeclaration")
+      }
+      // export var|const|let|function|class ...
       if (this.shouldParseExportStatement()) {
         node.declaration = this.parseStatement(null);
-
-        if (node.declaration.type === "VariableDeclaration") {
-          this.checkVariableExport(exports, node.declaration.declarations);
-        } else {
-          this.checkExport(exports, node.declaration.id.name, node.declaration.id.start);
-        }
-
+        if (node.declaration.type === "VariableDeclaration")
+          { this.checkVariableExport(exports, node.declaration.declarations); }
+        else
+          { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
         node.specifiers = [];
         node.source = null;
-      } else {
-        // export { x, y as z } [from '...']
+      } else { // export { x, y as z } [from '...']
         node.declaration = null;
         node.specifiers = this.parseExportSpecifiers(exports);
-
         if (this.eatContextual("from")) {
-          if (this.type !== tt.string) {
-            this.unexpected();
-          }
-
+          if (this.type !== tt.string) { this.unexpected(); }
           node.source = this.parseExprAtom();
 
           if (this.type === this.assertToken) {
             this.next();
             const assertions = this.parseImportAssertions();
-
             if (assertions) {
               node.assertions = assertions;
             }
@@ -24220,52 +24219,47 @@ function importAssertions(Parser) {
           for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
             // check for keywords used as local names
             var spec = list[i];
-            this.checkUnreserved(spec.local); // check if export is defined
 
+            this.checkUnreserved(spec.local);
+            // check if export is defined
             this.checkLocalExport(spec.local);
           }
 
           node.source = null;
         }
-
         this.semicolon();
       }
-
-      return this.finishNode(node, "ExportNamedDeclaration");
+      return this.finishNode(node, "ExportNamedDeclaration")
     }
 
     parseImport(node) {
-      this.next(); // import '...'
-
+      this.next();
+      // import '...'
       if (this.type === tt.string) {
         node.specifiers = [];
         node.source = this.parseExprAtom();
       } else {
         node.specifiers = this.parseImportSpecifiers();
         this.expectContextual("from");
-        node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+        node.source =
+          this.type === tt.string ? this.parseExprAtom() : this.unexpected();
       }
 
       if (this.type === this.assertToken) {
         this.next();
         const assertions = this.parseImportAssertions();
-
         if (assertions) {
           node.assertions = assertions;
         }
       }
-
       this.semicolon();
       return this.finishNode(node, "ImportDeclaration");
     }
 
     parseImportAssertions() {
       this._eat(tt.braceL);
-
       const attrs = this.parseAssertEntries();
-
       this._eat(tt.braceR);
-
       return attrs;
     }
 
@@ -24278,38 +24272,40 @@ function importAssertions(Parser) {
           break;
         }
 
-        const node = this.startNode(); // parse AssertionKey : IdentifierName, StringLiteral
+        const node = this.startNode();
 
+        // parse AssertionKey : IdentifierName, StringLiteral
         let assertionKeyNode;
-
         if (this.type === tt.string) {
           assertionKeyNode = this.parseLiteral(this.value);
         } else {
           assertionKeyNode = this.parseIdent(true);
         }
-
         this.next();
-        node.key = assertionKeyNode; // check if we already have an entry for an attribute
+        node.key = assertionKeyNode;
+
+        // check if we already have an entry for an attribute
         // if a duplicate entry is found, throw an error
         // for now this logic will come into play only when someone declares `type` twice
-
         if (attrNames.has(node.key.name)) {
           this.raise(this.pos, "Duplicated key in assertions");
         }
-
         attrNames.add(node.key.name);
 
         if (this.type !== tt.string) {
-          this.raise(this.pos, "Only string is supported as an assertion value");
+          this.raise(
+            this.pos,
+            "Only string is supported as an assertion value"
+          );
         }
 
         node.value = this.parseLiteral(this.value);
+
         attrs.push(this.finishNode(node, "ImportAttribute"));
       } while (this.eat(tt.comma));
 
       return attrs;
     }
-
   };
 }
 
@@ -24463,14 +24459,12 @@ const getOnwarn = (config) => {
         : defaultOnWarn;
 };
 const getAcorn = (config) => ({
-    allowAwaitOutsideFunction: true,
     ecmaVersion: 'latest',
-    preserveParens: false,
     sourceType: 'module',
     ...config.acorn
 });
 const getAcornInjectPlugins = (config) => [
-    importAssertions_1,
+    importAssertions,
     ...ensureArray(config.acornInjectPlugins)
 ];
 const getCache = (config) => config.cache?.cache || config.cache;
@@ -24537,7 +24531,7 @@ const getModuleContext = (config, context) => {
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
             contextByModuleId[resolve(key)] = moduleContext;
         }
-        return id => contextByModuleId[id] || context;
+        return id => contextByModuleId[id] ?? context;
     }
     return () => context;
 };