rollup 2.61.0 → 2.64.0

package/dist/es/shared/rollup.js

@@ -1,19 +1,21 @@
 /*
   @license
-	Rollup.js v2.61.0
-	Thu, 09 Dec 2021 05:43:43 GMT - commit 49d41f78987a1dd13488df009fe2db1b5d1b6e7c
+	Rollup.js v2.64.0
+	Fri, 14 Jan 2022 14:02:32 GMT - commit 82a3e2634a9d51b5040752e4fb2fd264651d504e
 
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import require$$0__default, { relative as relative$1, resolve, extname, basename, win32, posix, isAbsolute as isAbsolute$1, dirname } from 'path';
+import require$$0, { relative as relative$1, resolve, extname, basename, win32, posix, isAbsolute as isAbsolute$1, dirname } from 'path';
+import process$1 from 'process';
+import { performance } from 'perf_hooks';
 import { createHash as createHash$1 } from 'crypto';
 import fs, { lstatSync, realpathSync, readdirSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.61.0";
+var version$1 = "2.64.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1645,20 +1647,70 @@ const BLANK = Object.freeze(Object.create(null));
 const EMPTY_OBJECT = Object.freeze({});
 const EMPTY_ARRAY = Object.freeze([]);
 
-const reservedWords$2 = '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'.split(' ');
-const builtins$2 = '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'.split(' ');
-const blacklisted = new Set(reservedWords$2.concat(builtins$2));
+const RESERVED_NAMES = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'NaN',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+const RESERVED_NAMES$1 = RESERVED_NAMES;
+
 const illegalCharacters = /[^$_a-zA-Z0-9]/g;
 const startsWithDigit = (str) => /\d/.test(str[0]);
 function isLegal(str) {
-    if (startsWithDigit(str) || blacklisted.has(str)) {
+    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str)) {
         return false;
     }
     return !illegalCharacters.test(str);
 }
 function makeLegal(str) {
     str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
-    if (startsWithDigit(str) || blacklisted.has(str))
+    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str))
         str = `_${str}`;
     return str || '_';
 }
@@ -1740,6 +1792,7 @@ class ExternalModule {
             },
             isEntry: false,
             isExternal: true,
+            isIncluded: null,
             meta,
             syntheticNamedExports: false
         };
@@ -1798,9 +1851,24 @@ class ExternalModule {
     }
 }
 
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
 var utils$3 = {};
 
-const path$1 = require$$0__default;
+const path$1 = require$$0;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1980,7 +2048,7 @@ var constants$2 = {
 
 (function (exports) {
 
-const path = require$$0__default;
+const path = require$$0;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
@@ -3510,7 +3578,7 @@ parse$1.fastpaths = (input, options) => {
 
 var parse_1 = parse$1;
 
-const path = require$$0__default;
+const path = require$$0;
 const scan = scan_1;
 const parse = parse_1;
 const utils = utils$3;
@@ -5023,8 +5091,6 @@ const knownGlobals = {
         __proto__: null,
         [ValueProperties]: PURE,
         create: PF,
-        getNotifier: PF,
-        getOwn: PF,
         getOwnPropertyDescriptor: PF,
         getOwnPropertyNames: PF,
         getOwnPropertySymbols: PF,
@@ -6066,62 +6132,10 @@ function toBase64(num) {
     return outStr;
 }
 
-const RESERVED_NAMES = {
-    __proto__: null,
-    await: true,
-    break: true,
-    case: true,
-    catch: true,
-    class: true,
-    const: true,
-    continue: true,
-    debugger: true,
-    default: true,
-    delete: true,
-    do: true,
-    else: true,
-    enum: true,
-    eval: true,
-    export: true,
-    extends: true,
-    false: true,
-    finally: true,
-    for: true,
-    function: true,
-    if: true,
-    implements: true,
-    import: true,
-    in: true,
-    instanceof: true,
-    interface: true,
-    let: true,
-    new: true,
-    null: true,
-    package: true,
-    private: true,
-    protected: true,
-    public: true,
-    return: true,
-    static: true,
-    super: true,
-    switch: true,
-    this: true,
-    throw: true,
-    true: true,
-    try: true,
-    typeof: true,
-    undefined: true,
-    var: true,
-    void: true,
-    while: true,
-    with: true,
-    yield: true
-};
-
 function getSafeName(baseName, usedNames) {
     let safeName = baseName;
     let count = 1;
-    while (usedNames.has(safeName) || RESERVED_NAMES[safeName]) {
+    while (usedNames.has(safeName) || RESERVED_NAMES$1.has(safeName)) {
         safeName = `${baseName}$${toBase64(count++)}`;
     }
     usedNames.add(safeName);
@@ -6232,16 +6246,27 @@ const literalNumberMembers = assembleMemberDescriptions({
     valueOf: returnsNumber
 }, objectMembers);
 const literalStringMembers = assembleMemberDescriptions({
+    anchor: returnsString,
+    at: returnsUnknown,
+    big: returnsString,
+    blink: returnsString,
+    bold: returnsString,
     charAt: returnsString,
     charCodeAt: returnsNumber,
-    codePointAt: returnsNumber,
+    codePointAt: returnsUnknown,
     concat: returnsString,
     endsWith: returnsBoolean,
+    fixed: returnsString,
+    fontcolor: returnsString,
+    fontsize: returnsString,
     includes: returnsBoolean,
     indexOf: returnsNumber,
+    italics: returnsString,
     lastIndexOf: returnsNumber,
+    link: returnsString,
     localeCompare: returnsNumber,
-    match: returnsBoolean,
+    match: returnsUnknown,
+    matchAll: returnsUnknown,
     normalize: returnsString,
     padEnd: returnsString,
     padStart: returnsString,
@@ -6252,17 +6277,32 @@ const literalStringMembers = assembleMemberDescriptions({
             returns: UNKNOWN_LITERAL_STRING
         }
     },
+    replaceAll: {
+        value: {
+            callsArgs: [1],
+            returns: UNKNOWN_LITERAL_STRING
+        }
+    },
     search: returnsNumber,
     slice: returnsString,
+    small: returnsString,
     split: returnsUnknown,
     startsWith: returnsBoolean,
+    strike: returnsString,
+    sub: returnsString,
     substr: returnsString,
     substring: returnsString,
+    sup: returnsString,
     toLocaleLowerCase: returnsString,
     toLocaleUpperCase: returnsString,
     toLowerCase: returnsString,
+    toString: returnsString,
     toUpperCase: returnsString,
     trim: returnsString,
+    trimEnd: returnsString,
+    trimLeft: returnsString,
+    trimRight: returnsString,
+    trimStart: returnsString,
     valueOf: returnsString
 }, objectMembers);
 function getLiteralMembersForValue(value) {
@@ -8078,6 +8118,10 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     filter: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     find: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     findIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    findLast: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findLastIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
@@ -8095,6 +8139,8 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     some: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
     sort: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF,
     splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
     unshift: METHOD_MUTATES_SELF_RETURNS_NUMBER,
     values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
 }, OBJECT_PROTOTYPE, true);
@@ -11927,13 +11973,19 @@ class SyntheticNamedExportVariable extends Variable {
     }
 }
 
+var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
+    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
+    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
+})(BuildPhase || (BuildPhase = {}));
+
 function getId(m) {
     return m.id;
 }
 
 function getOriginalLocation(sourcemapChain, location) {
-    // This cast is guaranteed. If it were a missing Map, it wouldn't have a mappings.
-    const filteredSourcemapChain = sourcemapChain.filter(sourcemap => sourcemap.mappings);
+    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !!sourcemap.mappings);
     while (filteredSourcemapChain.length > 0) {
         const sourcemap = filteredSourcemapChain.pop();
         const line = sourcemap.mappings[location.line - 1];
@@ -11962,24 +12014,7 @@ function getOriginalLocation(sourcemapChain, location) {
 }
 
 const NOOP = () => { };
-let getStartTime = () => [0, 0];
-let getElapsedTime = () => 0;
-let getMemory = () => 0;
-let timers = {};
-const normalizeHrTime = (time) => time[0] * 1e3 + time[1] / 1e6;
-function setTimeHelpers() {
-    if (typeof process !== 'undefined' && typeof process.hrtime === 'function') {
-        getStartTime = process.hrtime.bind(process);
-        getElapsedTime = previous => normalizeHrTime(process.hrtime(previous));
-    }
-    else if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
-        getStartTime = () => [performance.now(), 0];
-        getElapsedTime = previous => performance.now() - previous[0];
-    }
-    if (typeof process !== 'undefined' && typeof process.memoryUsage === 'function') {
-        getMemory = () => process.memoryUsage().heapUsed;
-    }
-}
+let timers = new Map();
 function getPersistedLabel(label, level) {
     switch (level) {
         case 1:
@@ -11994,46 +12029,47 @@ function getPersistedLabel(label, level) {
 }
 function timeStartImpl(label, level = 3) {
     label = getPersistedLabel(label, level);
-    if (!timers.hasOwnProperty(label)) {
-        timers[label] = {
+    const startMemory = process$1.memoryUsage().heapUsed;
+    const startTime = performance.now();
+    const timer = timers.get(label);
+    if (timer === undefined) {
+        timers.set(label, {
             memory: 0,
-            startMemory: undefined,
-            startTime: undefined,
+            startMemory,
+            startTime,
             time: 0,
             totalMemory: 0
-        };
+        });
+    }
+    else {
+        timer.startMemory = startMemory;
+        timer.startTime = startTime;
     }
-    const currentMemory = getMemory();
-    timers[label].startTime = getStartTime();
-    timers[label].startMemory = currentMemory;
 }
 function timeEndImpl(label, level = 3) {
     label = getPersistedLabel(label, level);
-    if (timers.hasOwnProperty(label)) {
-        const currentMemory = getMemory();
-        timers[label].time += getElapsedTime(timers[label].startTime);
-        timers[label].totalMemory = Math.max(timers[label].totalMemory, currentMemory);
-        timers[label].memory += currentMemory - timers[label].startMemory;
+    const timer = timers.get(label);
+    if (timer !== undefined) {
+        const currentMemory = process$1.memoryUsage().heapUsed;
+        timer.memory += currentMemory - timer.startMemory;
+        timer.time += performance.now() - timer.startTime;
+        timer.totalMemory = Math.max(timer.totalMemory, currentMemory);
     }
 }
 function getTimings() {
     const newTimings = {};
-    for (const [label, { time, memory, totalMemory }] of Object.entries(timers)) {
+    for (const [label, { memory, time, totalMemory }] of timers) {
         newTimings[label] = [time, memory, totalMemory];
     }
     return newTimings;
 }
-let timeStart = NOOP, timeEnd = NOOP;
-const TIMED_PLUGIN_HOOKS = {
-    load: true,
-    resolveDynamicImport: true,
-    resolveId: true,
-    transform: true
-};
+let timeStart = NOOP;
+let timeEnd = NOOP;
+const TIMED_PLUGIN_HOOKS = ['load', 'resolveDynamicImport', 'resolveId', 'transform'];
 function getPluginWithTimers(plugin, index) {
     const timedPlugin = {};
-    for (const hook of Object.keys(plugin)) {
-        if (TIMED_PLUGIN_HOOKS[hook] === true) {
+    for (const hook of TIMED_PLUGIN_HOOKS) {
+        if (hook in plugin) {
             let timerLabel = `plugin ${index}`;
             if (plugin.name) {
                 timerLabel += ` (${plugin.name})`;
@@ -12041,11 +12077,11 @@ function getPluginWithTimers(plugin, index) {
             timerLabel += ` - ${hook}`;
             timedPlugin[hook] = function (...args) {
                 timeStart(timerLabel, 4);
-                let result = plugin[hook].apply(this === timedPlugin ? plugin : this, args);
+                const result = plugin[hook](...args);
                 timeEnd(timerLabel, 4);
                 if (result && typeof result.then === 'function') {
                     timeStart(`${timerLabel} (async)`, 4);
-                    result = result.then((hookResult) => {
+                    return result.then((hookResult) => {
                         timeEnd(`${timerLabel} (async)`, 4);
                         return hookResult;
                     });
@@ -12053,16 +12089,15 @@ function getPluginWithTimers(plugin, index) {
                 return result;
             };
         }
-        else {
-            timedPlugin[hook] = plugin[hook];
-        }
     }
-    return timedPlugin;
+    return {
+        ...plugin,
+        ...timedPlugin
+    };
 }
 function initialiseTimers(inputOptions) {
     if (inputOptions.perf) {
-        timers = {};
-        setTimeHelpers();
+        timers = new Map();
         timeStart = timeStartImpl;
         timeEnd = timeEndImpl;
         inputOptions.plugins = inputOptions.plugins.map(getPluginWithTimers);
@@ -12206,10 +12241,10 @@ class Module {
             hasModuleSideEffects,
             id,
             get implicitlyLoadedAfterOneOf() {
-                return Array.from(module.implicitlyLoadedAfter, getId);
+                return Array.from(module.implicitlyLoadedAfter, getId).sort();
             },
             get implicitlyLoadedBefore() {
-                return Array.from(module.implicitlyLoadedBefore, getId);
+                return Array.from(module.implicitlyLoadedBefore, getId).sort();
             },
             get importedIds() {
                 return Array.from(module.sources, source => { var _a; return (_a = module.resolvedIds[source]) === null || _a === void 0 ? void 0 : _a.id; }).filter(Boolean);
@@ -12219,7 +12254,13 @@ class Module {
             },
             isEntry,
             isExternal: false,
-            meta,
+            get isIncluded() {
+                if (module.graph.phase !== BuildPhase.GENERATE) {
+                    return null;
+                }
+                return module.isIncluded();
+            },
+            meta: { ...meta },
             syntheticNamedExports
         };
     }
@@ -12240,7 +12281,7 @@ class Module {
             return this.allExportNames;
         }
         const allExportNames = (this.allExportNames = new Set());
-        for (const name of Object.keys(this.exports)) {
+        for (const name of this.getExports()) {
             allExportNames.add(name);
         }
         for (const name of Object.keys(this.reexportDescriptions)) {
@@ -12264,12 +12305,11 @@ class Module {
         const relevantDependencies = new Set();
         const necessaryDependencies = new Set();
         const alwaysCheckedDependencies = new Set();
-        let dependencyVariables = this.imports.keys();
+        const dependencyVariables = new Set(this.imports);
         if (this.info.isEntry ||
             this.includedDynamicImporters.length > 0 ||
             this.namespace.included ||
             this.implicitlyLoadedAfter.size > 0) {
-            dependencyVariables = new Set(dependencyVariables);
             for (const exportName of [...this.getReexports(), ...this.getExports()]) {
                 const exportedVariable = this.getVariableForExportName(exportName);
                 if (exportedVariable) {
@@ -12651,7 +12691,7 @@ class Module {
             this.info.syntheticNamedExports = syntheticNamedExports;
         }
         if (meta != null) {
-            this.info.meta = { ...this.info.meta, ...meta };
+            Object.assign(this.info.meta, meta);
         }
     }
     warn(props, pos) {
@@ -12742,11 +12782,7 @@ class Module {
         for (const specifier of node.specifiers) {
             const isDefault = specifier.type === ImportDefaultSpecifier$1;
             const isNamespace = specifier.type === ImportNamespaceSpecifier$1;
-            const name = isDefault
-                ? 'default'
-                : isNamespace
-                    ? '*'
-                    : specifier.imported.name;
+            const name = isDefault ? 'default' : isNamespace ? '*' : specifier.imported.name;
             this.importDescriptions[specifier.local.name] = {
                 module: null,
                 name,
@@ -12893,7 +12929,7 @@ class Module {
             variable.include();
             this.graph.needsTreeshakingPass = true;
             const variableModule = variable.module;
-            if (variableModule && variableModule instanceof Module) {
+            if (variableModule instanceof Module) {
                 if (!variableModule.isExecuted) {
                     markModuleAndImpureDependenciesAsExecuted(variableModule);
                 }
@@ -14009,7 +14045,7 @@ function escapeId(id) {
 function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
     let nameIndex = 0;
     for (const variable of exports) {
-        let exportName = variable.name[0];
+        let [exportName] = variable.name;
         if (exportsByName[exportName]) {
             do {
                 exportName = toBase64(++nameIndex);
@@ -14018,7 +14054,7 @@ function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariab
                     nameIndex += 9 * 64 ** (exportName.length - 1);
                     exportName = toBase64(nameIndex);
                 }
-            } while (RESERVED_NAMES[exportName] || exportsByName[exportName]);
+            } while (RESERVED_NAMES$1.has(exportName) || exportsByName[exportName]);
         }
         exportsByName[exportName] = variable;
         exportNamesByVariable.set(variable, [exportName]);
@@ -14251,6 +14287,7 @@ class Chunk {
         this.implicitlyLoadedBefore = new Set();
         this.imports = new Set();
         this.indentString = undefined;
+        // This may only be updated in the constructor
         this.isEmpty = true;
         this.name = null;
         this.renderedDependencies = null;
@@ -14436,7 +14473,7 @@ class Chunk {
         }), existingNames);
     }
     generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames, unsetOptions) {
-        const id = this.orderedModules[0].id;
+        const [{ id }] = this.orderedModules;
         const sanitizedId = this.outputOptions.sanitizeFileName(id);
         let path;
         const patternOpt = unsetOptions.has('entryFileNames')
@@ -15236,13 +15273,6 @@ function getChunkNameFromModule(module) {
     return module.chunkName || getAliasName(module.id);
 }
 
-var BuildPhase;
-(function (BuildPhase) {
-    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
-    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
-    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
-})(BuildPhase || (BuildPhase = {}));
-
 function generateAssetFileName(name, source, outputOptions, bundle) {
     const emittedName = outputOptions.sanitizeFileName(name || 'asset');
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
@@ -15753,7 +15783,7 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
     ];
     const isValidPropName = reservedNamesAsProps
         ? (name) => validPropName.test(name)
-        : (name) => !RESERVED_NAMES[name] && validPropName.test(name);
+        : (name) => !RESERVED_NAMES$1.has(name) && validPropName.test(name);
     return {
         _,
         cnst,
@@ -15978,7 +16008,7 @@ function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
         onWarn(errInvalidOption('output.amd.id', 'outputamd', 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
 }
 function getIncludedModules(modulesById) {
-    return [...modulesById.values()].filter(module => module instanceof Module &&
+    return [...modulesById.values()].filter((module) => module instanceof Module &&
         (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0));
 }
 function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
@@ -21540,9 +21570,9 @@ function writeFile(dest, data) {
 }
 
 class Queue {
-    constructor(maxParallel = 1) {
+    constructor(maxParallel) {
         this.maxParallel = maxParallel;
-        this.queue = new Array();
+        this.queue = [];
         this.workerCount = 0;
     }
     run(task) {
@@ -21752,7 +21782,7 @@ function getCacheForUncacheablePlugin(pluginName) {
     };
 }
 
-function transform(source, module, pluginDriver, warn) {
+async function transform(source, module, pluginDriver, warn) {
     const id = module.id;
     const sourcemapChain = [];
     let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
@@ -21762,7 +21792,7 @@ function transform(source, module, pluginDriver, warn) {
     const emittedFiles = [];
     let customTransformCache = false;
     const useCustomTransformCache = () => (customTransformCache = true);
-    let curPlugin;
+    let pluginName = '';
     const curSource = source.code;
     function transformReducer(previousCode, result, plugin) {
         let code;
@@ -21793,90 +21823,91 @@ function transform(source, module, pluginDriver, warn) {
         }
         return code;
     }
-    return pluginDriver
-        .hookReduceArg0('transform', [curSource, id], transformReducer, (pluginContext, plugin) => {
-        curPlugin = plugin;
-        return {
-            ...pluginContext,
-            addWatchFile(id) {
-                transformDependencies.push(id);
-                pluginContext.addWatchFile(id);
-            },
-            cache: customTransformCache
-                ? pluginContext.cache
-                : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
-            emitAsset(name, source) {
-                emittedFiles.push({ name, source, type: 'asset' });
-                return pluginContext.emitAsset(name, source);
-            },
-            emitChunk(id, options) {
-                emittedFiles.push({ id, name: options && options.name, type: 'chunk' });
-                return pluginContext.emitChunk(id, options);
-            },
-            emitFile(emittedFile) {
-                emittedFiles.push(emittedFile);
-                return pluginDriver.emitFile(emittedFile);
-            },
-            error(err, pos) {
-                if (typeof err === 'string')
-                    err = { message: err };
-                if (pos)
-                    augmentCodeLocation(err, pos, curSource, id);
-                err.id = id;
-                err.hook = 'transform';
-                return pluginContext.error(err);
-            },
-            getCombinedSourcemap() {
-                const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn);
-                if (!combinedMap) {
-                    const magicString = new MagicString$1(originalCode);
-                    return magicString.generateMap({ hires: true, includeContent: true, source: id });
-                }
-                if (originalSourcemap !== combinedMap) {
-                    originalSourcemap = combinedMap;
-                    sourcemapChain.length = 0;
+    let code;
+    try {
+        code = await pluginDriver.hookReduceArg0('transform', [curSource, id], transformReducer, (pluginContext, plugin) => {
+            pluginName = plugin.name;
+            return {
+                ...pluginContext,
+                addWatchFile(id) {
+                    transformDependencies.push(id);
+                    pluginContext.addWatchFile(id);
+                },
+                cache: customTransformCache
+                    ? pluginContext.cache
+                    : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
+                emitAsset(name, source) {
+                    emittedFiles.push({ name, source, type: 'asset' });
+                    return pluginContext.emitAsset(name, source);
+                },
+                emitChunk(id, options) {
+                    emittedFiles.push({ id, name: options && options.name, type: 'chunk' });
+                    return pluginContext.emitChunk(id, options);
+                },
+                emitFile(emittedFile) {
+                    emittedFiles.push(emittedFile);
+                    return pluginDriver.emitFile(emittedFile);
+                },
+                error(err, pos) {
+                    if (typeof err === 'string')
+                        err = { message: err };
+                    if (pos)
+                        augmentCodeLocation(err, pos, curSource, id);
+                    err.id = id;
+                    err.hook = 'transform';
+                    return pluginContext.error(err);
+                },
+                getCombinedSourcemap() {
+                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn);
+                    if (!combinedMap) {
+                        const magicString = new MagicString$1(originalCode);
+                        return magicString.generateMap({ hires: true, includeContent: true, source: id });
+                    }
+                    if (originalSourcemap !== combinedMap) {
+                        originalSourcemap = combinedMap;
+                        sourcemapChain.length = 0;
+                    }
+                    return new SourceMap({
+                        ...combinedMap,
+                        file: null,
+                        sourcesContent: combinedMap.sourcesContent
+                    });
+                },
+                setAssetSource() {
+                    return this.error({
+                        code: 'INVALID_SETASSETSOURCE',
+                        message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
+                    });
+                },
+                warn(warning, pos) {
+                    if (typeof warning === 'string')
+                        warning = { message: warning };
+                    if (pos)
+                        augmentCodeLocation(warning, pos, curSource, id);
+                    warning.id = id;
+                    warning.hook = 'transform';
+                    pluginContext.warn(warning);
                 }
-                return new SourceMap({
-                    ...combinedMap,
-                    file: null,
-                    sourcesContent: combinedMap.sourcesContent
-                });
-            },
-            setAssetSource() {
-                return this.error({
-                    code: 'INVALID_SETASSETSOURCE',
-                    message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
-                });
-            },
-            warn(warning, pos) {
-                if (typeof warning === 'string')
-                    warning = { message: warning };
-                if (pos)
-                    augmentCodeLocation(warning, pos, curSource, id);
-                warning.id = id;
-                warning.hook = 'transform';
-                pluginContext.warn(warning);
-            }
-        };
-    })
-        .catch(err => throwPluginError(err, curPlugin.name, { hook: 'transform', id }))
-        .then(code => {
-        if (!customTransformCache) {
-            // files emitted by a transform hook need to be emitted again if the hook is skipped
-            if (emittedFiles.length)
-                module.transformFiles = emittedFiles;
-        }
-        return {
-            ast,
-            code,
-            customTransformCache,
-            meta: module.info.meta,
-            originalCode,
-            originalSourcemap,
-            sourcemapChain,
-            transformDependencies
-        };
-    });
+            };
+        });
+    }
+    catch (err) {
+        throwPluginError(err, pluginName, { hook: 'transform', id });
+    }
+    if (!customTransformCache) {
+        // files emitted by a transform hook need to be emitted again if the hook is skipped
+        if (emittedFiles.length)
+            module.transformFiles = emittedFiles;
+    }
+    return {
+        ast,
+        code,
+        customTransformCache,
+        originalCode,
+        originalSourcemap,
+        sourcemapChain,
+        transformDependencies
+    };
 }
 
 class ModuleLoader {
@@ -21889,8 +21920,8 @@ class ModuleLoader {
         this.indexedEntryModules = [];
         this.latestLoadModulesPromise = Promise.resolve();
         this.moduleLoadPromises = new Map();
+        this.modulesWithLoadedDependencies = new Set();
         this.nextEntryModuleIndex = 0;
-        this.readQueue = new Queue();
         this.resolveId = async (source, importer, customOptions, isEntry, skip = null) => {
             return this.addDefaultsToResolvedId(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
                 ? false
@@ -21899,7 +21930,7 @@ class ModuleLoader {
         this.hasModuleSideEffects = options.treeshake
             ? options.treeshake.moduleSideEffects
             : () => true;
-        this.readQueue.maxParallel = options.maxParallelFileReads;
+        this.readQueue = new Queue(options.maxParallelFileReads);
     }
     async addAdditionalModules(unresolvedModules) {
         const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null))));
@@ -21950,8 +21981,9 @@ class ModuleLoader {
         }
         return module;
     }
-    preloadModule(resolvedId) {
-        return this.fetchModule(this.addDefaultsToResolvedId(resolvedId), undefined, false, true).then(module => module.info);
+    async preloadModule(resolvedId) {
+        const module = await this.fetchModule(this.addDefaultsToResolvedId(resolvedId), undefined, false, true);
+        return module.info;
     }
     addDefaultsToResolvedId(resolvedId) {
         var _a, _b;
@@ -21962,7 +21994,7 @@ class ModuleLoader {
         return {
             external,
             id: resolvedId.id,
-            meta: resolvedId.meta || EMPTY_OBJECT,
+            meta: resolvedId.meta || {},
             moduleSideEffects: (_a = resolvedId.moduleSideEffects) !== null && _a !== void 0 ? _a : this.hasModuleSideEffects(resolvedId.id, !!external),
             syntheticNamedExports: (_b = resolvedId.syntheticNamedExports) !== null && _b !== void 0 ? _b : false
         };
@@ -22001,13 +22033,23 @@ class ModuleLoader {
         timeEnd('load modules', 3);
         const sourceDescription = typeof source === 'string'
             ? { code: source }
-            : typeof source === 'object' && typeof source.code === 'string'
+            : source != null && typeof source === 'object' && typeof source.code === 'string'
                 ? source
                 : error(errBadLoader(id));
         const cachedModule = this.graph.cachedModules.get(id);
         if (cachedModule &&
             !cachedModule.customTransformCache &&
-            cachedModule.originalCode === sourceDescription.code) {
+            cachedModule.originalCode === sourceDescription.code &&
+            !(await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
+                {
+                    ast: cachedModule.ast,
+                    code: cachedModule.code,
+                    id: cachedModule.id,
+                    meta: cachedModule.meta,
+                    moduleSideEffects: cachedModule.moduleSideEffects,
+                    syntheticNamedExports: cachedModule.syntheticNamedExports
+                }
+            ]))) {
             if (cachedModule.transformFiles) {
                 for (const emittedFile of cachedModule.transformFiles)
                     this.pluginDriver.emitFile(emittedFile);
@@ -22067,7 +22109,8 @@ class ModuleLoader {
         this.graph.watchFiles[id] = true;
         const loadPromise = this.addModuleSource(id, importer, module).then(() => [
             this.getResolveStaticDependencyPromises(module),
-            this.getResolveDynamicImportPromises(module)
+            this.getResolveDynamicImportPromises(module),
+            loadAndResolveDependenciesPromise
         ]);
         const loadAndResolveDependenciesPromise = loadPromise
             .then(([resolveStaticDependencyPromises, resolveDynamicImportPromises]) => Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]))
@@ -22075,23 +22118,25 @@ class ModuleLoader {
         loadAndResolveDependenciesPromise.catch(() => {
             /* avoid unhandled promise rejections */
         });
-        if (isPreload) {
-            this.moduleLoadPromises.set(module, loadPromise);
-            await loadPromise;
-        }
-        else {
-            await this.fetchModuleDependencies(module, ...(await loadPromise));
-            // To handle errors when resolving dependencies or in moduleParsed
-            await loadAndResolveDependenciesPromise;
+        this.moduleLoadPromises.set(module, loadPromise);
+        const resolveDependencyPromises = await loadPromise;
+        if (!isPreload) {
+            await this.fetchModuleDependencies(module, ...resolveDependencyPromises);
         }
         return module;
     }
-    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises) {
+    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises, loadAndResolveDependenciesPromise) {
+        if (this.modulesWithLoadedDependencies.has(module)) {
+            return;
+        }
+        this.modulesWithLoadedDependencies.add(module);
         await Promise.all([
             this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
             this.fetchDynamicDependencies(module, resolveDynamicDependencyPromises)
         ]);
         module.linkImports();
+        // To handle errors when resolving dependencies or in moduleParsed
+        await loadAndResolveDependenciesPromise;
     }
     fetchResolvedDependency(source, importer, resolvedId) {
         if (resolvedId.external) {
@@ -22180,8 +22225,7 @@ class ModuleLoader {
     async handleExistingModule(module, isEntry, isPreload) {
         const loadPromise = this.moduleLoadPromises.get(module);
         if (isPreload) {
-            await loadPromise;
-            return;
+            return loadPromise;
         }
         if (isEntry) {
             module.info.isEntry = true;
@@ -22191,11 +22235,7 @@ class ModuleLoader {
             }
             module.implicitlyLoadedAfter.clear();
         }
-        if (loadPromise) {
-            this.moduleLoadPromises.delete(module);
-            await this.fetchModuleDependencies(module, ...(await loadPromise));
-        }
-        return;
+        return this.fetchModuleDependencies(module, ...(await loadPromise));
     }
     handleResolveId(resolvedId, source, importer) {
         if (resolvedId === null) {
@@ -22206,7 +22246,7 @@ class ModuleLoader {
             return {
                 external: true,
                 id: source,
-                meta: EMPTY_OBJECT,
+                meta: {},
                 moduleSideEffects: this.hasModuleSideEffects(source, true),
                 syntheticNamedExports: false
             };
@@ -22401,6 +22441,40 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     return context;
 }
 
+const unfulfilledActions = new Set();
+function addUnresolvedAction(actionTuple) {
+    unfulfilledActions.add(actionTuple);
+}
+function resolveAction(actionTuple) {
+    unfulfilledActions.delete(actionTuple);
+}
+function formatAction([pluginName, hookName, args]) {
+    let action = `(${pluginName}) ${hookName}`;
+    const s = JSON.stringify;
+    switch (hookName) {
+        case 'resolveId':
+            action += ` ${s(args[0])} ${s(args[1])}`;
+            break;
+        case 'load':
+            action += ` ${s(args[0])}`;
+            break;
+        case 'transform':
+            action += ` ${s(args[1])}`;
+            break;
+    }
+    return action;
+}
+process.on('exit', () => {
+    if (unfulfilledActions.size) {
+        let err = '[!] Error: unfinished hook action(s) on exit:\n';
+        for (const action of unfulfilledActions) {
+            err += formatAction(action) + '\n';
+        }
+        console.error('%s', err);
+        process.exit(1);
+    }
+});
+
 const inputHookNames = {
     buildEnd: 1,
     buildStart: 1,
@@ -22411,6 +22485,7 @@ const inputHookNames = {
     options: 1,
     resolveDynamicImport: 1,
     resolveId: 1,
+    shouldTransformCachedModule: 1,
     transform: 1,
     watchChange: 1
 };
@@ -22552,6 +22627,7 @@ class PluginDriver {
         if (hookContext) {
             context = hookContext(context, plugin);
         }
+        let action = null;
         return Promise.resolve()
             .then(() => {
             // permit values allows values to be returned instead of a functional hook
@@ -22561,9 +22637,35 @@ class PluginDriver {
                 return throwInvalidHookError(hookName, plugin.name);
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            return hook.apply(context, args);
+            const hookResult = hook.apply(context, args);
+            if (!hookResult || !hookResult.then) {
+                // short circuit for non-thenables and non-Promises
+                return hookResult;
+            }
+            // Track pending hook actions to properly error out when
+            // unfulfilled promises cause rollup to abruptly and confusingly
+            // exit with a successful 0 return code but without producing any
+            // output, errors or warnings.
+            action = [plugin.name, hookName, args];
+            addUnresolvedAction(action);
+            // Although it would be more elegant to just return hookResult here
+            // and put the .then() handler just above the .catch() handler below,
+            // doing so would subtly change the defacto async event dispatch order
+            // which at least one test and some plugins in the wild may depend on.
+            const promise = Promise.resolve(hookResult);
+            return promise.then(() => {
+                // action was fulfilled
+                resolveAction(action);
+                return promise;
+            });
         })
-            .catch(err => throwPluginError(err, plugin.name, { hook: hookName }));
+            .catch(err => {
+            if (action !== null) {
+                // action considered to be fulfilled since error being handled
+                resolveAction(action);
+            }
+            return throwPluginError(err, plugin.name, { hook: hookName });
+        });
     }
     /**
      * Run a sync plugin hook and return the result.
@@ -22876,6 +22978,7 @@ const generatedCodePresets = {
         reservedNamesAsProps: true
     }
 };
+const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
 const objectifyOptionWithPresets = (presets, optionName, additionalValues) => (value) => {
     if (typeof value === 'string') {
         const preset = presets[value];
@@ -22884,7 +22987,7 @@ const objectifyOptionWithPresets = (presets, optionName, additionalValues) => (v
         }
         error(errInvalidOption(optionName, getHashFromObjectOption(optionName), `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
     }
-    return value && typeof value === 'object' ? value : {};
+    return objectifyOption(value);
 };
 const getOptionWithPreset = (value, presets, optionName, additionalValues) => {
     var _a;
@@ -23532,16 +23635,27 @@ function defineConfig(options) {
 
 let fsEvents;
 let fsEventsImportError;
-function loadFsEvents() {
+async function loadFsEvents() {
     const moduleName = 'fsevents';
-    return import(moduleName)
-        .then(namespace => {
-        fsEvents = namespace.default;
-    })
-        .catch(err => {
+    try {
+        ({ default: fsEvents } = await import(moduleName));
+    }
+    catch (err) {
         fsEventsImportError = err;
-    });
+    }
 }
+// A call to this function will be injected into the chokidar code
+function getFsEvents() {
+    if (fsEventsImportError)
+        throw fsEventsImportError;
+    return fsEvents;
+}
+
+const fseventsImporter = {
+  __proto__: null,
+  loadFsEvents,
+  getFsEvents
+};
 
 class WatchEmitter extends EventEmitter {
     constructor() {
@@ -23565,4 +23679,4 @@ function watch(configs) {
     return emitter;
 }
 
-export { createFilter, defaultOnWarn, defineConfig, ensureArray, generatedCodePresets, objectifyOptionWithPresets, picomatch, rollup, rollupInternal, treeshakePresets, version$1 as version, warnUnknownOptions, watch };
+export { createFilter, defaultOnWarn, defineConfig, ensureArray, fseventsImporter, generatedCodePresets, getAugmentedNamespace, objectifyOption, objectifyOptionWithPresets, picomatch, rollup, rollupInternal, treeshakePresets, version$1 as version, warnUnknownOptions, watch };