rollup 2.61.0 → 2.64.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @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
@@ -10,10 +10,12 @@
 */
 'use strict';
 
-const path$2 = require('path');
+const require$$0 = require('path');
+const process$1 = require('process');
+const perf_hooks = require('perf_hooks');
 const crypto = require('crypto');
 const fs = require('fs');
-const require$$0 = require('events');
+const require$$0$1 = require('events');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null);
@@ -26,7 +28,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.61.0";
+var version$1 = "2.64.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -140,13 +142,13 @@ function normalize(path) {
 }
 
 function getAliasName(id) {
-    const base = path$2.basename(id);
-    return base.substr(0, base.length - path$2.extname(id).length);
+    const base = require$$0.basename(id);
+    return base.substr(0, base.length - require$$0.extname(id).length);
 }
 function relativeId(id) {
     if (!isAbsolute(id))
         return id;
-    return path$2.relative(path$2.resolve(), id);
+    return require$$0.relative(require$$0.resolve(), id);
 }
 function isPathFragment(name) {
     // starting with "/", "./", "../", "C:/"
@@ -554,6 +556,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];
@@ -562,7 +565,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;
@@ -582,19 +585,45 @@ const getHashFromObjectOption = (optionName) => optionName.split('.').join('').t
 
 let fsEvents;
 let fsEventsImportError;
-function loadFsEvents() {
+async function loadFsEvents() {
     const moduleName = 'fsevents';
-    return Promise.resolve().then(() => /*#__PURE__*/_interopNamespaceDefault(require(moduleName)))
-        .then(namespace => {
-        fsEvents = namespace.default;
-    })
-        .catch(err => {
+    try {
+        ({ default: fsEvents } = await Promise.resolve().then(() => /*#__PURE__*/_interopNamespaceDefault(require(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
+};
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+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 charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
 for (var i = 0; i < chars$1.length; i++) {
@@ -2225,20 +2254,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 || '_';
 }
@@ -2280,6 +2359,7 @@ class ExternalModule {
             },
             isEntry: false,
             isExternal: true,
+            isIncluded: null,
             meta,
             syntheticNamedExports: false
         };
@@ -2297,7 +2377,7 @@ class ExternalModule {
             typeof options.paths === 'function' ? options.paths(this.id) : options.paths[this.id];
         if (!this.renderPath) {
             this.renderPath = this.renormalizeRenderPath
-                ? normalize(path$2.relative(inputBase, this.id))
+                ? normalize(require$$0.relative(inputBase, this.id))
                 : this.id;
         }
         return this.renderPath;
@@ -2340,7 +2420,7 @@ class ExternalModule {
 
 var utils$3 = {};
 
-const path$1 = path$2;
+const path$1 = require$$0;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -2520,7 +2600,7 @@ var constants$2 = {
 
 (function (exports) {
 
-const path = path$2;
+const path = require$$0;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
@@ -4050,7 +4130,7 @@ parse$1.fastpaths = (input, options) => {
 
 var parse_1 = parse$1;
 
-const path = path$2;
+const path = require$$0;
 const scan = scan_1;
 const parse = parse_1;
 const utils = utils$3;
@@ -4443,22 +4523,22 @@ function ensureArray(thing) {
 }
 
 const normalizePath = function normalizePath(filename) {
-    return filename.split(path$2.win32.sep).join(path$2.posix.sep);
+    return filename.split(require$$0.win32.sep).join(require$$0.posix.sep);
 };
 
 function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || path$2.isAbsolute(id) || id.startsWith('*')) {
+    if (resolutionBase === false || require$$0.isAbsolute(id) || id.startsWith('*')) {
         return id;
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath(path$2.resolve(resolutionBase || ''))
+    const basePath = normalizePath(require$$0.resolve(resolutionBase || ''))
         // escape all possible (posix + win) path characters that might interfere with regex
         .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
     // Note that we use posix.join because:
     // 1. the basePath has been normalized to use /
     // 2. the incoming glob (id) matcher, also uses /
     // otherwise Node will force backslash (\) on windows
-    return path$2.posix.join(basePath, id);
+    return require$$0.posix.join(basePath, id);
 }
 const createFilter = function createFilter(include, exclude, options) {
     const resolutionBase = options && options.resolve;
@@ -5522,8 +5602,6 @@ const knownGlobals = {
         __proto__: null,
         [ValueProperties]: PURE,
         create: PF,
-        getNotifier: PF,
-        getOwn: PF,
         getOwnPropertyDescriptor: PF,
         getOwnPropertyNames: PF,
         getOwnPropertySymbols: PF,
@@ -6565,62 +6643,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);
@@ -6731,16 +6757,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,
@@ -6751,17 +6788,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) {
@@ -8577,6 +8629,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,
@@ -8594,6 +8650,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);
@@ -10845,7 +10903,7 @@ class MetaProperty extends NodeBase {
                 chunkReferenceId = metaProperty.substr(CHUNK_PREFIX.length);
                 fileName = outputPluginDriver.getFileName(chunkReferenceId);
             }
-            const relativePath = normalize(path$2.relative(path$2.dirname(chunkId), fileName));
+            const relativePath = normalize(require$$0.relative(require$$0.dirname(chunkId), fileName));
             let replacement;
             if (assetReferenceId !== null) {
                 replacement = outputPluginDriver.hookFirstSync('resolveAssetUrl', [
@@ -12046,13 +12104,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];
@@ -12081,24 +12145,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:
@@ -12113,46 +12160,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 = perf_hooks.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 += perf_hooks.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})`;
@@ -12160,11 +12208,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;
                     });
@@ -12172,16 +12220,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);
@@ -12325,10 +12372,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);
@@ -12338,13 +12385,19 @@ class Module {
             },
             isEntry,
             isExternal: false,
-            meta,
+            get isIncluded() {
+                if (module.graph.phase !== BuildPhase.GENERATE) {
+                    return null;
+                }
+                return module.isIncluded();
+            },
+            meta: { ...meta },
             syntheticNamedExports
         };
     }
     basename() {
-        const base = path$2.basename(this.id);
-        const ext = path$2.extname(this.id);
+        const base = require$$0.basename(this.id);
+        const ext = require$$0.extname(this.id);
         return makeLegal(ext ? base.slice(0, -ext.length) : base);
     }
     bindReferences() {
@@ -12359,7 +12412,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)) {
@@ -12383,12 +12436,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) {
@@ -12770,7 +12822,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) {
@@ -12861,11 +12913,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,
@@ -13012,7 +13060,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);
                 }
@@ -13962,9 +14010,9 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
     else {
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
-        const directory = path$2.dirname(id) || '.';
+        const directory = require$$0.dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
-        const baseSources = sources.map((source, i) => new Source(path$2.resolve(directory, sourceRoot, source), sourcesContent[i]));
+        const baseSources = sources.map((source, i) => new Source(require$$0.resolve(directory, sourceRoot, source), sourcesContent[i]));
         source = new Link(originalSourcemap, baseSources);
     }
     return sourcemapChain.reduce(linkMap, source);
@@ -13980,9 +14028,9 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     source = bundleSourcemapChain.reduce(linkMap, source);
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
-        const directory = path$2.dirname(file);
-        sources = sources.map((source) => path$2.relative(directory, source));
-        file = path$2.basename(file);
+        const directory = require$$0.dirname(file);
+        sources = sources.map((source) => require$$0.relative(directory, source));
+        file = require$$0.basename(file);
     }
     sourcesContent = (excludeContent ? null : sourcesContent);
     return new SourceMap({ file, mappings, names, sources, sourcesContent });
@@ -14128,7 +14176,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);
@@ -14137,7 +14185,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]);
@@ -14314,7 +14362,7 @@ function makeUnique(name, existingNames) {
     const existingNamesLowercase = new Set(Object.keys(existingNames).map(key => key.toLowerCase()));
     if (!existingNamesLowercase.has(name.toLocaleLowerCase()))
         return name;
-    const ext = path$2.extname(name);
+    const ext = require$$0.extname(name);
     name = name.substr(0, name.length - ext.length);
     let uniqueName, uniqueIndex = 1;
     while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
@@ -14370,6 +14418,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;
@@ -14555,7 +14604,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')
@@ -14563,8 +14612,8 @@ class Chunk {
             : options.entryFileNames;
         const pattern = typeof patternOpt === 'function' ? patternOpt(this.getChunkInfo()) : patternOpt;
         if (isAbsolute(id)) {
-            const currentDir = path$2.dirname(sanitizedId);
-            const extension = path$2.extname(id);
+            const currentDir = require$$0.dirname(sanitizedId);
+            const extension = require$$0.extname(id);
             const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
                 assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
                 ext: () => extension.substr(1),
@@ -14582,7 +14631,7 @@ class Chunk {
             }
         }
         else {
-            const extension = path$2.extname(sanitizedId);
+            const extension = require$$0.extname(sanitizedId);
             const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
                 assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
                 ext: () => extension.substr(1),
@@ -14835,11 +14884,11 @@ class Chunk {
             timeStart('sourcemap', 2);
             let file;
             if (options.file)
-                file = path$2.resolve(options.sourcemapFile || options.file);
+                file = require$$0.resolve(options.sourcemapFile || options.file);
             else if (options.dir)
-                file = path$2.resolve(options.dir, this.id);
+                file = require$$0.resolve(options.dir, this.id);
             else
-                file = path$2.resolve(this.id);
+                file = require$$0.resolve(this.id);
             const decodedMap = magicString.generateDecodedMap({});
             map = collapseSourcemaps(file, decodedMap, this.usedModules, chunkSourcemapChain, options.sourcemapExcludeSources, this.inputOptions.onwarn);
             map.sources = map.sources
@@ -15204,14 +15253,14 @@ class Chunk {
         return referencedFiles;
     }
     getRelativePath(targetPath, stripJsExtension) {
-        let relativePath = normalize(relative(path$2.dirname(this.id), targetPath));
+        let relativePath = normalize(relative(require$$0.dirname(this.id), targetPath));
         if (stripJsExtension && relativePath.endsWith('.js')) {
             relativePath = relativePath.slice(0, -3);
         }
         if (relativePath === '..')
-            return '../../' + path$2.basename(targetPath);
+            return '../../' + require$$0.basename(targetPath);
         if (relativePath === '')
-            return '../' + path$2.basename(targetPath);
+            return '../' + require$$0.basename(targetPath);
         return relativePath.startsWith('../') ? relativePath : './' + relativePath;
     }
     inlineChunkDependencies(chunk) {
@@ -15355,20 +15404,13 @@ 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'
         ? outputOptions.assetFileNames({ name, source, type: 'asset' })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => path$2.extname(emittedName).substr(1),
-        extname: () => path$2.extname(emittedName),
+        ext: () => require$$0.extname(emittedName).substr(1),
+        extname: () => require$$0.extname(emittedName),
         hash() {
             const hash = createHash();
             hash.update(emittedName);
@@ -15376,7 +15418,7 @@ function generateAssetFileName(name, source, outputOptions, bundle) {
             hash.update(source);
             return hash.digest('hex').substr(0, 8);
         },
-        name: () => emittedName.substr(0, emittedName.length - path$2.extname(emittedName).length)
+        name: () => emittedName.substr(0, emittedName.length - require$$0.extname(emittedName).length)
     }), bundle);
 }
 function reserveFileNameInBundle(fileName, bundle, warn) {
@@ -15768,7 +15810,7 @@ function commondir(files) {
     if (files.length === 0)
         return '/';
     if (files.length === 1)
-        return path$2.dirname(files[0]);
+        return require$$0.dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegements = file.split(/\/+|\\+/);
         let i;
@@ -15872,7 +15914,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,
@@ -15988,7 +16030,7 @@ class Bundle {
         const chunksForNaming = entryChunks.concat(otherChunks);
         for (const chunk of chunksForNaming) {
             if (this.outputOptions.file) {
-                chunk.id = path$2.basename(this.outputOptions.file);
+                chunk.id = require$$0.basename(this.outputOptions.file);
             }
             else if (this.outputOptions.preserveModules) {
                 chunk.id = chunk.generateIdPreserveModules(inputBase, this.outputOptions, bundle, this.unsetOptions);
@@ -16097,7 +16139,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) {
@@ -21641,7 +21683,7 @@ Parser.acorn = {
 
 const readFile = (file) => new Promise((fulfil, reject) => fs.readFile(file, 'utf-8', (err, contents) => (err ? reject(err) : fulfil(contents))));
 function mkdirpath(path) {
-    const dir = path$2.dirname(path);
+    const dir = require$$0.dirname(path);
     fs.mkdirSync(dir, { recursive: true });
 }
 function writeFile(dest, data) {
@@ -21659,9 +21701,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) {
@@ -21721,7 +21763,7 @@ async function resolveId(source, importer, preserveSymlinks, pluginDriver, modul
     // absolute path is created. Absolute importees therefore shortcircuit the
     // resolve call and require no special handing on our part.
     // See https://nodejs.org/api/path.html#path_path_resolve_paths
-    return addJsExtensionIfNecessary(importer ? path$2.resolve(path$2.dirname(importer), source) : path$2.resolve(source), preserveSymlinks);
+    return addJsExtensionIfNecessary(importer ? require$$0.resolve(require$$0.dirname(importer), source) : require$$0.resolve(source), preserveSymlinks);
 }
 function addJsExtensionIfNecessary(file, preserveSymlinks) {
     let found = findFile(file, preserveSymlinks);
@@ -21740,8 +21782,8 @@ function findFile(file, preserveSymlinks) {
             return findFile(fs.realpathSync(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
-            const name = path$2.basename(file);
-            const files = fs.readdirSync(path$2.dirname(file));
+            const name = require$$0.basename(file);
+            const files = fs.readdirSync(require$$0.dirname(file));
             if (files.indexOf(name) !== -1)
                 return file;
         }
@@ -21871,7 +21913,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);
@@ -21881,7 +21923,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;
@@ -21912,90 +21954,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 {
@@ -22008,8 +22051,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
@@ -22018,7 +22061,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))));
@@ -22069,8 +22112,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;
@@ -22081,7 +22125,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
         };
@@ -22120,13 +22164,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);
@@ -22186,7 +22240,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]))
@@ -22194,23 +22249,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) {
@@ -22299,8 +22356,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;
@@ -22310,11 +22366,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) {
@@ -22325,7 +22377,7 @@ class ModuleLoader {
             return {
                 external: true,
                 id: source,
-                meta: EMPTY_OBJECT,
+                meta: {},
                 moduleSideEffects: this.hasModuleSideEffects(source, true),
                 syntheticNamedExports: false
             };
@@ -22383,8 +22435,8 @@ class ModuleLoader {
 function normalizeRelativeExternalId(source, importer) {
     return isRelative(source)
         ? importer
-            ? path$2.resolve(importer, '..', source)
-            : path$2.resolve(source)
+            ? require$$0.resolve(importer, '..', source)
+            : require$$0.resolve(source)
         : source;
 }
 function addChunkNamesToModule(module, { fileName, name }, isUserDefined) {
@@ -22520,6 +22572,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,
@@ -22530,6 +22616,7 @@ const inputHookNames = {
     options: 1,
     resolveDynamicImport: 1,
     resolveId: 1,
+    shouldTransformCachedModule: 1,
     transform: 1,
     watchChange: 1
 };
@@ -22671,6 +22758,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
@@ -22680,9 +22768,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.
@@ -23047,7 +23161,7 @@ const getModuleContext = (config, context) => {
     if (configModuleContext) {
         const contextByModuleId = Object.create(null);
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
-            contextByModuleId[path$2.resolve(key)] = moduleContext;
+            contextByModuleId[require$$0.resolve(key)] = moduleContext;
         }
         return id => contextByModuleId[id] || context;
     }
@@ -23253,7 +23367,7 @@ const getPreserveModulesRoot = (config) => {
     if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
         return undefined;
     }
-    return path$2.resolve(preserveModulesRoot);
+    return require$$0.resolve(preserveModulesRoot);
 };
 const getAmd = (config) => {
     const mergedOption = {
@@ -23525,7 +23639,7 @@ function getSortingFileType(file) {
     return SortingFileType.SECONDARY_CHUNK;
 }
 function writeOutputFile(outputFile, outputOptions) {
-    const fileName = path$2.resolve(outputOptions.dir || path$2.dirname(outputOptions.file), outputFile.fileName);
+    const fileName = require$$0.resolve(outputOptions.dir || require$$0.dirname(outputOptions.file), outputFile.fileName);
     let writeSourceMapPromise;
     let source;
     if (outputFile.type === 'asset') {
@@ -23539,7 +23653,7 @@ function writeOutputFile(outputFile, outputOptions) {
                 url = outputFile.map.toUrl();
             }
             else {
-                url = `${path$2.basename(outputFile.fileName)}.map`;
+                url = `${require$$0.basename(outputFile.fileName)}.map`;
                 writeSourceMapPromise = writeFile(`${fileName}.map`, outputFile.map.toString());
             }
             if (outputOptions.sourcemap !== 'hidden') {
@@ -23558,7 +23672,7 @@ function defineConfig(options) {
     return options;
 }
 
-class WatchEmitter extends require$$0.EventEmitter {
+class WatchEmitter extends require$$0$1.EventEmitter {
     constructor() {
         super();
         // Allows more than 10 bundles to be watched without
@@ -23586,10 +23700,13 @@ exports.defaultOnWarn = defaultOnWarn;
 exports.defineConfig = defineConfig;
 exports.ensureArray = ensureArray$1;
 exports.error = error;
+exports.fseventsImporter = fseventsImporter;
 exports.generatedCodePresets = generatedCodePresets;
 exports.getAliasName = getAliasName;
+exports.getAugmentedNamespace = getAugmentedNamespace;
 exports.getOrCreate = getOrCreate;
 exports.loadFsEvents = loadFsEvents;
+exports.objectifyOption = objectifyOption;
 exports.objectifyOptionWithPresets = objectifyOptionWithPresets;
 exports.picomatch = picomatch;
 exports.printQuotedStringList = printQuotedStringList;