rollup 3.9.0 → 3.10.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.9.0
-	Wed, 28 Dec 2022 05:59:30 GMT - commit 5aa1cce444e767c40cf86cdd96953201e4d32774
+	Rollup.js v3.10.0
+	Thu, 12 Jan 2023 07:56:20 GMT - commit ffc19b0091267d9bf5072b16969599e457a63f5c
 
 	https://github.com/rollup/rollup
 
@@ -12,132 +12,172 @@ import require$$0$1, { win32, posix, isAbsolute as isAbsolute$1, resolve as reso
 import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
 import { createHash as createHash$1 } from 'node:crypto';
-import { promises } from 'node:fs';
+import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.9.0";
-
-var charToInteger = {};
-var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$1 = 0; i$1 < chars$1.length; i$1++) {
-    charToInteger[chars$1.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;
+var version$1 = "3.10.0";
+
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+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$1.length; i++) {
+    const c = chars$1.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
         }
-        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;
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                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 {
-                var shouldNegate = value & 1;
-                value >>>= 1;
-                if (shouldNegate) {
-                    value = value === 0 ? -0x80000000 : -value;
-                }
-                segment[j] += value;
-                j++;
-                value = shift = 0; // reset
+                seg = [col];
             }
+            line.push(seg);
         }
-    }
-    segmentify(line, segment, j);
-    decoded.push(line);
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        index = semi + 1;
+    } while (index <= mappings.length);
     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 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) {
-    var sourceFileIndex = 0; // second field
-    var sourceCodeLine = 0; // third field
-    var sourceCodeColumn = 0; // fourth field
-    var nameIndex = 0; // fifth field
-    var mappings = '';
-    for (var i = 0; i < decoded.length; i++) {
-        var line = decoded[i];
-        if (i > 0)
-            mappings += ';';
+    const state = new Int32Array(5);
+    const bufLength = 1024 * 16;
+    const subLength = bufLength - 36;
+    const buf = new Uint8Array(bufLength);
+    const sub = buf.subarray(0, subLength);
+    let pos = 0;
+    let out = '';
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0) {
+            if (pos === bufLength) {
+                out += td.decode(buf);
+                pos = 0;
+            }
+            buf[pos++] = semicolon;
+        }
         if (line.length === 0)
             continue;
-        var generatedCodeColumn = 0; // first field
-        var lineMappings = [];
-        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
-            var segment = line_1[_i];
-            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
-            generatedCodeColumn = segment[0];
-            if (segment.length > 1) {
-                segmentMappings +=
-                    encodeInteger(segment[1] - sourceFileIndex) +
-                        encodeInteger(segment[2] - sourceCodeLine) +
-                        encodeInteger(segment[3] - sourceCodeColumn);
-                sourceFileIndex = segment[1];
-                sourceCodeLine = segment[2];
-                sourceCodeColumn = segment[3];
-            }
-            if (segment.length === 5) {
-                segmentMappings += encodeInteger(segment[4] - nameIndex);
-                nameIndex = segment[4];
-            }
-            lineMappings.push(segmentMappings);
-        }
-        mappings += lineMappings.join(',');
-    }
-    return mappings;
-}
-function encodeInteger(num) {
-    var result = '';
+        state[0] = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            // We can push up to 5 ints, each int can take at most 7 chars, and we
+            // may push a comma.
+            if (pos > subLength) {
+                out += td.decode(sub);
+                buf.copyWithin(0, subLength, pos);
+                pos -= subLength;
+            }
+            if (j > 0)
+                buf[pos++] = comma;
+            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+            if (segment.length === 1)
+                continue;
+            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
+            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
+            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            if (segment.length === 4)
+                continue;
+            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+        }
+    }
+    return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+    const next = segment[j];
+    let num = next - state[j];
+    state[j] = next;
     num = num < 0 ? (-num << 1) | 1 : num << 1;
     do {
-        var clamped = num & 31;
+        let clamped = num & 0b011111;
         num >>>= 5;
-        if (num > 0) {
-            clamped |= 32;
-        }
-        result += chars$1[clamped];
+        if (num > 0)
+            clamped |= 0b100000;
+        buf[pos++] = intToChar[clamped];
     } while (num > 0);
-    return result;
+    return pos;
 }
 
 class BitSet {
@@ -1631,7 +1671,7 @@ function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName)
             return [...relativePath.split('/'), '..', basename(targetPath)].join('/');
         }
     }
-    return !relativePath ? '.' : relativePath.startsWith('..') ? relativePath : './' + relativePath;
+    return relativePath ? (relativePath.startsWith('..') ? relativePath : './' + relativePath) : '.';
 }
 
 class ExternalChunk {
@@ -2234,7 +2274,7 @@ function errorInternalIdCannotBeExternal(source, importer) {
 function errorInvalidOption(option, urlHash, explanation, value) {
     return {
         code: INVALID_OPTION,
-        message: `Invalid value ${value !== undefined ? `${JSON.stringify(value)} ` : ''}for option "${option}" - ${explanation}.`,
+        message: `Invalid value ${value === undefined ? '' : `${JSON.stringify(value)} `}for option "${option}" - ${explanation}.`,
         url: `https://rollupjs.org/guide/en/#${urlHash}`
     };
 }
@@ -2702,9 +2742,16 @@ function getDefaultExportFromCjs (x) {
 }
 
 function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
   var f = n.default;
 	if (typeof f == "function") {
-		var a = function () {
+		var a = function a () {
+			if (this instanceof a) {
+				var args = [null];
+				args.push.apply(args, arguments);
+				var Ctor = Function.bind.apply(f, args);
+				return new Ctor();
+			}
 			return f.apply(this, arguments);
 		};
 		a.prototype = f.prototype;
@@ -2722,7 +2769,11 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-var picomatch$1 = {exports: {}};
+var picomatchExports = {};
+var picomatch$1 = {
+  get exports(){ return picomatchExports; },
+  set exports(v){ picomatchExports = v; },
+};
 
 var utils$3 = {};
 
@@ -4789,7 +4840,7 @@ var picomatch_1 = picomatch;
 	module.exports = picomatch_1;
 } (picomatch$1));
 
-const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch$1.exports);
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
 
 const extractors = {
     ArrayPattern(names, param) {
@@ -4892,8 +4943,8 @@ const createFilter = function createFilter(include, exclude, options) {
 };
 
 const reservedWords$1 = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
-const builtins$1 = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
-const forbiddenIdentifiers = new Set(`${reservedWords$1} ${builtins$1}`.split(' '));
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords$1} ${builtins}`.split(' '));
 forbiddenIdentifiers.add('');
 
 const BROKEN_FLOW_NONE = 0;
@@ -6091,21 +6142,7 @@ class ObjectEntity extends ExpressionEntity {
         for (let index = properties.length - 1; index >= 0; index--) {
             const { key, kind, property } = properties[index];
             allProperties.push(property);
-            if (typeof key !== 'string') {
-                if (key === UnknownInteger) {
-                    unknownIntegerProps.push(property);
-                    continue;
-                }
-                if (kind === 'set')
-                    unmatchableSetters.push(property);
-                if (kind === 'get')
-                    unmatchableGetters.push(property);
-                if (kind !== 'get')
-                    unmatchablePropertiesAndSetters.push(property);
-                if (kind !== 'set')
-                    unmatchablePropertiesAndGetters.push(property);
-            }
-            else {
+            if (typeof key === 'string') {
                 if (kind === 'set') {
                     if (!propertiesAndSettersByKey[key]) {
                         propertiesAndSettersByKey[key] = [property, ...unmatchablePropertiesAndSetters];
@@ -6127,6 +6164,20 @@ class ObjectEntity extends ExpressionEntity {
                     }
                 }
             }
+            else {
+                if (key === UnknownInteger) {
+                    unknownIntegerProps.push(property);
+                    continue;
+                }
+                if (kind === 'set')
+                    unmatchableSetters.push(property);
+                if (kind === 'get')
+                    unmatchableGetters.push(property);
+                if (kind !== 'get')
+                    unmatchablePropertiesAndSetters.push(property);
+                if (kind !== 'set')
+                    unmatchablePropertiesAndGetters.push(property);
+            }
         }
     }
     deoptimizeCachedEntities() {
@@ -6324,8 +6375,6 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
-    group: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
-    groupToMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
     join: METHOD_RETURNS_STRING,
@@ -6396,11 +6445,11 @@ class ArrayExpression extends NodeBase {
                     properties.unshift({ key: UnknownInteger, kind: 'init', property: element });
                 }
             }
-            else if (!element) {
-                properties.push({ key: String(index), kind: 'init', property: UNDEFINED_EXPRESSION });
+            else if (element) {
+                properties.push({ key: String(index), kind: 'init', property: element });
             }
             else {
-                properties.push({ key: String(index), kind: 'init', property: element });
+                properties.push({ key: String(index), kind: 'init', property: UNDEFINED_EXPRESSION });
             }
         }
         return (this.objectEntity = new ObjectEntity(properties, ARRAY_PROTOTYPE));
@@ -6817,7 +6866,6 @@ class ReturnValueScope extends ParameterScope {
     }
 }
 
-//@ts-check
 /** @typedef { import('estree').Node} Node */
 /** @typedef {Node | {
  *   type: 'PropertyDefinition';
@@ -6829,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') {
@@ -9433,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 {
@@ -9603,9 +9678,9 @@ class ClassNode extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return interaction.type === INTERACTION_CALLED && path.length === 0
             ? !interaction.withNew ||
-                (this.classConstructor !== null
-                    ? this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)
-                    : this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
+                (this.classConstructor === null
+                    ? this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)
+                    : this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
                 false
             : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
@@ -9782,12 +9857,12 @@ class ConditionalExpression extends NodeBase {
     }
     deoptimizePath(path) {
         const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            this.consequent.deoptimizePath(path);
-            this.alternate.deoptimizePath(path);
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
         }
         else {
-            usedBranch.deoptimizePath(path);
+            this.consequent.deoptimizePath(path);
+            this.alternate.deoptimizePath(path);
         }
     }
     deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
@@ -9845,17 +9920,22 @@ class ConditionalExpression extends NodeBase {
     }
     includeCallArguments(context, parameters) {
         const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            this.consequent.includeCallArguments(context, parameters);
-            this.alternate.includeCallArguments(context, parameters);
+        if (usedBranch) {
+            usedBranch.includeCallArguments(context, parameters);
         }
         else {
-            usedBranch.includeCallArguments(context, parameters);
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
         }
     }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
         const usedBranch = this.getUsedBranch();
-        if (!this.test.included) {
+        if (this.test.included) {
+            this.test.render(code, options, { renderedSurroundingElement });
+            this.consequent.render(code, options);
+            this.alternate.render(code, options);
+        }
+        else {
             const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
             const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
                 ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
@@ -9875,11 +9955,6 @@ class ConditionalExpression extends NodeBase {
                 renderedSurroundingElement: renderedSurroundingElement || this.parent.type
             });
         }
-        else {
-            this.test.render(code, options, { renderedSurroundingElement });
-            this.consequent.render(code, options);
-            this.alternate.render(code, options);
-        }
     }
     getUsedBranch() {
         if (this.isBranchResolutionAnalysed) {
@@ -10917,12 +10992,12 @@ class LogicalExpression extends NodeBase {
     }
     deoptimizePath(path) {
         const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            this.left.deoptimizePath(path);
-            this.right.deoptimizePath(path);
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
         }
         else {
-            usedBranch.deoptimizePath(path);
+            this.left.deoptimizePath(path);
+            this.right.deoptimizePath(path);
         }
     }
     deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
@@ -12121,7 +12196,10 @@ class VariableDeclaration extends NodeBase {
             code.remove(this.end - 1, this.end);
         }
         separatorString += ';';
-        if (lastSeparatorPos !== null) {
+        if (lastSeparatorPos === null) {
+            code.appendLeft(renderedContentEnd, separatorString);
+        }
+        else {
             if (code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/ &&
                 (code.original.charCodeAt(this.end) === 10 /*"\n"*/ ||
                     code.original.charCodeAt(this.end) === 13) /*"\r"*/) {
@@ -12138,9 +12216,6 @@ class VariableDeclaration extends NodeBase {
                 code.remove(actualContentEnd, renderedContentEnd);
             }
         }
-        else {
-            code.appendLeft(renderedContentEnd, separatorString);
-        }
         if (systemPatternExports.length > 0) {
             code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
         }
@@ -12464,7 +12539,8 @@ class NamespaceVariable extends Variable {
             return this.memberVariables;
         }
         const memberVariables = Object.create(null);
-        for (const name of [...this.context.getExports(), ...this.context.getReexports()]) {
+        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
+        for (const name of sortedExports) {
             if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
                 const exportedVariable = this.context.traceExport(name);
                 if (exportedVariable) {
@@ -13268,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;
@@ -13372,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;
@@ -13661,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
@@ -13691,7 +13767,7 @@ function getCompleteAmdId(options, chunkId) {
     if (options.autoId) {
         return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
     }
-    return options.id || '';
+    return options.id ?? '';
 }
 
 function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, mechanism = 'return ') {
@@ -13898,33 +13974,82 @@ function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
     return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
 }
 
-const builtins = {
-    assert: 1,
-    buffer: 1,
-    console: 1,
-    constants: 1,
-    domain: 1,
-    events: 1,
-    http: 1,
-    https: 1,
-    os: 1,
-    path: 1,
-    process: 1,
-    punycode: 1,
-    querystring: 1,
-    stream: 1,
-    string_decoder: 1,
-    timers: 1,
-    tty: 1,
-    url: 1,
-    util: 1,
-    vm: 1,
-    zlib: 1
-};
+var _staticExports = {};
+var _static = {
+  get exports(){ return _staticExports; },
+  set exports(v){ _staticExports = v; },
+};
+
+const require$$0 = [
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"timers",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+];
+
+(function (module) {
+	module.exports = require$$0;
+} (_static));
+
+const builtinModules = /*@__PURE__*/getDefaultExportFromCjs(_staticExports);
+
+const nodeBuiltins = new Set([
+    ...builtinModules,
+    // TODO
+    // remove once builtin-modules includes PR: https://github.com/sindresorhus/builtin-modules/pull/17
+    'assert/strict',
+    'dns/promises',
+    'fs/promises',
+    'path/posix',
+    'path/win32',
+    'readline/promises',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
+    'timers/promises',
+    'util/types'
+]);
 function warnOnBuiltins(warn, dependencies) {
     const externalBuiltins = dependencies
         .map(({ importPath }) => importPath)
-        .filter(importPath => importPath in builtins || importPath.startsWith('node:'));
+        .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
     if (externalBuiltins.length === 0)
         return;
     warn(errorMissingNodeBuiltins(externalBuiltins));
@@ -15076,10 +15201,7 @@ class Chunk {
         if (file) {
             fileName = basename(file);
         }
-        else if (this.fileName !== null) {
-            fileName = this.fileName;
-        }
-        else {
+        else if (this.fileName === null) {
             const [pattern, patternName] = preserveModules || this.facadeModule?.isUserDefinedEntryPoint
                 ? [entryFileNames, 'output.entryFileNames']
                 : [chunkFileNames, 'output.chunkFileNames'];
@@ -15092,6 +15214,9 @@ class Chunk {
                 fileName = makeUnique(fileName, this.bundle);
             }
         }
+        else {
+            fileName = this.fileName;
+        }
         if (!hashPlaceholder) {
             this.bundle[fileName] = FILE_PLACEHOLDER;
         }
@@ -16338,10 +16463,7 @@ function getLinkMap(warn) {
 }
 function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, linkMap) {
     let source;
-    if (!originalSourcemap) {
-        source = new Source(id, originalCode);
-    }
-    else {
+    if (originalSourcemap) {
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
         const directory = dirname(id) || '.';
@@ -16349,6 +16471,9 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
         const baseSources = sources.map((source, index) => new Source(resolve(directory, sourceRoot, source), sourcesContent[index]));
         source = new Link(originalSourcemap, baseSources);
     }
+    else {
+        source = new Source(id, originalCode);
+    }
     return sourcemapChain.reduce(linkMap, source);
 }
 function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, warn) {
@@ -16670,7 +16795,6 @@ class Bundle {
                 if ('code' in file) {
                     try {
                         this.graph.contextParse(file.code, {
-                            allowHashBang: true,
                             ecmaVersion: 'latest'
                         });
                     }
@@ -22281,7 +22405,7 @@ pp.readWord = function() {
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version = "8.8.0";
+var version = "8.8.1";
 
 Parser.acorn = {
   Parser: Parser,
@@ -22331,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,
@@ -22416,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] !== '.')
@@ -22440,13 +22578,13 @@ async function addJsExtensionIfNecessary(file, preserveSymlinks) {
 }
 async function findFile(file, preserveSymlinks) {
     try {
-        const stats = await promises.lstat(file);
+        const stats = await lstat(file);
         if (!preserveSymlinks && stats.isSymbolicLink())
-            return await findFile(await promises.realpath(file), preserveSymlinks);
+            return await findFile(await realpath(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
             const name = basename(file);
-            const files = await promises.readdir(dirname(file));
+            const files = await readdir(dirname(file));
             if (files.includes(name))
                 return file;
         }
@@ -22691,15 +22829,15 @@ class ModuleLoader {
                     entryModule.isUserDefinedEntryPoint || isUserDefined;
                 addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined, firstChunkNamePriority + index);
                 const existingIndexedModule = this.indexedEntryModules.find(indexedModule => indexedModule.module === entryModule);
-                if (!existingIndexedModule) {
+                if (existingIndexedModule) {
+                    existingIndexedModule.index = Math.min(existingIndexedModule.index, firstEntryModuleIndex + index);
+                }
+                else {
                     this.indexedEntryModules.push({
                         index: firstEntryModuleIndex + index,
                         module: entryModule
                     });
                 }
-                else {
-                    existingIndexedModule.index = Math.min(existingIndexedModule.index, firstEntryModuleIndex + index);
-                }
             }
             this.indexedEntryModules.sort(({ index: indexA }, { index: indexB }) => indexA > indexB ? 1 : -1);
             return entryModules;
@@ -22750,7 +22888,7 @@ class ModuleLoader {
     async addModuleSource(id, importer, module) {
         let source;
         try {
-            source = await this.graph.fileOperationQueue.run(async () => (await this.pluginDriver.hookFirst('load', [id])) ?? (await promises.readFile(id, 'utf8')));
+            source = await this.graph.fileOperationQueue.run(async () => (await this.pluginDriver.hookFirst('load', [id])) ?? (await readFile(id, 'utf8')));
         }
         catch (error_) {
             let message = `Could not load ${id}`;
@@ -22972,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
         };
     }
@@ -23004,6 +23143,7 @@ class ModuleLoader {
                 id: source,
                 meta: {},
                 moduleSideEffects: this.hasModuleSideEffects(source, true),
+                resolvedBy: 'rollup',
                 syntheticNamedExports: false
             };
         }
@@ -23215,8 +23355,11 @@ class FileEmitter {
             this.facadeChunkByModule = facadeChunkByModule;
         };
         this.setOutputBundle = (bundle, outputOptions) => {
-            const fileNamesBySource = new Map();
-            const output = (this.output = { bundle, fileNamesBySource, outputOptions });
+            const output = (this.output = {
+                bundle,
+                fileNamesBySource: new Map(),
+                outputOptions
+            });
             for (const emittedFile of this.filesByReferenceId.values()) {
                 if (emittedFile.fileName) {
                     reserveFileNameInBundle(emittedFile.fileName, output, this.options.onwarn);
@@ -23237,12 +23380,9 @@ class FileEmitter {
         this.outputFileEmitters.push(outputFileEmitter);
     }
     assignReferenceId(file, idBase) {
-        let referenceId;
+        let referenceId = idBase;
         do {
-            referenceId = createHash()
-                .update(referenceId || idBase)
-                .digest('hex')
-                .slice(0, 8);
+            referenceId = createHash().update(referenceId).digest('hex').slice(0, 8);
         } while (this.filesByReferenceId.has(referenceId) ||
             this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
         this.filesByReferenceId.set(referenceId, file);
@@ -23252,9 +23392,9 @@ class FileEmitter {
         return referenceId;
     }
     emitAsset(emittedAsset) {
-        const source = typeof emittedAsset.source !== 'undefined'
-            ? getValidSource(emittedAsset.source, emittedAsset, null)
-            : undefined;
+        const source = emittedAsset.source === undefined
+            ? undefined
+            : getValidSource(emittedAsset.source, emittedAsset, null);
         const consumedAsset = {
             fileName: emittedAsset.fileName,
             name: emittedAsset.name,
@@ -23454,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) {
@@ -23927,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
@@ -23955,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);
@@ -23973,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 '{'
@@ -23998,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);
       }
@@ -24013,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")) {
@@ -24040,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();
@@ -24083,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;
             }
@@ -24123,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;
     }
 
@@ -24181,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;
     }
-
   };
 }
 
@@ -24366,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;
@@ -24440,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;
 };
@@ -24477,7 +24568,7 @@ const getHasModuleSideEffects = (moduleSideEffectsOption) => {
         return (_id, external) => !external;
     }
     if (typeof moduleSideEffectsOption === 'function') {
-        return (id, external) => !id.startsWith('\0') ? moduleSideEffectsOption(id, external) !== false : true;
+        return (id, external) => id.startsWith('\0') ? true : moduleSideEffectsOption(id, external) !== false;
     }
     if (Array.isArray(moduleSideEffectsOption)) {
         const ids = new Set(moduleSideEffectsOption);
@@ -24941,8 +25032,8 @@ function getSortingFileType(file) {
 async function writeOutputFile(outputFile, outputOptions) {
     const fileName = resolve(outputOptions.dir || dirname(outputOptions.file), outputFile.fileName);
     // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
-    await promises.mkdir(dirname(fileName), { recursive: true });
-    return promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
+    await mkdir(dirname(fileName), { recursive: true });
+    return writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
 }
 /**
  * Auxiliary function for defining rollup configuration
@@ -25340,8 +25431,8 @@ function getFsEvents() {
 
 const fseventsImporter = /*#__PURE__*/Object.defineProperty({
   __proto__: null,
-  loadFsEvents,
-  getFsEvents
+  getFsEvents,
+  loadFsEvents
 }, Symbol.toStringTag, { value: 'Module' });
 
 function watch(configs) {
@@ -25362,4 +25453,4 @@ async function watchInternal(configs, emitter) {
     new Watcher(watchOptionsList, emitter);
 }
 
-export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, picomatch$1 as picomatch, rollup, rollupInternal, version$1 as version, watch };
+export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, picomatchExports, rollup, rollupInternal, version$1 as version, watch };