rollup 4.6.1 → 4.8.0

package/LICENSE.md

@@ -50,6 +50,28 @@ License: MIT
 By: Rich Harris
 Repository: rollup/plugins
 
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
 ---------------------------------------
 
 ## anymatch

package/dist/bin/rollup

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/es/getLogFilter.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/es/parseAst.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 
@@ -16,7 +16,7 @@ import { xxhashBase64Url } from '../../native.js';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version = "4.6.1";
+var version = "4.8.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -15913,11 +15913,15 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
-    // This mutates initialChunks but also clears
-    // dynamicallyDependentEntriesByDynamicEntry as side effect
-    removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize, log).map(({ modules }) => ({
+    const chunkAtoms = getChunksWithSameDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
+    const staticDependencyAtomsByEntry = getStaticDependencyAtomsByEntry(allEntries, chunkAtoms);
+    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+    // If we no longer want this, we should make a copy here.
+    const alreadyLoadedAtomsByEntry = getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+    // This mutates the dependentEntries in chunkAtoms
+    removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry);
+    const { chunks, sideEffectAtoms, sizeByAtom } = getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize);
+    chunkDefinitions.push(...getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log).map(({ modules }) => ({
         alias: null,
         modules
     })));
@@ -16026,7 +16030,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksFromDependentEntries(modulesWithDependentEntries) {
+function getChunksWithSameDependentEntries(modulesWithDependentEntries) {
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
         let chunkSignature = 0n;
@@ -16047,55 +16051,152 @@ function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManu
         }
     }
 }
-/**
- * This removes all unnecessary dynamic entries from the dependenEntries in its
- * first argument. It will also consume its second argument, so if
- * dynamicallyDependentEntriesByDynamicEntry is ever needed after this, we
- * should make a copy.
- */
-function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
-    // The indices correspond to the indices in allEntries. The chunks correspond
+function getStaticDependencyAtomsByEntry(allEntries, chunkAtoms) {
+    // The indices correspond to the indices in allEntries. The atoms correspond
     // to bits in the bigint values where chunk 0 is the lowest bit.
-    const staticDependenciesPerEntry = allEntries.map(() => 0n);
-    const alreadyLoadedChunksPerEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
-    // This toggles the bits for each chunk that is a dependency of an entry
-    let chunkMask = 1n;
-    for (const { dependentEntries } of chunks) {
+    const staticDependencyAtomsByEntry = allEntries.map(() => 0n);
+    // This toggles the bits for each atom that is a dependency of an entry
+    let atomMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
         for (const entryIndex of dependentEntries) {
-            staticDependenciesPerEntry[entryIndex] |= chunkMask;
-        }
-        chunkMask <<= 1n;
-    }
-    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
-    // If we no longer want this, we should make a copy here.
-    const updatedDynamicallyDependentEntriesByDynamicEntry = dynamicallyDependentEntriesByDynamicEntry;
-    for (const [dynamicEntryIndex, updatedDynamicallyDependentEntries] of updatedDynamicallyDependentEntriesByDynamicEntry) {
-        updatedDynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
-        const previousLoadedModules = alreadyLoadedChunksPerEntry[dynamicEntryIndex];
-        let newLoadedModules = previousLoadedModules;
-        for (const entryIndex of updatedDynamicallyDependentEntries) {
-            newLoadedModules &=
-                staticDependenciesPerEntry[entryIndex] | alreadyLoadedChunksPerEntry[entryIndex];
-        }
-        if (newLoadedModules !== previousLoadedModules) {
-            alreadyLoadedChunksPerEntry[dynamicEntryIndex] = newLoadedModules;
+            staticDependencyAtomsByEntry[entryIndex] |= atomMask;
+        }
+        atomMask <<= 1n;
+    }
+    return staticDependencyAtomsByEntry;
+}
+// Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+function getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+    // Dynamic entries have all atoms as already loaded initially because we then
+    // intersect with the static dependency atoms of all dynamic importers.
+    // Static entries cannot have already loaded atoms.
+    const alreadyLoadedAtomsByEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+    for (const [dynamicEntryIndex, dynamicallyDependentEntries] of dynamicallyDependentEntriesByDynamicEntry) {
+        // We delete here so that they can be added again if necessary to be handled
+        // again by the loop
+        dynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const knownLoadedAtoms = alreadyLoadedAtomsByEntry[dynamicEntryIndex];
+        let updatedLoadedAtoms = knownLoadedAtoms;
+        for (const entryIndex of dynamicallyDependentEntries) {
+            updatedLoadedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        // If the knownLoadedAtoms changed, all dependent dynamic entries need to be
+        // updated again
+        if (updatedLoadedAtoms !== knownLoadedAtoms) {
+            alreadyLoadedAtomsByEntry[dynamicEntryIndex] = updatedLoadedAtoms;
             for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
-                getOrCreate(updatedDynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
+                // If this adds an entry that was deleted before, it will be handled
+                // again. This is the reason why we delete every entry from this map
+                // that we processed.
+                getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
             }
         }
     }
+    return alreadyLoadedAtomsByEntry;
+}
+/**
+ * This removes all unnecessary dynamic entries from the dependentEntries in its
+ * first argument if a chunk is already loaded without that entry.
+ */
+function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry) {
     // Remove entries from dependent entries if a chunk is already loaded without
     // that entry.
-    chunkMask = 1n;
-    for (const { dependentEntries } of chunks) {
+    let chunkMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
         for (const entryIndex of dependentEntries) {
-            if ((alreadyLoadedChunksPerEntry[entryIndex] & chunkMask) === chunkMask) {
+            if ((alreadyLoadedAtomsByEntry[entryIndex] & chunkMask) === chunkMask) {
                 dependentEntries.delete(entryIndex);
             }
         }
         chunkMask <<= 1n;
     }
 }
+function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
+    const chunksBySignature = Object.create(null);
+    const chunkByModule = new Map();
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let atomMask = 1n;
+    for (const { dependentEntries, modules } of chunkAtoms) {
+        let chunkSignature = 0n;
+        let correlatedAtoms = -1n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+            // Correlated atoms are the atoms that are guaranteed to be loaded as
+            // well when a given atom is loaded. It is the intersection of the already
+            // loaded modules of each chunk merged with its static dependencies.
+            correlatedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        const chunk = (chunksBySignature[String(chunkSignature)] ||= {
+            containedAtoms: 0n,
+            correlatedAtoms,
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            dependentEntries: new Set(dependentEntries),
+            modules: [],
+            pure: true,
+            size: 0
+        });
+        let atomSize = 0;
+        let pure = true;
+        for (const module of modules) {
+            chunkByModule.set(module, chunk);
+            // Unfortunately, we cannot take tree-shaking into account here because
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure &&= !module.hasEffects();
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                atomSize += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
+        }
+        if (!pure) {
+            sideEffectAtoms |= atomMask;
+        }
+        sizeByAtom.push(atomSize);
+        chunk.containedAtoms |= atomMask;
+        chunk.modules.push(...modules);
+        chunk.pure &&= pure;
+        chunk.size += atomSize;
+        atomMask <<= 1n;
+    }
+    const chunks = Object.values(chunksBySignature);
+    sideEffectAtoms |= addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, atomMask);
+    return { chunks, sideEffectAtoms, sizeByAtom };
+}
+function addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, nextAvailableAtomMask) {
+    const signatureByExternalModule = new Map();
+    let externalSideEffectAtoms = 0n;
+    for (const chunk of chunks) {
+        const { dependencies, modules } = chunk;
+        for (const module of modules) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (dependency instanceof ExternalModule) {
+                    if (dependency.info.moduleSideEffects) {
+                        const signature = getOrCreate(signatureByExternalModule, dependency, () => {
+                            const signature = nextAvailableAtomMask;
+                            nextAvailableAtomMask <<= 1n;
+                            externalSideEffectAtoms |= signature;
+                            return signature;
+                        });
+                        chunk.containedAtoms |= signature;
+                        chunk.correlatedAtoms |= signature;
+                    }
+                }
+                else {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
+                }
+            }
+        }
+    }
+    return externalSideEffectAtoms;
+}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -16172,77 +16273,44 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
  *    following the rule (a), starting with the smallest chunks to look for
  *    possible merge targets.
  */
-function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize, log) {
+function getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    const chunkPartition = getPartitionedChunks(chunks, minChunkSize);
     if (!chunkPartition) {
         timeEnd('optimize chunks', 3);
-        return initialChunks; // the actual modules
+        return chunks; // the actual modules
     }
     minChunkSize > 1 &&
-        log('info', logOptimizeChunkStatus(initialChunks.length, chunkPartition.small.size, 'Initially'));
-    mergeChunks(chunkPartition, minChunkSize);
+        log('info', logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, 'Initially'));
+    mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
     minChunkSize > 1 &&
         log('info', logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(chunks, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
-    const chunkByModule = new Map();
-    const sizeByAtom = [];
-    let sideEffectAtoms = 0n;
-    let containedAtoms = 1n;
-    for (const { dependentEntries, modules } of initialChunks) {
-        const chunkDescription = {
-            containedAtoms,
-            correlatedAtoms: 0n,
-            dependencies: new Set(),
-            dependentChunks: new Set(),
-            dependentEntries,
-            modules,
-            pure: true,
-            size: 0
-        };
-        let size = 0;
-        let pure = true;
-        for (const module of modules) {
-            chunkByModule.set(module, chunkDescription);
-            // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet, but we can detect empty modules
-            if (module.isIncluded()) {
-                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) {
-            sideEffectAtoms |= containedAtoms;
-        }
-        (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
-        containedAtoms <<= 1n;
+    for (const chunk of chunks) {
+        (chunk.size < minChunkSize ? smallChunks : bigChunks).push(chunk);
     }
-    // If there are no small chunks, we will not optimize
     if (smallChunks.length === 0) {
         return null;
     }
-    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
+    smallChunks.sort(compareChunkSize);
+    bigChunks.sort(compareChunkSize);
     return {
         big: new Set(bigChunks),
-        sideEffectAtoms,
-        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function mergeChunks(chunkPartition, minChunkSize) {
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom) {
     const { small } = chunkPartition;
     for (const mergedChunk of small) {
-        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, sideEffectAtoms, sizeByAtom, 
         // In the default case, we do not accept size increases
         minChunkSize <= 1 ? 1 : Infinity);
         if (bestTargetChunk) {
@@ -16274,57 +16342,7 @@ function mergeChunks(chunkPartition, minChunkSize) {
         }
     }
 }
-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, dependentEntries, modules } = chunk;
-            for (const module of modules) {
-                for (const dependency of module.getDependenciesToBeIncluded()) {
-                    if (dependency instanceof ExternalModule) {
-                        if (dependency.info.moduleSideEffects) {
-                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
-                                const signature = nextAtomSignature;
-                                nextAtomSignature <<= 1n;
-                                sideEffectAtoms |= signature;
-                                return signature;
-                            });
-                        }
-                    }
-                    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;
-            }
-        }
-    }
-    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;
-}
-function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+function findBestMergeTarget(mergedChunk, { big, small }, sideEffectAtoms, sizeByAtom, smallestAdditionalSize) {
     let bestTargetChunk = null;
     // In the default case, we do not accept size increases
     for (const targetChunk of concatLazy([small, big])) {
@@ -16340,12 +16358,6 @@ function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, sm
     }
     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
@@ -16403,6 +16415,9 @@ function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
     }
     return size;
 }
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
 
 // ported from https://github.com/substack/node-commondir
 function commondir(files) {

package/dist/es/shared/parseAst.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/getLogFilter.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/native.js

@@ -16,6 +16,7 @@ const bindingsByPlatformAndArch = {
 	linux: {
 		arm: { base: 'linux-arm-gnueabihf', musl: null },
 		arm64: { base: 'linux-arm64-gnu', musl: 'linux-arm64-musl' },
+		riscv64: { base: 'linux-riscv64-gnu', musl: null },
 		x64: { base: 'linux-x64-gnu', musl: 'linux-x64-musl' }
 	},
 	win32: {
@@ -25,6 +26,12 @@ const bindingsByPlatformAndArch = {
 	}
 };
 
+const msvcLinkFilenameByArch = {
+	arm64: 'vc_redist.arm64.exe',
+	ia32: 'vc_redist.x86.exe',
+	x64: 'vc_redist.x64.exe'
+};
+
 const packageBase = getPackageBase();
 
 if (!packageBase) {
@@ -61,6 +68,22 @@ const requireWithFriendlyError = id => {
 	try {
 		return require(id);
 	} catch (error) {
+		if (
+			platform === 'win32' &&
+			error instanceof Error &&
+			error.code === 'ERR_DLOPEN_FAILED' &&
+			error.message.includes('The specified module could not be found')
+		) {
+			const msvcDownloadLink = `https://aka.ms/vs/17/release/${msvcLinkFilenameByArch[arch]}`;
+			throw new Error(
+				`Failed to load module ${id}. ` +
+					'Required DLL was not found. ' +
+					'This error usually happens when Microsoft Visual C++ Redistributable is not installed. ' +
+					`You can download it from ${msvcDownloadLink}`,
+				{ cause: error }
+			);
+		}
+
 		throw new Error(
 			`Cannot find module ${id}. ` +
 				`npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +

package/dist/parseAst.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup