rollup 3.0.0-3 → 3.0.0-4

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.0.0-2
-	Sat, 30 Jul 2022 12:51:34 GMT - commit 41906cedefbc03640d6e8ca23ce6975f3bb5c6a1
+	Rollup.js v3.0.0-3
+	Mon, 15 Aug 2022 04:43:13 GMT - commit 84a4a595851ef71494b6f2ab558968bfbc148bdb
 
 	https://github.com/rollup/rollup
 
@@ -9,12 +9,13 @@
 */
 'use strict';
 
+const node_path = require('node:path');
 const require$$0 = require('path');
-const process$1 = require('process');
-const perf_hooks = require('perf_hooks');
-const crypto = require('crypto');
-const require$$0$1 = require('fs');
-const require$$0$2 = require('events');
+const process$1 = require('node:process');
+const node_perf_hooks = require('node:perf_hooks');
+const node_crypto = require('node:crypto');
+const node_fs = require('node:fs');
+const node_events = require('node:events');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -27,7 +28,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "3.0.0-2";
+var version$1 = "3.0.0-3";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -162,13 +163,13 @@ function normalize(path) {
 }
 
 function getAliasName(id) {
-    const base = require$$0.basename(id);
-    return base.substring(0, base.length - require$$0.extname(id).length);
+    const base = node_path.basename(id);
+    return base.substring(0, base.length - node_path.extname(id).length);
 }
 function relativeId(id) {
     if (!isAbsolute(id))
         return id;
-    return relative(require$$0.resolve(), id);
+    return relative(node_path.resolve(), id);
 }
 function isPathFragment(name) {
     // starting with "/", "./", "../", "C:/"
@@ -176,17 +177,17 @@ function isPathFragment(name) {
 }
 const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
 function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
-    let relativePath = normalize(relative(require$$0.dirname(importerId), targetPath));
+    let relativePath = normalize(relative(node_path.dirname(importerId), targetPath));
     if (stripJsExtension && relativePath.endsWith('.js')) {
         relativePath = relativePath.slice(0, -3);
     }
     if (ensureFileName) {
         if (relativePath === '')
-            return '../' + require$$0.basename(targetPath);
+            return '../' + node_path.basename(targetPath);
         if (UPPER_DIR_REGEX.test(relativePath)) {
             return relativePath
                 .split('/')
-                .concat(['..', require$$0.basename(targetPath)])
+                .concat(['..', node_path.basename(targetPath)])
                 .join('/');
         }
     }
@@ -435,11 +436,19 @@ function errInvalidOption(option, urlHash, explanation, value) {
         url: `https://rollupjs.org/guide/en/#${urlHash}`
     };
 }
-function errInvalidPluginHook(hook, plugin) {
+function errInvalidAddonPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
-        message: `Error running plugin hook "${hook}" for "${plugin}", expected a function hook.`,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a string, a function hook or an object with a "handler" string or function.`,
+        plugin
+    };
+}
+function errInvalidFunctionPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a function hook or an object with a "handler" function.`,
         plugin
     };
 }
@@ -2358,7 +2367,7 @@ class ExternalChunk {
         const { paths } = this.options;
         return (this.fileName =
             (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
-                (this.renormalizeRenderPath ? normalize(require$$0.relative(this.inputBase, this.id)) : this.id));
+                (this.renormalizeRenderPath ? normalize(node_path.relative(this.inputBase, this.id)) : this.id));
     }
     getImportPath(importer) {
         return escapeId(this.renormalizeRenderPath
@@ -5431,10 +5440,10 @@ const SequenceExpression$1 = 'SequenceExpression';
 
 // this looks ridiculous, but it prevents sourcemap tooling from mistaking
 // this for an actual sourceMappingURL
-exports.SOURCEMAPPING_URL = 'sourceMa';
-exports.SOURCEMAPPING_URL += 'ppingURL';
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
 const whiteSpaceNoNewline = '[ \\f\\r\\t\\v\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]';
-const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${exports.SOURCEMAPPING_URL}=.+`);
+const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${SOURCEMAPPING_URL}=.+`);
 
 const ANNOTATION_KEY = '_rollupAnnotations';
 const INVALID_COMMENT_KEY = '_rollupRemoved';
@@ -10943,7 +10952,7 @@ class MetaProperty extends NodeBase {
         const chunkId = this.preliminaryChunkId;
         if (referenceId) {
             const fileName = pluginDriver.getFileName(referenceId);
-            const relativePath = normalize(require$$0.relative(require$$0.dirname(chunkId), fileName));
+            const relativePath = normalize(node_path.relative(node_path.dirname(chunkId), fileName));
             const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
                 {
                     chunkId,
@@ -12453,7 +12462,7 @@ function getPersistedLabel(label, level) {
 function timeStartImpl(label, level = 3) {
     label = getPersistedLabel(label, level);
     const startMemory = process$1.memoryUsage().heapUsed;
-    const startTime = perf_hooks.performance.now();
+    const startTime = node_perf_hooks.performance.now();
     const timer = timers.get(label);
     if (timer === undefined) {
         timers.set(label, {
@@ -12475,7 +12484,7 @@ function timeEndImpl(label, level = 3) {
     if (timer !== undefined) {
         const currentMemory = process$1.memoryUsage().heapUsed;
         timer.memory += currentMemory - timer.startMemory;
-        timer.time += perf_hooks.performance.now() - timer.startTime;
+        timer.time += node_perf_hooks.performance.now() - timer.startTime;
         timer.totalMemory = Math.max(timer.totalMemory, currentMemory);
     }
 }
@@ -12715,8 +12724,8 @@ class Module {
         });
     }
     basename() {
-        const base = require$$0.basename(this.id);
-        const ext = require$$0.extname(this.id);
+        const base = node_path.basename(this.id);
+        const ext = node_path.extname(this.id);
         return makeLegal(ext ? base.slice(0, -ext.length) : base);
     }
     bindReferences() {
@@ -13599,32 +13608,32 @@ function removeExtensionFromRelativeAmdId(id) {
 }
 
 const builtins = {
-    assert: true,
-    buffer: true,
-    console: true,
-    constants: true,
-    domain: true,
-    events: true,
-    http: true,
-    https: true,
-    os: true,
-    path: true,
-    process: true,
-    punycode: true,
-    querystring: true,
-    stream: true,
-    string_decoder: true,
-    timers: true,
-    tty: true,
-    url: true,
-    util: true,
-    vm: true,
-    zlib: true
+    assert: 1,
+    buffer: 1,
+    console: 1,
+    constants: 1,
+    domain: 1,
+    events: 1,
+    http: 1,
+    https: 1,
+    os: 1,
+    path: 1,
+    process: 1,
+    punycode: 1,
+    querystring: 1,
+    stream: 1,
+    string_decoder: 1,
+    timers: 1,
+    tty: 1,
+    url: 1,
+    util: 1,
+    vm: 1,
+    zlib: 1
 };
 function warnOnBuiltins(warn, dependencies) {
     const externalBuiltins = dependencies
         .map(({ importPath }) => importPath)
-        .filter(importPath => importPath in builtins);
+        .filter(importPath => importPath in builtins || importPath.startsWith('node:'));
     if (!externalBuiltins.length)
         return;
     warn(errMissingNodeBuiltins(externalBuiltins));
@@ -14161,7 +14170,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
 
 const finalisers = { amd, cjs, es, iife, system, umd };
 
-const createHash = () => crypto.createHash('sha256');
+const createHash = () => node_crypto.createHash('sha256');
 
 // Four random characters from the private use area to minimize risk of conflicts
 const hashPlaceholderLeft = '\uf7f9\ue4d3';
@@ -14216,7 +14225,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 = require$$0.extname(name);
+    const ext = node_path.extname(name);
     name = name.substring(0, name.length - ext.length);
     let uniqueName, uniqueIndex = 1;
     while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
@@ -14229,13 +14238,13 @@ function generateAssetFileName(name, source, outputOptions, bundle) {
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
         ? outputOptions.assetFileNames({ name, source, type: 'asset' })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => require$$0.extname(emittedName).substring(1),
-        extname: () => require$$0.extname(emittedName),
+        ext: () => node_path.extname(emittedName).substring(1),
+        extname: () => node_path.extname(emittedName),
         hash: size => createHash()
             .update(source)
             .digest('hex')
             .substring(0, size || defaultHashSize),
-        name: () => emittedName.substring(0, emittedName.length - require$$0.extname(emittedName).length)
+        name: () => emittedName.substring(0, emittedName.length - node_path.extname(emittedName).length)
     }), bundle);
 }
 function reserveFileNameInBundle(fileName, bundle, warn) {
@@ -14979,7 +14988,7 @@ class Chunk {
         let hashPlaceholder = null;
         const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
         if (file) {
-            fileName = require$$0.basename(file);
+            fileName = node_path.basename(file);
         }
         else if (this.fileName !== null) {
             fileName = this.fileName;
@@ -15344,17 +15353,17 @@ class Chunk {
             return predefinedChunkName;
         const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
         const sanitizedId = sanitizeFileName(module.id.split(QUERY_HASH_REGEX, 1)[0]);
-        const extName = require$$0.extname(sanitizedId);
+        const extName = node_path.extname(sanitizedId);
         const idWithoutExtension = NON_ASSET_EXTENSIONS.includes(extName)
             ? sanitizedId.slice(0, -extName.length)
             : sanitizedId;
         if (isAbsolute(idWithoutExtension)) {
-            return preserveModulesRoot && idWithoutExtension.startsWith(preserveModulesRoot)
+            return preserveModulesRoot && node_path.resolve(idWithoutExtension).startsWith(preserveModulesRoot)
                 ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[\\/]/, '')
                 : relative(this.inputBase, idWithoutExtension);
         }
         else {
-            return `_virtual/${require$$0.basename(idWithoutExtension)}`;
+            return `_virtual/${node_path.basename(idWithoutExtension)}`;
         }
     }
     getReexportSpecifiers() {
@@ -15826,7 +15835,7 @@ function commondir(files) {
     if (files.length === 0)
         return '/';
     if (files.length === 1)
-        return require$$0.dirname(files[0]);
+        return node_path.dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegements = file.split(/\/+|\\+/);
         let i;
@@ -16083,9 +16092,9 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
     else {
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
-        const directory = require$$0.dirname(id) || '.';
+        const directory = node_path.dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
-        const baseSources = sources.map((source, i) => new Source(require$$0.resolve(directory, sourceRoot, source), sourcesContent[i]));
+        const baseSources = sources.map((source, i) => new Source(node_path.resolve(directory, sourceRoot, source), sourcesContent[i]));
         source = new Link(originalSourcemap, baseSources);
     }
     return sourcemapChain.reduce(linkMap, source);
@@ -16099,9 +16108,9 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     const source = bundleSourcemapChain.reduce(linkMap, link);
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
-        const directory = require$$0.dirname(file);
-        sources = sources.map((source) => require$$0.relative(directory, source));
-        file = require$$0.basename(file);
+        const directory = node_path.dirname(file);
+        sources = sources.map((source) => node_path.relative(directory, source));
+        file = node_path.basename(file);
     }
     sourcesContent = (excludeContent ? null : sourcesContent);
     return new SourceMap({ file, mappings, names, sources, sourcesContent });
@@ -16142,7 +16151,7 @@ async function renderChunks(chunks, outputBundle, pluginDriver, outputOptions, o
     const chunkGraph = getChunkGraph(chunks);
     const { nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn);
     const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle);
-    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
     timeEnd('transform chunks', 2);
 }
 function reserveEntryChunksInBundle(chunks) {
@@ -16184,11 +16193,11 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         timeStart('sourcemaps', 3);
         let file;
         if (options.file)
-            file = require$$0.resolve(options.sourcemapFile || options.file);
+            file = node_path.resolve(options.sourcemapFile || options.file);
         else if (options.dir)
-            file = require$$0.resolve(options.dir, fileName);
+            file = node_path.resolve(options.dir, fileName);
         else
-            file = require$$0.resolve(fileName);
+            file = node_path.resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
         map = collapseSourcemaps(file, decodedMap, usedModules, sourcemapChain, options.sourcemapExcludeSources, onwarn);
         map.sources = map.sources
@@ -16286,22 +16295,40 @@ function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlac
     }
     return hashesByPlaceholder;
 }
-function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders) {
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
     for (const { chunk, code, fileName, map } of renderedChunksByPlaceholder.values()) {
-        const updatedCode = replacePlaceholders(code, hashesByPlaceholder);
+        let updatedCode = replacePlaceholders(code, hashesByPlaceholder);
         const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
         if (map) {
             map.file = replacePlaceholders(map.file, hashesByPlaceholder);
+            updatedCode += emitSourceMapAndGetComment(finalFileName, map, pluginDriver, options);
         }
         outputBundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
     for (const { chunk, code, fileName, map } of nonHashedChunksWithPlaceholders) {
-        const updatedCode = hashesByPlaceholder.size
+        let updatedCode = hashesByPlaceholder.size
             ? replacePlaceholders(code, hashesByPlaceholder)
             : code;
+        if (map) {
+            updatedCode += emitSourceMapAndGetComment(fileName, map, pluginDriver, options);
+        }
         outputBundle[fileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
 }
+function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, sourcemapBaseUrl }) {
+    let url;
+    if (sourcemap === 'inline') {
+        url = map.toUrl();
+    }
+    else {
+        const sourcemapFileName = `${node_path.basename(fileName)}.map`;
+        url = sourcemapBaseUrl
+            ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
+            : sourcemapFileName;
+        pluginDriver.emitFile({ fileName: `${fileName}.map`, source: map.toString(), type: 'asset' });
+    }
+    return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
+}
 
 class Bundle {
     constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
@@ -22057,7 +22084,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 ? require$$0.resolve(require$$0.dirname(importer), source) : require$$0.resolve(source), preserveSymlinks);
+    return addJsExtensionIfNecessary(importer ? node_path.resolve(node_path.dirname(importer), source) : node_path.resolve(source), preserveSymlinks);
 }
 async function addJsExtensionIfNecessary(file, preserveSymlinks) {
     var _a, _b;
@@ -22065,13 +22092,13 @@ async function addJsExtensionIfNecessary(file, preserveSymlinks) {
 }
 async function findFile(file, preserveSymlinks) {
     try {
-        const stats = await require$$0$1.promises.lstat(file);
+        const stats = await node_fs.promises.lstat(file);
         if (!preserveSymlinks && stats.isSymbolicLink())
-            return await findFile(await require$$0$1.promises.realpath(file), preserveSymlinks);
+            return await findFile(await node_fs.promises.realpath(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
-            const name = require$$0.basename(file);
-            const files = await require$$0$1.promises.readdir(require$$0.dirname(file));
+            const name = node_path.basename(file);
+            const files = await node_fs.promises.readdir(node_path.dirname(file));
             if (files.includes(name))
                 return file;
         }
@@ -22380,7 +22407,7 @@ class ModuleLoader {
     async addModuleSource(id, importer, module) {
         let source;
         try {
-            source = await this.graph.fileOperationQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await require$$0$1.promises.readFile(id, 'utf8')); });
+            source = await this.graph.fileOperationQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await node_fs.promises.readFile(id, 'utf8')); });
         }
         catch (err) {
             let msg = `Could not load ${id}`;
@@ -22677,8 +22704,8 @@ class ModuleLoader {
 function normalizeRelativeExternalId(source, importer) {
     return isRelative(source)
         ? importer
-            ? require$$0.resolve(importer, '..', source)
-            : require$$0.resolve(source)
+            ? node_path.resolve(importer, '..', source)
+            : node_path.resolve(source)
         : source;
 }
 function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
@@ -22743,7 +22770,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     else {
         cacheInstance = getCacheForUncacheablePlugin(plugin.name);
     }
-    const context = {
+    return {
         addWatchFile(id) {
             if (graph.phase >= BuildPhase.GENERATE) {
                 return this.error(errInvalidRollupPhaseForAddWatchFile());
@@ -22793,9 +22820,9 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             options.onwarn(warning);
         }
     };
-    return context;
 }
 
+// This will make sure no input hook is omitted
 const inputHookNames = {
     buildEnd: 1,
     buildStart: 1,
@@ -22815,8 +22842,9 @@ class PluginDriver {
     constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
         this.graph = graph;
         this.options = options;
-        this.unfulfilledActions = new Set();
         this.pluginCache = pluginCache;
+        this.sortedPlugins = new Map();
+        this.unfulfilledActions = new Set();
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
         this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
         this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
@@ -22847,21 +22875,21 @@ class PluginDriver {
     }
     // chains, first non-null result stops and returns
     hookFirst(hookName, args, replaceContext, skipped) {
-        let promise = Promise.resolve(undefined);
-        for (const plugin of this.plugins) {
+        let promise = Promise.resolve(null);
+        for (const plugin of this.getSortedPlugins(hookName)) {
             if (skipped && skipped.has(plugin))
                 continue;
             promise = promise.then(result => {
                 if (result != null)
                     return result;
-                return this.runHook(hookName, args, plugin, false, replaceContext);
+                return this.runHook(hookName, args, plugin, replaceContext);
             });
         }
         return promise;
     }
     // chains synchronously, first non-null result stops and returns
     hookFirstSync(hookName, args, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             if (result != null)
                 return result;
@@ -22869,56 +22897,58 @@ class PluginDriver {
         return null;
     }
     // parallel, ignores returns
-    hookParallel(hookName, args, replaceContext) {
-        const promises = [];
-        for (const plugin of this.plugins) {
-            const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-            if (!hookPromise)
-                continue;
-            promises.push(hookPromise);
+    async hookParallel(hookName, args, replaceContext) {
+        const parallelPromises = [];
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (plugin[hookName].sequential) {
+                await Promise.all(parallelPromises);
+                parallelPromises.length = 0;
+                await this.runHook(hookName, args, plugin, replaceContext);
+            }
+            else {
+                parallelPromises.push(this.runHook(hookName, args, plugin, replaceContext));
+            }
         }
-        return Promise.all(promises).then(() => { });
+        await Promise.all(parallelPromises);
     }
     // chains, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0(hookName, [arg0, ...rest], reduce, replaceContext) {
         let promise = Promise.resolve(arg0);
-        for (const plugin of this.plugins) {
-            promise = promise.then(arg0 => {
-                const args = [arg0, ...rest];
-                const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-                if (!hookPromise)
-                    return arg0;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin));
-            });
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(arg0 => this.runHook(hookName, [arg0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin)));
         }
         return promise;
     }
     // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0Sync(hookName, [arg0, ...rest], reduce, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const args = [arg0, ...rest];
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             arg0 = reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin);
         }
         return arg0;
     }
-    // chains, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
-    hookReduceValue(hookName, initialValue, args, reduce, replaceContext) {
-        let promise = Promise.resolve(initialValue);
-        for (const plugin of this.plugins) {
-            promise = promise.then(value => {
-                const hookPromise = this.runHook(hookName, args, plugin, true, replaceContext);
-                if (!hookPromise)
-                    return value;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), value, result, plugin));
-            });
+    // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
+    async hookReduceValue(hookName, initialValue, args, reducer) {
+        const results = [];
+        const parallelResults = [];
+        for (const plugin of this.getSortedPlugins(hookName, validateAddonPluginHandler)) {
+            if (plugin[hookName].sequential) {
+                results.push(...(await Promise.all(parallelResults)));
+                parallelResults.length = 0;
+                results.push(await this.runHook(hookName, args, plugin));
+            }
+            else {
+                parallelResults.push(this.runHook(hookName, args, plugin));
+            }
         }
-        return promise;
+        results.push(...(await Promise.all(parallelResults)));
+        return results.reduce(reducer, await initialValue);
     }
     // chains synchronously, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
     hookReduceValueSync(hookName, initialValue, args, reduce, replaceContext) {
         let acc = initialValue;
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             acc = reduce.call(this.pluginContexts.get(plugin), acc, result, plugin);
         }
@@ -22927,31 +22957,32 @@ class PluginDriver {
     // chains, ignores returns
     hookSeq(hookName, args, replaceContext) {
         let promise = Promise.resolve();
-        for (const plugin of this.plugins) {
-            promise = promise.then(() => this.runHook(hookName, args, plugin, false, replaceContext));
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(() => this.runHook(hookName, args, plugin, replaceContext));
         }
-        return promise;
+        return promise.then(noReturn);
+    }
+    getSortedPlugins(hookName, validateHandler) {
+        return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
     }
-    runHook(hookName, args, plugin, permitValues, hookContext) {
+    // Implementation signature
+    runHook(hookName, args, plugin, replaceContext) {
+        // We always filter for plugins that support the hook before running it
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         let action = null;
         return Promise.resolve()
             .then(() => {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                if (permitValues)
-                    return hook;
-                return error(errInvalidPluginHook(hookName, plugin.name));
+            if (typeof handler !== 'function') {
+                return handler;
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            const hookResult = hook.apply(context, args);
-            if (!hookResult || !hookResult.then) {
+            const hookResult = handler.apply(context, args);
+            if (!(hookResult === null || hookResult === void 0 ? void 0 : hookResult.then)) {
                 // short circuit for non-thenables and non-Promises
                 return hookResult;
             }
@@ -22984,29 +23015,61 @@ class PluginDriver {
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
      * @param args Arguments passed to the plugin hook.
      * @param plugin The acutal plugin
-     * @param hookContext When passed, the plugin context can be overridden.
+     * @param replaceContext When passed, the plugin context can be overridden.
      */
-    runHookSync(hookName, args, plugin, hookContext) {
+    runHookSync(hookName, args, plugin, replaceContext) {
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         try {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                return error(errInvalidPluginHook(hookName, plugin.name));
-            }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            return hook.apply(context, args);
+            return handler.apply(context, args);
         }
         catch (err) {
             return error(errPluginError(err, plugin.name, { hook: hookName }));
         }
     }
 }
+function getSortedValidatedPlugins(hookName, plugins, validateHandler = validateFunctionPluginHandler) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                validateHandler(hook.handler, hookName, plugin);
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            else {
+                validateHandler(hook, hookName, plugin);
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}
+function validateFunctionPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'function') {
+        error(errInvalidFunctionPluginHook(hookName, plugin.name));
+    }
+}
+function validateAddonPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'string' && typeof handler !== 'function') {
+        return error(errInvalidAddonPluginHook(hookName, plugin.name));
+    }
+}
+function noReturn() { }
 
 class Queue {
     constructor(maxParallel) {
@@ -23263,7 +23326,7 @@ function formatAction([pluginName, hookName, args]) {
 // We do not directly listen on process to avoid max listeners warnings for
 // complicated build processes
 const beforeExitEvent = 'beforeExit';
-const beforeExitEmitter = new require$$0$2.EventEmitter();
+const beforeExitEmitter = new node_events.EventEmitter();
 beforeExitEmitter.setMaxListeners(0);
 process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
 async function catchUnfinishedHookActions(pluginDriver, callback) {
@@ -23405,7 +23468,7 @@ const getModuleContext = (config, context) => {
     if (configModuleContext) {
         const contextByModuleId = Object.create(null);
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
-            contextByModuleId[require$$0.resolve(key)] = moduleContext;
+            contextByModuleId[node_path.resolve(key)] = moduleContext;
         }
         return id => contextByModuleId[id] || context;
     }
@@ -23611,7 +23674,7 @@ const getPreserveModulesRoot = (config) => {
     if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
         return undefined;
     }
-    return require$$0.resolve(preserveModulesRoot);
+    return node_path.resolve(preserveModulesRoot);
 };
 const getAmd = (config) => {
     const mergedOption = {
@@ -23829,17 +23892,15 @@ async function getInputOptions(rawInputOptions, watchMode) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    const rawPlugins = ensureArray$1(rawInputOptions.plugins);
+    const rawPlugins = getSortedValidatedPlugins('options', ensureArray$1(rawInputOptions.plugins));
     const { options, unsetOptions } = normalizeInputOptions(await rawPlugins.reduce(applyOptionHook(watchMode), Promise.resolve(rawInputOptions)));
     normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
     return { options, unsetOptions };
 }
 function applyOptionHook(watchMode) {
     return async (inputOptions, plugin) => {
-        if (plugin.options) {
-            return ((await plugin.options.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
-        }
-        return inputOptions;
+        const handler = 'handler' in plugin.options ? plugin.options.handler : plugin.options;
+        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
     };
 }
 function normalizePlugins(plugins, anonymousPrefix) {
@@ -23915,35 +23976,10 @@ function getSortingFileType(file) {
     return SortingFileType.SECONDARY_CHUNK;
 }
 async function writeOutputFile(outputFile, outputOptions) {
-    const fileName = require$$0.resolve(outputOptions.dir || require$$0.dirname(outputOptions.file), outputFile.fileName);
+    const fileName = node_path.resolve(outputOptions.dir || node_path.dirname(outputOptions.file), outputFile.fileName);
     // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
-    await require$$0$1.promises.mkdir(require$$0.dirname(fileName), { recursive: true });
-    let writeSourceMapPromise;
-    let source;
-    if (outputFile.type === 'asset') {
-        source = outputFile.source;
-    }
-    else {
-        source = outputFile.code;
-        if (outputOptions.sourcemap && outputFile.map) {
-            let url;
-            if (outputOptions.sourcemap === 'inline') {
-                url = outputFile.map.toUrl();
-            }
-            else {
-                const { sourcemapBaseUrl } = outputOptions;
-                const sourcemapFileName = `${require$$0.basename(outputFile.fileName)}.map`;
-                url = sourcemapBaseUrl
-                    ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
-                    : sourcemapFileName;
-                writeSourceMapPromise = require$$0$1.promises.writeFile(`${fileName}.map`, outputFile.map.toString());
-            }
-            if (outputOptions.sourcemap !== 'hidden') {
-                source += `//# ${exports.SOURCEMAPPING_URL}=${url}\n`;
-            }
-        }
-    }
-    return Promise.all([require$$0$1.promises.writeFile(fileName, source), writeSourceMapPromise]);
+    await node_fs.promises.mkdir(node_path.dirname(fileName), { recursive: true });
+    return node_fs.promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
 }
 /**
  * Auxiliary function for defining rollup configuration
@@ -23954,7 +23990,7 @@ function defineConfig(options) {
     return options;
 }
 
-class WatchEmitter extends require$$0$2.EventEmitter {
+class WatchEmitter extends node_events.EventEmitter {
     constructor() {
         super();
         this.awaitedHandlers = Object.create(null);