@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/{extension-tools-d0cfdea1.js → extension-tools-0c4c1ad7.js}

@@ -7,7 +7,6 @@ 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 { mkdir, writeFile, readFile, lstat, realpath, readdir } from 'node:fs/promises';
-import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 import { addExtension } from '@rollup/pluginutils';
 
@@ -1401,6 +1400,9 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+/**
+ * Extracted from json.ts to keep json nls free.
+ */
 function getParseErrorMessage(errorCode) {
     switch (errorCode) {
         case 1 /* ParseErrorCode.InvalidSymbol */: return localize('error.invalidSymbol', 'Invalid symbol');
@@ -1419,15 +1421,15 @@ function getParseErrorMessage(errorCode) {
 
 /*
   @license
-	Rollup.js v3.21.3
-	Tue, 02 May 2023 04:37:56 GMT - commit ef6ca52fec43ec4a7d6f12c8ebdee82ee690c2ce
+	Rollup.js v3.23.0
+	Mon, 22 May 2023 05:28:38 GMT - commit 5ea36552c447d2903050d2622f2dcae3dd2df975
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
 
-var version$1 = "3.21.3";
+var version$1 = "3.23.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -4763,6 +4765,7 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
 
 // AST walker module for Mozilla Parser API compatible trees
 
+
 function skipThrough(node, st, c) { c(node, st); }
 function ignore(_node, _st, _c) {}
 
@@ -6648,6 +6651,13 @@ const IMPURE = {
     getLiteralValue: getTruthyLiteralValue,
     hasEffectsWhenCalled: returnTrue
 };
+const PURE_WITH_ARRAY = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }) {
+        return args.length > 1 && !(args[1] instanceof ArrayExpression);
+    }
+};
 // We use shortened variables to reduce file size here
 /* OBJECT */
 const O = {
@@ -6685,6 +6695,11 @@ const PC = {
     [ValueProperties]: PURE,
     prototype: O
 };
+const PC_WITH_ARRAY = {
+    __proto__: null,
+    [ValueProperties]: PURE_WITH_ARRAY,
+    prototype: O
+};
 const ARRAY_TYPE = {
     __proto__: null,
     [ValueProperties]: PURE,
@@ -6755,7 +6770,7 @@ const knownGlobals = {
     isNaN: PF,
     isPrototypeOf: O,
     JSON: O,
-    Map: C,
+    Map: PC_WITH_ARRAY,
     Math: {
         __proto__: null,
         [ValueProperties]: IMPURE,
@@ -6851,7 +6866,7 @@ const knownGlobals = {
     ReferenceError: PC,
     Reflect: O,
     RegExp: PC,
-    Set: C,
+    Set: PC_WITH_ARRAY,
     SharedArrayBuffer: C,
     String: {
         __proto__: null,
@@ -6891,8 +6906,8 @@ const knownGlobals = {
     unescape: PF,
     URIError: PC,
     valueOf: O,
-    WeakMap: C,
-    WeakSet: C,
+    WeakMap: PC_WITH_ARRAY,
+    WeakSet: PC_WITH_ARRAY,
     // Additional globals shared by Node and Browser that are not strictly part of the language
     clearInterval: C,
     clearTimeout: C,
@@ -11361,6 +11376,14 @@ class Program extends NodeBase {
             code.remove(0, start);
         }
         if (this.body.length > 0) {
+            // Keep all consecutive lines that start with a comment
+            while (code.original[start] === '/' && /[*/]/.test(code.original[start + 1])) {
+                const firstLineBreak = findFirstLineBreakOutsideComment(code.original.slice(start, this.body[0].start));
+                if (firstLineBreak[0] === -1) {
+                    break;
+                }
+                start += firstLineBreak[1];
+            }
             renderStatementList(this.body, code, start, this.end, options);
         }
         else {
@@ -11604,6 +11627,7 @@ SwitchCase.prototype.needsBoundaries = true;
 
 class SwitchStatement extends NodeBase {
     createScope(parentScope) {
+        this.parentScope = parentScope;
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
@@ -11672,6 +11696,10 @@ class SwitchStatement extends NodeBase {
         }
         this.defaultCase = null;
     }
+    parseNode(esTreeNode) {
+        this.discriminant = new (this.context.getNodeConstructor(esTreeNode.discriminant.type))(esTreeNode.discriminant, this, this.parentScope);
+        super.parseNode(esTreeNode);
+    }
     render(code, options) {
         this.discriminant.render(code, options);
         if (this.cases.length > 0) {
@@ -12478,14 +12506,14 @@ class NamespaceVariable extends Variable {
         const memberVariables = this.getMemberVariables();
         const members = Object.entries(memberVariables)
             .filter(([_, variable]) => variable.included)
-            .map(([name, original]) => {
-            if (this.referencedEarly || original.isReassigned) {
+            .map(([name, variable]) => {
+            if (this.referencedEarly || variable.isReassigned || variable === this) {
                 return [
                     null,
-                    `get ${name}${_}()${_}{${_}return ${original.getName(getPropertyAccess)}${s}${_}}`
+                    `get ${name}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
                 ];
             }
-            return [name, original.getName(getPropertyAccess)];
+            return [name, variable.getName(getPropertyAccess)];
         });
         members.unshift([null, `__proto__:${_}null`]);
         let output = getObject(members, { lineBreakIndent: { base: '', t } });
@@ -12936,6 +12964,16 @@ class Module {
         this.addLocationToLogProps(properties, pos);
         return error(properties);
     }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
     getAllExportNames() {
         if (this.allExportNames) {
             return this.allExportNames;
@@ -13205,7 +13243,11 @@ class Module {
     isIncluded() {
         // Modules where this.ast is missing have been loaded via this.load and are
         // not yet fully processed, hence they cannot be included.
-        return (this.ast && (this.ast.included || this.namespace.included || this.importedFromNotTreeshaken));
+        return (this.ast &&
+            (this.ast.included ||
+                this.namespace.included ||
+                this.importedFromNotTreeshaken ||
+                this.exportShimVariable.included));
     }
     linkImports() {
         this.addModulesToImportDescriptions(this.importDescriptions);
@@ -14969,13 +15011,18 @@ class Chunk {
     }
     canModuleBeFacade(module, exposedVariables) {
         const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
                 return false;
             }
         }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
         for (const exposedVariable of exposedVariables) {
-            if (!(moduleExportNamesByVariable.has(exposedVariable) || exposedVariable.module === module)) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
                 return false;
             }
         }
@@ -15030,7 +15077,10 @@ class Chunk {
         for (const module of entryModules) {
             if (module.preserveSignature) {
                 for (const exportedVariable of module.getExportNamesByVariable().keys()) {
-                    exposedVariables.add(exportedVariable);
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
                 }
             }
         }
@@ -16007,11 +16057,14 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = Object.values(getChunksBySignature(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks)));
+    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
     // This mutates initialChunks but also clears
     // dynamicallyDependentEntriesByDynamicEntry as side effect
     removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...createChunks(allEntries, getChunksBySignature(initialChunks), minChunkSize));
+    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
     return chunkDefinitions;
 }
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
@@ -16117,7 +16170,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksBySignature(modulesWithDependentEntries) {
+function getChunksFromDependentEntries(modulesWithDependentEntries) {
     var _a;
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
@@ -16130,7 +16183,7 @@ function getChunksBySignature(modulesWithDependentEntries) {
             modules: []
         })).modules.push(...modules);
     }
-    return chunkModules;
+    return Object.values(chunkModules);
 }
 function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
     for (const [module, dependentEntries] of dependentEntriesByModule) {
@@ -16188,17 +16241,6 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
         chunkMask <<= 1n;
     }
 }
-function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
-    return minChunkSize === 0
-        ? Object.values(chunkModulesBySignature).map(({ modules }) => ({
-            alias: null,
-            modules
-        }))
-        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
-}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -16241,239 +16283,270 @@ function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
  * dependency side effects are AF.
  * For entry chunks, dependency and correlated side effects are the same.
  *
- * With these concepts, merging chunks is allowed if the correlated side effects
- * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
  * a) the dependency side effects of each chunk are a subset of the correlated
  *    side effects of the other chunk, so no additional side effects are
  *    triggered for any entry, or
- * b) The signature of chunk A is a subset of the signature of chunk B while the
- *    dependency side effects of A are a subset of the correlated side effects
- *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
- *    But there are cases when B is loaded where A is not loaded. So if we merge
- *    the chunks, all dependency side effects of A will be added to the
- *    correlated side effects of B, and as the latter is not allowed to change,
- *    the former need to be a subset of the latter.
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
  *
- * Another consideration when merging small chunks into other chunks is to avoid
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
  * that too much additional code is loaded. This is achieved when the dependent
- * entries of the small chunk are a subset of the dependent entries of the other
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
  * chunk. Because then when the small chunk is loaded, the other chunk was
  * loaded/in memory anyway, so at most when the other chunk is loaded, the
  * additional size of the small chunk is loaded unnecessarily.
  *
  * So the algorithm performs merges in two passes:
+ *
  * 1. First we try to merge small chunks A only into other chunks B if the
  *    dependent entries of A are a subset of the dependent entries of B and the
  *    dependency side effects of A are a subset of the correlated side effects
  *    of B.
  * 2. Only then for all remaining small chunks, we look for arbitrary merges
- *    following the above rules (a) and (b), starting with the smallest chunks
- *    to look for possible merge targets.
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
  */
-// TODO instead of picking the "closest" chunk, we could actually use a
-//  technique similar to what we do for side effects to compare the size of the
-//  static dependencies that are not part of the correlated dependencies
-function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
-    console.log('Before eliminating small chunks, there were\n', Object.keys(chunkModulesBySignature).length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
-    if (chunkPartition.small.size > 0) {
-        mergeChunks(chunkPartition, minChunkSize);
-    }
-    console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
+    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return initialChunks; // the actual modules
+    }
+    minChunkSize > 1 &&
+        console.log('Before eliminating small chunks, there were\n', initialChunks.length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
+    mergeChunks(chunkPartition, minChunkSize);
+    minChunkSize > 1 &&
+        console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
     const chunkByModule = new Map();
-    const sideEffectsByEntry = [];
-    for (let index = 0; index < numberOfEntries; index++) {
-        sideEffectsByEntry.push(new Set());
-    }
-    for (const [signature, { dependentEntries, modules }] of Object.entries(chunkModulesBySignature)) {
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let containedAtoms = 1n;
+    for (const { dependentEntries, modules } of initialChunks) {
         const chunkDescription = {
-            correlatedSideEffects: new Set(),
+            containedAtoms,
+            correlatedAtoms: 0n,
             dependencies: new Set(),
             dependentChunks: new Set(),
             dependentEntries,
             modules,
             pure: true,
-            sideEffects: new Set(),
             size: 0
         };
         let size = 0;
         let pure = true;
         for (const module of modules) {
             chunkByModule.set(module, chunkDescription);
-            pure && (pure = !module.hasEffects());
             // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet
-            size += module.originalCode.length;
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure && (pure = !module.hasEffects());
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                size += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
+        sizeByAtom.push(size);
         if (!pure) {
-            for (const entryIndex of dependentEntries) {
-                sideEffectsByEntry[entryIndex].add(signature);
-            }
-            // In the beginning, each chunk is only its own side effect. After
-            // merging, additional side effects can accumulate.
-            chunkDescription.sideEffects.add(signature);
+            sideEffectAtoms |= containedAtoms;
         }
         (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+        containedAtoms <<= 1n;
     }
-    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
+    // If there are no small chunks, we will not optimize
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
     return {
         big: new Set(bigChunks),
+        sideEffectAtoms,
+        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure && (bestTargetChunk.pure = pure);
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
+    const signatureByExternalModule = new Map();
+    let sideEffectAtoms = 0n;
+    const atomsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        atomsByEntry.push(0n);
+    }
     for (const chunks of chunkLists) {
         chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
+            const { dependencies, dependentEntries, modules } = chunk;
             for (const module of modules) {
                 for (const dependency of module.getDependenciesToBeIncluded()) {
-                    const dependencyChunk = chunkByModule.get(dependency);
-                    if (dependencyChunk && dependencyChunk !== chunk) {
-                        dependencies.add(dependencyChunk);
-                        dependencyChunk.dependentChunks.add(chunk);
-                    }
-                }
-            }
-            let firstEntry = true;
-            // Correlated side effects is the intersection of all entry side effects
-            for (const entryIndex of dependentEntries) {
-                const entryEffects = sideEffectsByEntry[entryIndex];
-                if (firstEntry) {
-                    for (const sideEffect of entryEffects) {
-                        correlatedSideEffects.add(sideEffect);
+                    if (dependency instanceof ExternalModule) {
+                        if (dependency.info.moduleSideEffects) {
+                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
+                                const signature = nextAtomSignature;
+                                nextAtomSignature <<= 1n;
+                                sideEffectAtoms |= signature;
+                                return signature;
+                            });
+                        }
                     }
-                    firstEntry = false;
-                }
-                else {
-                    for (const sideEffect of correlatedSideEffects) {
-                        if (!entryEffects.has(sideEffect)) {
-                            correlatedSideEffects.delete(sideEffect);
+                    else {
+                        const dependencyChunk = chunkByModule.get(dependency);
+                        if (dependencyChunk && dependencyChunk !== chunk) {
+                            dependencies.add(dependencyChunk);
+                            dependencyChunk.dependentChunks.add(chunk);
                         }
                     }
                 }
             }
+            const { containedAtoms } = chunk;
+            for (const entryIndex of dependentEntries) {
+                atomsByEntry[entryIndex] |= containedAtoms;
+            }
         }
     }
-}
-function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
-function mergeChunks(chunkPartition, minChunkSize) {
-    for (const allowArbitraryMerges of [false, true]) {
-        for (const mergedChunk of chunkPartition.small) {
-            let closestChunk = null;
-            let closestChunkDistance = Infinity;
-            const { modules, pure, size } = mergedChunk;
-            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
-                if (mergedChunk === targetChunk)
-                    continue;
-                // If both chunks are small, we also allow for unrelated merges during
-                // the first pass
-                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
-                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
-                if (distance < closestChunkDistance &&
-                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
-                    closestChunk = targetChunk;
-                    closestChunkDistance = distance;
-                }
-            }
-            if (closestChunk) {
-                chunkPartition.small.delete(mergedChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
-                closestChunk.modules.push(...modules);
-                closestChunk.size += size;
-                closestChunk.pure && (closestChunk.pure = pure);
-                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
-                for (const sideEffect of correlatedSideEffects) {
-                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
-                        correlatedSideEffects.delete(sideEffect);
-                    }
-                }
-                for (const entry of mergedChunk.dependentEntries) {
-                    dependentEntries.add(entry);
-                }
-                for (const sideEffect of mergedChunk.sideEffects) {
-                    sideEffects.add(sideEffect);
-                }
-                for (const dependency of mergedChunk.dependencies) {
-                    dependencies.add(dependency);
-                    dependency.dependentChunks.delete(mergedChunk);
-                    dependency.dependentChunks.add(closestChunk);
-                }
-                for (const dependentChunk of mergedChunk.dependentChunks) {
-                    dependentChunks.add(dependentChunk);
-                    dependentChunk.dependencies.delete(mergedChunk);
-                    dependentChunk.dependencies.add(closestChunk);
-                }
-                dependencies.delete(closestChunk);
-                dependentChunks.delete(closestChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+    for (const chunks of chunkLists) {
+        for (const chunk of chunks) {
+            const { dependentEntries } = chunk;
+            // Correlated atoms are the intersection of all entry atoms
+            chunk.correlatedAtoms = -1n;
+            for (const entryIndex of dependentEntries) {
+                chunk.correlatedAtoms &= atomsByEntry[entryIndex];
             }
         }
     }
+    return sideEffectAtoms;
 }
-// Merging will not produce cycles if none of the direct non-merged dependencies
-// of a chunk have the other chunk as a transitive dependency
-function isValidMerge(mergedChunk, targetChunk, onlySubsetMerge) {
-    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
-        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
-}
-function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
-    const { correlatedSideEffects } = dependencyChunk;
-    if (checkSideEffects) {
-        for (const sideEffect of dependentChunk.sideEffects) {
-            if (!correlatedSideEffects.has(sideEffect)) {
-                return true;
-            }
+function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
         }
     }
+    return bestTargetChunk;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * Merging will not produce cycles if none of the direct non-merged
+ * dependencies of a chunk have the other chunk as a transitive dependency.
+ */
+function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies, sideEffects } of chunksToCheck) {
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
-                return true;
+                return Infinity;
             }
             chunksToCheck.add(dependency);
         }
-        if (checkSideEffects) {
-            for (const sideEffect of sideEffects) {
-                if (!correlatedSideEffects.has(sideEffect)) {
-                    return true;
-                }
-            }
-        }
     }
-    return false;
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
 }
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-}
-function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
-    let distance = 0;
-    for (const entryIndex of targetEntries) {
-        if (!sourceEntries.has(entryIndex)) {
-            distance++;
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
         }
-    }
-    for (const entryIndex of sourceEntries) {
-        if (!targetEntries.has(entryIndex)) {
-            if (enforceSubest) {
-                return Infinity;
-            }
-            distance++;
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
         }
     }
-    return distance;
+    return size;
 }
 
 // ported from https://github.com/substack/node-commondir
@@ -23546,10 +23619,10 @@ function reserveFileNameInBundle(fileName, { bundle }, warn) {
         bundle[fileName] = FILE_PLACEHOLDER;
     }
 }
+const emittedFileTypes = new Set(['chunk', 'asset', 'prebuilt-chunk']);
 function hasValidType(emittedFile) {
     return Boolean(emittedFile &&
-        (emittedFile.type === 'asset' ||
-            emittedFile.type === 'chunk'));
+        emittedFileTypes.has(emittedFile.type));
 }
 function hasValidName(emittedFile) {
     const validatedName = emittedFile.fileName || emittedFile.name;
@@ -23587,10 +23660,13 @@ class FileEmitter {
         this.outputFileEmitters = [];
         this.emitFile = (emittedFile) => {
             if (!hasValidType(emittedFile)) {
-                return error(errorFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
+                return error(errorFailedValidation(`Emitted files must be of type "asset", "chunk" or "prebuilt-chunk", received "${emittedFile && emittedFile.type}".`));
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return this.emitPrebuiltChunk(emittedFile);
             }
             if (!hasValidName(emittedFile)) {
-                return error(errorFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
+                return error(errorFailedValidation(`The "fileName" or "name" properties of emitted chunks and assets must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
             }
             if (emittedFile.type === 'chunk') {
                 return this.emitChunk(emittedFile);
@@ -23610,6 +23686,9 @@ class FileEmitter {
             if (emittedFile.type === 'chunk') {
                 return getChunkFileName(emittedFile, this.facadeChunkByModule);
             }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return emittedFile.fileName;
+            }
             return getAssetFileName(emittedFile, fileReferenceId);
         };
         this.setAssetSource = (referenceId, requestedSource) => {
@@ -23658,6 +23737,9 @@ class FileEmitter {
                         getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
                     }
                 }
+                else if (consumedFile.type === 'prebuilt-chunk') {
+                    this.output.bundle[consumedFile.fileName] = this.createPrebuiltChunk(consumedFile);
+                }
             }
             for (const [sourceHash, consumedFiles] of consumedAssetsByHash) {
                 this.finalizeAssetsWithSameSource(consumedFiles, sourceHash, output);
@@ -23684,6 +23766,27 @@ class FileEmitter {
         }
         return referenceId;
     }
+    createPrebuiltChunk(prebuiltChunk) {
+        return {
+            code: prebuiltChunk.code,
+            dynamicImports: [],
+            exports: prebuiltChunk.exports || [],
+            facadeModuleId: null,
+            fileName: prebuiltChunk.fileName,
+            implicitlyLoadedBefore: [],
+            importedBindings: {},
+            imports: [],
+            isDynamicEntry: false,
+            isEntry: false,
+            isImplicitEntry: false,
+            map: prebuiltChunk.map || null,
+            moduleIds: [],
+            modules: {},
+            name: prebuiltChunk.fileName,
+            referencedFiles: [],
+            type: 'chunk'
+        };
+    }
     emitAsset(emittedAsset) {
         const source = emittedAsset.source === undefined
             ? undefined
@@ -23739,6 +23842,29 @@ class FileEmitter {
         });
         return this.assignReferenceId(consumedChunk, emittedChunk.id);
     }
+    emitPrebuiltChunk(emitPrebuiltChunk) {
+        if (typeof emitPrebuiltChunk.code !== 'string') {
+            return error(errorFailedValidation(`Emitted prebuilt chunks need to have a valid string code, received "${emitPrebuiltChunk.code}".`));
+        }
+        if (typeof emitPrebuiltChunk.fileName !== 'string' ||
+            isPathFragment(emitPrebuiltChunk.fileName)) {
+            return error(errorFailedValidation(`The "fileName" property of emitted prebuilt chunks must be strings that are neither absolute nor relative paths, received "${emitPrebuiltChunk.fileName}".`));
+        }
+        const consumedPrebuiltChunk = {
+            code: emitPrebuiltChunk.code,
+            exports: emitPrebuiltChunk.exports,
+            fileName: emitPrebuiltChunk.fileName,
+            map: emitPrebuiltChunk.map,
+            referenceId: '',
+            type: 'prebuilt-chunk'
+        };
+        const referenceId = this.assignReferenceId(consumedPrebuiltChunk, consumedPrebuiltChunk.fileName);
+        if (this.output) {
+            this.output.bundle[consumedPrebuiltChunk.fileName] =
+                this.createPrebuiltChunk(consumedPrebuiltChunk);
+        }
+        return referenceId;
+    }
     finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, outputOptions }) {
         let { fileName, needsCodeReference, referenceId } = consumedFile;
         // Deduplicate assets if an explicit fileName is not provided
@@ -24376,25 +24502,34 @@ function formatAction([pluginName, hookName, parameters]) {
     }
     return action;
 }
-// We do not directly listen on process to avoid max listeners warnings for
-// complicated build processes
-const beforeExitEvent = 'beforeExit';
-const beforeExitEmitter = new EventEmitter();
-beforeExitEmitter.setMaxListeners(0);
-process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
+let handleBeforeExit = null;
+const rejectByPluginDriver = new Map();
 async function catchUnfinishedHookActions(pluginDriver, callback) {
-    let handleEmptyEventLoop;
     const emptyEventLoopPromise = new Promise((_, reject) => {
-        handleEmptyEventLoop = () => {
-            const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
-            reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
-                [...unfulfilledActions].map(formatAction).join('\n')));
-        };
-        beforeExitEmitter.once(beforeExitEvent, handleEmptyEventLoop);
+        rejectByPluginDriver.set(pluginDriver, reject);
+        if (!handleBeforeExit) {
+            // We only ever create a single event listener to avoid max listener and
+            // other issues
+            handleBeforeExit = () => {
+                for (const [pluginDriver, reject] of rejectByPluginDriver) {
+                    const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
+                    reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
+                        [...unfulfilledActions].map(formatAction).join('\n')));
+                }
+            };
+            process$1.once('beforeExit', handleBeforeExit);
+        }
     });
-    const result = await Promise.race([callback(), emptyEventLoopPromise]);
-    beforeExitEmitter.off(beforeExitEvent, handleEmptyEventLoop);
-    return result;
+    try {
+        return await Promise.race([callback(), emptyEventLoopPromise]);
+    }
+    finally {
+        rejectByPluginDriver.delete(pluginDriver);
+        if (rejectByPluginDriver.size === 0) {
+            process$1.off('beforeExit', handleBeforeExit);
+            handleBeforeExit = null;
+        }
+    }
 }
 
 const leftCurlyBrace = "{".charCodeAt(0);
@@ -24493,7 +24628,7 @@ function importAssertions(Parser) {
         if (this.type !== tt.string) { this.unexpected(); }
         node.source = this.parseExprAtom();
 
-        if (this.type === this.assertToken) {
+        if (this.type === this.assertToken || this.type === tt._with) {
           this.next();
           const assertions = this.parseImportAssertions();
           if (assertions) {
@@ -24537,7 +24672,7 @@ function importAssertions(Parser) {
           if (this.type !== tt.string) { this.unexpected(); }
           node.source = this.parseExprAtom();
 
-          if (this.type === this.assertToken) {
+          if (this.type === this.assertToken || this.type === tt._with) {
             this.next();
             const assertions = this.parseImportAssertions();
             if (assertions) {
@@ -24574,7 +24709,7 @@ function importAssertions(Parser) {
           this.type === tt.string ? this.parseExprAtom() : this.unexpected();
       }
 
-      if (this.type === this.assertToken) {
+      if (this.type === this.assertToken || this.type == tt._with) {
         this.next();
         const assertions = this.parseImportAssertions();
         if (assertions) {
@@ -24946,7 +25081,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
         experimentalDeepDynamicChunkOptimization: getExperimentalDeepDynamicChunkOptimization(config, inputOptions),
-        experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
         externalImportAssertions: config.externalImportAssertions ?? true,