rollup 1.15.5 → 1.16.2

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v1.15.5
-	Fri, 14 Jun 2019 15:05:54 GMT - commit 3a5c17ab3dfc45971bed30697e0e58036b5dd55d
+	Rollup.js v1.16.2
+	Sat, 22 Jun 2019 08:26:33 GMT - commit 3ed6c52c86a1545385f172e86bdb373e59a15a3c
 
 
 	https://github.com/rollup/rollup
@@ -23,7 +23,7 @@ var acorn__default = _interopDefault(acorn);
 var events = require('events');
 var module$1 = _interopDefault(require('module'));
 
-var version = "1.15.5";
+var version = "1.16.2";
 
 var minimalisticAssert = assert;
 function assert(val, msg) {
@@ -2647,10 +2647,12 @@ class ExternalModule {
         this.exportedVariables = new Map();
     }
     getVariableForExportName(name, _isExportAllSearch) {
-        if (name !== 'default' && name !== '*')
-            this.exportsNames = true;
-        if (name === '*')
+        if (name === '*') {
             this.exportsNamespace = true;
+        }
+        else if (name !== 'default') {
+            this.exportsNames = true;
+        }
         let declaration = this.declarations[name];
         if (declaration)
             return declaration;
@@ -8705,6 +8707,7 @@ ExportDefaultVariable.prototype.getBaseVariableName = ExportDefaultVariable.prot
 
 const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
 const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
+const INTEROP_NAMESPACE_VARIABLE = '_interopNamespace';
 
 class ExportShimVariable extends Variable {
     constructor(module) {
@@ -8982,11 +8985,11 @@ function getExportBlock(exports, dependencies, namedExportsMode, interop, compac
                     if (!compact && exportBlock)
                         exportBlock += '\n';
                     exportBlock +=
-                        `Object.keys(${name}).forEach(function${_}(key)${_}{${n}` +
-                            `${t}Object.defineProperty(exports,${_}key,${_}{${n}` +
+                        `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
+                            `${t}if${_}(k${_}!==${_}'default')${_}Object.defineProperty(exports,${_}k,${_}{${n}` +
                             `${t}${t}enumerable:${_}true,${n}` +
                             `${t}${t}get:${_}function${_}()${_}{${n}` +
-                            `${t}${t}${t}return ${name}[key];${n}` +
+                            `${t}${t}${t}return ${name}[k];${n}` +
                             `${t}${t}}${n}${t}});${n}});`;
                 }
             });
@@ -9062,6 +9065,27 @@ function getInteropBlock(dependencies, options, varOrConst) {
         .join(options.compact ? '' : '\n');
 }
 
+function getInteropNamespace(_, n, t) {
+    return `function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
+        `${t}if${_}(e${_}&&${_}e.__esModule)${_}{${_}return e;${_}}${_}else${_}{${n}` +
+        `${t}${t}var n${_}=${_}{};${n}` +
+        `${t}${t}if${_}(e)${_}{${n}` +
+        `${t}${t}${t}Object.keys(e).forEach(function${_}(k)${_}{${n}` +
+        `${t}${t}${t}${t}var d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${t}${t}${t}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${t}${t}${t}${t}${t}enumerable:${_}true,${n}` +
+        `${t}${t}${t}${t}${t}get:${_}function${_}()${_}{${n}` +
+        `${t}${t}${t}${t}${t}${t}return e[k];${n}` +
+        `${t}${t}${t}${t}${t}}${n}` +
+        `${t}${t}${t}${t}});${n}` +
+        `${t}${t}${t}});${n}` +
+        `${t}${t}}${n}` +
+        `${t}${t}n['default']${_}=${_}e;${n}` +
+        `${t}${t}return n;${n}` +
+        `${t}}${n}` +
+        `}${n}${n}`;
+}
+
 const builtins$1 = {
     assert: true,
     buffer: true,
@@ -9138,8 +9162,12 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
     const wrapperStart = `${define}(${params}function${_}(${args.join(`,${_}`)})${_}{${useStrict}${n}${n}`;
     // var foo__default = 'default' in foo ? foo['default'] : foo;
     const interopBlock = getInteropBlock(dependencies, options, varOrConst);
-    if (interopBlock)
+    if (interopBlock) {
         magicString.prepend(interopBlock + n + n);
+    }
+    if (accessedGlobals.has(INTEROP_NAMESPACE_VARIABLE)) {
+        magicString.prepend(getInteropNamespace(_, n, t));
+    }
     if (intro)
         magicString.prepend(intro);
     const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, options.interop, options.compact, t);
@@ -9155,7 +9183,7 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         .prepend(wrapperStart);
 }
 
-function cjs(magicString, { dependencies, exports, hasExports, indentString: t, intro, isEntryModuleFacade, namedExportsMode, outro, varOrConst }, options) {
+function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports, indentString: t, intro, isEntryModuleFacade, namedExportsMode, outro, varOrConst }, options) {
     const n = options.compact ? '' : '\n';
     const _ = options.compact ? '' : ' ';
     intro =
@@ -9201,6 +9229,9 @@ function cjs(magicString, { dependencies, exports, hasExports, indentString: t,
                 `(${ex}${_}&&${_}(typeof ${ex}${_}===${_}'object')${_}&&${_}'default'${_}in ${ex})${_}` +
                 `?${_}${ex}['default']${_}:${_}${ex}${options.compact ? '' : '; '}}${n}${n}`;
     }
+    if (accessedGlobals.has(INTEROP_NAMESPACE_VARIABLE)) {
+        intro += getInteropNamespace(_, n, t);
+    }
     if (importBlock)
         intro += importBlock + n + n;
     const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, options.interop, options.compact, t, `module.exports${_}=${_}`);
@@ -9391,6 +9422,7 @@ var Errors;
     Errors["BAD_LOADER"] = "BAD_LOADER";
     Errors["CHUNK_NOT_FOUND"] = "CHUNK_NOT_FOUND";
     Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
+    Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
     Errors["INVALID_ASSET_NAME"] = "INVALID_ASSET_NAME";
     Errors["INVALID_CHUNK"] = "INVALID_CHUNK";
     Errors["INVALID_EXTERNAL_ID"] = "INVALID_EXTERNAL_ID";
@@ -9455,6 +9487,9 @@ function errChunkReferenceIdNotFoundForFilename(chunkReferenceId) {
         message: `Plugin error - Unable to get file name for unknown chunk "${chunkReferenceId}".`
     };
 }
+function errDeprecation(deprecation) {
+    return Object.assign({ code: Errors.DEPRECATED_FEATURE }, (typeof deprecation === 'string' ? { message: deprecation } : deprecation));
+}
 function errInvalidAssetName(name) {
     return {
         code: Errors.INVALID_ASSET_NAME,
@@ -10639,8 +10674,15 @@ class ConditionalExpression extends NodeBase {
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
         if (!this.test.included) {
-            code.remove(this.start, this.usedBranch.start);
-            code.remove(this.usedBranch.end, this.end);
+            const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
+            if (this.consequent.included) {
+                const questionmarkPos = findFirstOccurrenceOutsideComment(code.original, '?', this.test.end);
+                code.remove(this.start, questionmarkPos + 1);
+                code.remove(colonPos, this.end);
+            }
+            else {
+                code.remove(this.start, colonPos + 1);
+            }
             removeAnnotations(this, code);
             this.usedBranch.render(code, options, {
                 isCalleeOfRenderedParent: renderedParentType
@@ -10892,75 +10934,31 @@ class IfStatement extends NodeBase {
     }
 }
 
-const getDynamicImportMechanism = (options) => {
-    switch (options.format) {
-        case 'cjs': {
-            const _ = options.compact ? '' : ' ';
-            return {
-                interopLeft: `Promise.resolve({${_}default:${_}require(`,
-                interopRight: `)${_}})`,
-                left: 'Promise.resolve(require(',
-                right: '))'
-            };
-        }
-        case 'amd': {
-            const _ = options.compact ? '' : ' ';
-            const resolve = options.compact ? 'c' : 'resolve';
-            const reject = options.compact ? 'e' : 'reject';
-            return {
-                interopLeft: `new Promise(function${_}(${resolve},${_}${reject})${_}{${_}require([`,
-                interopRight: `],${_}function${_}(m)${_}{${_}${resolve}({${_}default:${_}m${_}})${_}},${_}${reject})${_}})`,
-                left: `new Promise(function${_}(${resolve},${_}${reject})${_}{${_}require([`,
-                right: `],${_}${resolve},${_}${reject})${_}})`
-            };
-        }
-        case 'system':
-            return {
-                left: 'module.import(',
-                right: ')'
-            };
-        case 'es':
-            return {
-                left: `${options.dynamicImportFunction || 'import'}(`,
-                right: ')'
-            };
-    }
-    return undefined;
-};
-const accessedImportGlobals = {
-    amd: ['require'],
-    cjs: ['require'],
-    system: ['module']
-};
 class Import extends NodeBase {
     constructor() {
         super(...arguments);
-        this.resolutionInterop = false;
+        this.exportMode = 'auto';
     }
     include() {
         if (!this.included) {
             this.included = true;
             this.context.includeDynamicImport(this);
-            this.scope.addAccessedGlobalsByFormat(accessedImportGlobals);
         }
     }
     initialise() {
         this.context.addDynamicImport(this);
     }
     render(code, options) {
-        if (this.resolutionNamespace) {
+        if (this.inlineNamespace) {
             const _ = options.compact ? '' : ' ';
             const s = options.compact ? '' : ';';
-            code.overwrite(this.parent.start, this.parent.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.resolutionNamespace}${s}${_}})`);
+            code.overwrite(this.parent.start, this.parent.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.inlineNamespace.getName()}${s}${_}})`);
             return;
         }
-        const importMechanism = getDynamicImportMechanism(options);
+        const importMechanism = this.getDynamicImportMechanism(options);
         if (importMechanism) {
-            const leftMechanism = (this.resolutionInterop && importMechanism.interopLeft) || importMechanism.left;
-            const leftMechanismEnd = findFirstOccurrenceOutsideComment(code.original, '(', this.parent.callee.end) + 1;
-            code.overwrite(this.parent.start, leftMechanismEnd, leftMechanism);
-            const rightMechanism = (this.resolutionInterop && importMechanism.interopRight) || importMechanism.right;
-            code.overwrite(this.parent.end - 1, this.parent.end, rightMechanism);
+            code.overwrite(this.parent.start, findFirstOccurrenceOutsideComment(code.original, '(', this.parent.callee.end) + 1, importMechanism.left);
+            code.overwrite(this.parent.end - 1, this.parent.end, importMechanism.right);
         }
     }
     renderFinalResolution(code, resolution, format) {
@@ -10971,9 +10969,76 @@ class Import extends NodeBase {
             code.overwrite(this.parent.arguments[0].start, this.parent.arguments[0].end, resolution);
         }
     }
-    setResolution(interop, namespace) {
-        this.resolutionInterop = interop;
-        this.resolutionNamespace = namespace;
+    setResolution(exportMode, inlineNamespace) {
+        this.exportMode = exportMode;
+        if (inlineNamespace) {
+            this.inlineNamespace = inlineNamespace;
+        }
+        else {
+            this.scope.addAccessedGlobalsByFormat({
+                amd: ['require'],
+                cjs: ['require'],
+                system: ['module']
+            });
+            if (exportMode === 'auto') {
+                this.scope.addAccessedGlobalsByFormat({
+                    amd: [INTEROP_NAMESPACE_VARIABLE],
+                    cjs: [INTEROP_NAMESPACE_VARIABLE]
+                });
+            }
+        }
+    }
+    getDynamicImportMechanism(options) {
+        switch (options.format) {
+            case 'cjs': {
+                const _ = options.compact ? '' : ' ';
+                const resolve = options.compact ? 'c' : 'resolve';
+                switch (this.exportMode) {
+                    case 'default':
+                        return {
+                            left: `new Promise(function${_}(${resolve})${_}{${_}${resolve}({${_}'default':${_}require(`,
+                            right: `)${_}});${_}})`
+                        };
+                    case 'auto':
+                        return {
+                            left: `new Promise(function${_}(${resolve})${_}{${_}${resolve}(${INTEROP_NAMESPACE_VARIABLE}(require(`,
+                            right: `)));${_}})`
+                        };
+                    default:
+                        return {
+                            left: `new Promise(function${_}(${resolve})${_}{${_}${resolve}(require(`,
+                            right: `));${_}})`
+                        };
+                }
+            }
+            case 'amd': {
+                const _ = options.compact ? '' : ' ';
+                const resolve = options.compact ? 'c' : 'resolve';
+                const reject = options.compact ? 'e' : 'reject';
+                const resolveNamespace = this.exportMode === 'default'
+                    ? `function${_}(m)${_}{${_}${resolve}({${_}'default':${_}m${_}});${_}}`
+                    : this.exportMode === 'auto'
+                        ? `function${_}(m)${_}{${_}${resolve}(${INTEROP_NAMESPACE_VARIABLE}(m));${_}}`
+                        : resolve;
+                return {
+                    left: `new Promise(function${_}(${resolve},${_}${reject})${_}{${_}require([`,
+                    right: `],${_}${resolveNamespace},${_}${reject})${_}})`
+                };
+            }
+            case 'system':
+                return {
+                    left: 'module.import(',
+                    right: ')'
+                };
+            case 'es':
+                if (options.dynamicImportFunction) {
+                    return {
+                        left: `${options.dynamicImportFunction}(`,
+                        right: ')'
+                    };
+                }
+        }
+        return null;
     }
 }
 
@@ -11141,8 +11206,13 @@ class LogicalExpression extends NodeBase {
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
         if (!this.left.included || !this.right.included) {
-            code.remove(this.start, this.usedBranch.start);
-            code.remove(this.usedBranch.end, this.end);
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
+            if (this.right.included) {
+                code.remove(this.start, operatorPos + 2);
+            }
+            else {
+                code.remove(operatorPos, this.end);
+            }
             removeAnnotations(this, code);
             this.usedBranch.render(code, options, {
                 isCalleeOfRenderedParent: renderedParentType
@@ -11574,7 +11644,6 @@ class MetaProperty extends NodeBase {
             const relativePath = normalize(path.relative(path.dirname(chunkId), fileName));
             let replacement;
             if (assetReferenceId !== null) {
-                // deprecated hook for assets
                 replacement = pluginDriver.hookFirstSync('resolveAssetUrl', [
                     {
                         assetFileName: fileName,
@@ -12146,16 +12215,13 @@ class SequenceExpression extends NodeBase {
         this.expressions[this.expressions.length - 1].include(includeChildrenRecursively);
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
-        let firstStart = 0, lastEnd, includedNodes = 0;
+        let includedNodes = 0;
         for (const { node, start, end } of getCommaSeparatedNodesWithBoundaries(this.expressions, code, this.start, this.end)) {
             if (!node.included) {
                 treeshakeNode(node, code, start, end);
                 continue;
             }
             includedNodes++;
-            if (firstStart === 0)
-                firstStart = start;
-            lastEnd = end;
             if (node === this.expressions[this.expressions.length - 1] && includedNodes === 1) {
                 node.render(code, options, {
                     isCalleeOfRenderedParent: renderedParentType
@@ -12168,11 +12234,6 @@ class SequenceExpression extends NodeBase {
                 node.render(code, options);
             }
         }
-        // Round brackets are part of the actual parent and should be re-added in case the parent changed
-        if (includedNodes > 1 && renderedParentType) {
-            code.prependRight(firstStart, '(');
-            code.appendLeft(lastEnd, ')');
-        }
     }
 }
 
@@ -13402,8 +13463,7 @@ class Module {
             return this.traceVariable(name) || this.graph.scope.findVariable(name);
         }
         if (name !== 'default') {
-            for (let i = 0; i < this.exportAllModules.length; i += 1) {
-                const module = this.exportAllModules[i];
+            for (const module of this.exportAllModules) {
                 const declaration = module.getVariableForExportName(name, true);
                 if (declaration)
                     return declaration;
@@ -13467,9 +13527,15 @@ class Module {
         }
         this.addModulesToSpecifiers(this.importDescriptions);
         this.addModulesToSpecifiers(this.reexports);
-        this.exportAllModules = this.exportAllSources.map(source => {
+        this.exportAllModules = this.exportAllSources
+            .map(source => {
             const id = this.resolvedIds[source].id;
             return this.graph.moduleById.get(id);
+        })
+            .sort((moduleA, moduleB) => {
+            const aExternal = moduleA instanceof ExternalModule;
+            const bExternal = moduleB instanceof ExternalModule;
+            return aExternal === bExternal ? 0 : aExternal ? 1 : -1;
         });
     }
     render(options) {
@@ -13595,7 +13661,7 @@ class Module {
         this.graph.warn(warning);
     }
     addDynamicImport(node) {
-        this.dynamicImports.push({ node, resolution: undefined });
+        this.dynamicImports.push({ node, resolution: null });
     }
     addExport(node) {
         const source = node.source && node.source.value;
@@ -14518,8 +14584,8 @@ class Chunk$1 {
             }
         }
         sortByExecutionOrder(this.dependencies);
-        this.setIdentifierRenderResolutions(options);
         this.prepareDynamicImports();
+        this.setIdentifierRenderResolutions(options);
         let hoistedSource = '';
         const renderedModules = (this.renderedModules = Object.create(null));
         for (const module of this.orderedModules) {
@@ -14940,22 +15006,19 @@ class Chunk$1 {
     prepareDynamicImports() {
         for (const module of this.orderedModules) {
             for (const { node, resolution } of module.dynamicImports) {
-                if (!resolution)
+                if (!node.included)
                     continue;
                 if (resolution instanceof Module) {
                     if (resolution.chunk === this) {
                         const namespace = resolution.getOrCreateNamespace();
-                        node.setResolution(false, namespace.getName());
+                        node.setResolution('named', namespace);
                     }
                     else {
-                        node.setResolution(false);
+                        node.setResolution(resolution.chunk.exportMode);
                     }
                 }
-                else if (resolution instanceof ExternalModule) {
-                    node.setResolution(false);
-                }
                 else {
-                    node.setResolution(false);
+                    node.setResolution('auto');
                 }
             }
         }
@@ -15480,15 +15543,30 @@ var BuildPhase;
     BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
 })(BuildPhase || (BuildPhase = {}));
 
-const deprecatedHookNames = {
-    ongenerate: 'generateBundle',
-    onwrite: 'generateBundle',
-    transformBundle: 'renderChunk',
-    transformChunk: 'renderChunk'
-};
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const deprecatedHooks = [
+    { active: true, deprecated: 'ongenerate', replacement: 'generateBundle' },
+    { active: true, deprecated: 'onwrite', replacement: 'generateBundle/writeBundle' },
+    { active: true, deprecated: 'transformBundle', replacement: 'renderChunk' },
+    { active: true, deprecated: 'transformChunk', replacement: 'renderChunk' },
+    { active: false, deprecated: 'resolveAssetUrl', replacement: 'resolveFileUrl' }
+];
+function warnDeprecatedHooks(plugins, graph) {
+    for (const { active, deprecated, replacement } of deprecatedHooks) {
+        for (const plugin of plugins) {
+            if (deprecated in plugin) {
+                graph.warnDeprecation({
+                    message: `The "${deprecated}" hook used by plugin ${plugin.name} is deprecated. The "${replacement}" hook should be used instead.`,
+                    plugin: plugin.name
+                }, active);
+            }
+        }
+    }
+}
 function createPluginDriver(graph, options, pluginCache, watcher) {
+    warnDeprecatedHooks(options.plugins, graph);
     const plugins = [
-        ...(options.plugins || []),
+        ...options.plugins,
         getRollupDefaultPlugin(options.preserveSymlinks)
     ];
     const { emitAsset, getAssetFileName, setAssetSource } = createAssetPluginHooks(graph.assetsById);
@@ -15497,7 +15575,7 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
     const pluginContexts = plugins.map((plugin, pidx) => {
         let cacheable = true;
         if (typeof plugin.cacheKey !== 'string') {
-            if (typeof plugin.name !== 'string' || existingPluginKeys.has(plugin.name)) {
+            if (plugin.name.startsWith(ANONYMOUS_PLUGIN_PREFIX) || existingPluginKeys.has(plugin.name)) {
                 cacheable = false;
             }
             else {
@@ -15518,17 +15596,6 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
         else {
             cacheInstance = uncacheablePlugin(plugin.name);
         }
-        let watcherDeprecationWarningShown = false;
-        function deprecatedWatchListener(event, handler) {
-            if (!watcherDeprecationWarningShown) {
-                context.warn({
-                    code: 'PLUGIN_WATCHER_DEPRECATED',
-                    message: `this.watcher usage is deprecated in plugins. Use the watchChange plugin hook and this.addWatchFile() instead.`
-                });
-                watcherDeprecationWarningShown = true;
-            }
-            return watcher.on(event, handler);
-        }
         const context = {
             addWatchFile(id) {
                 if (graph.phase >= BuildPhase.GENERATE)
@@ -15548,12 +15615,9 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 if (err.code)
                     err.pluginCode = err.code;
                 err.code = 'PLUGIN_ERROR';
-                err.plugin = plugin.name || `Plugin at position ${pidx + 1}`;
+                err.plugin = plugin.name;
                 return error(err);
             },
-            isExternal(id, parentId, isResolved = false) {
-                return graph.moduleLoader.isExternal(id, parentId, isResolved);
-            },
             getAssetFileName: getAssetFileName,
             getChunkFileName(chunkReferenceId) {
                 return graph.moduleLoader.getChunkFileName(chunkReferenceId);
@@ -15573,6 +15637,19 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     isExternal: foundModule instanceof ExternalModule
                 };
             },
+            isExternal: (() => {
+                let deprecationWarningShown = false;
+                return (id, parentId, isResolved = false) => {
+                    if (!deprecationWarningShown) {
+                        deprecationWarningShown = true;
+                        graph.warnDeprecation({
+                            message: `The "this.isExternal" plugin context function used by plugin ${plugin.name} is deprecated. The "this.resolve" plugin context function should be used instead.`,
+                            plugin: plugin.name
+                        }, false);
+                    }
+                    return graph.moduleLoader.isExternal(id, parentId, isResolved);
+                };
+            })(),
             meta: {
                 rollupVersion: version
             },
@@ -15580,14 +15657,24 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 return graph.moduleById.keys();
             },
             parse: graph.contextParse,
-            resolveId(source, importer) {
-                return graph.moduleLoader
-                    .resolveId(source, importer)
-                    .then(resolveId => resolveId && resolveId.id);
-            },
             resolve(source, importer, options) {
                 return graph.moduleLoader.resolveId(source, importer, options && options.skipSelf ? pidx : null);
             },
+            resolveId: (() => {
+                let deprecationWarningShown = false;
+                return (source, importer) => {
+                    if (!deprecationWarningShown) {
+                        deprecationWarningShown = true;
+                        graph.warnDeprecation({
+                            message: `The "this.resolveId" plugin context function used by plugin ${plugin.name} is deprecated. The "this.resolve" plugin context function should be used instead.`,
+                            plugin: plugin.name
+                        }, false);
+                    }
+                    return graph.moduleLoader
+                        .resolveId(source, importer)
+                        .then(resolveId => resolveId && resolveId.id);
+                };
+            })(),
             setAssetSource,
             warn(warning) {
                 if (typeof warning === 'string')
@@ -15595,11 +15682,24 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 if (warning.code)
                     warning.pluginCode = warning.code;
                 warning.code = 'PLUGIN_WARNING';
-                warning.plugin = plugin.name || `Plugin at position ${pidx + 1}`;
+                warning.plugin = plugin.name;
                 graph.warn(warning);
             },
             watcher: watcher
-                ? Object.assign({}, watcher, { addListener: deprecatedWatchListener, on: deprecatedWatchListener })
+                ? (() => {
+                    let deprecationWarningShown = false;
+                    function deprecatedWatchListener(event, handler) {
+                        if (!deprecationWarningShown) {
+                            context.warn({
+                                code: 'PLUGIN_WATCHER_DEPRECATED',
+                                message: `this.watcher usage is deprecated in plugins. Use the watchChange plugin hook and this.addWatchFile() instead.`
+                            });
+                            deprecationWarningShown = true;
+                        }
+                        return watcher.on(event, handler);
+                    }
+                    return Object.assign({}, watcher, { addListener: deprecatedWatchListener, on: deprecatedWatchListener });
+                })()
                 : undefined
         };
         return context;
@@ -15610,9 +15710,6 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
         const hook = plugin[hookName];
         if (!hook)
             return undefined;
-        const deprecatedHookNewName = deprecatedHookNames[hookName];
-        if (deprecatedHookNewName)
-            context.warn(hookDeprecationWarning(hookName, deprecatedHookNewName, plugin, pluginIndex));
         if (hookContext) {
             context = hookContext(context, plugin);
             if (!context || context === pluginContexts[pluginIndex])
@@ -15625,8 +15722,7 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     return hook;
                 error({
                     code: 'INVALID_PLUGIN_HOOK',
-                    message: `Error running plugin hook ${hookName} for ${plugin.name ||
-                        `Plugin at position ${pluginIndex + 1}`}, expected a function hook.`
+                    message: `Error running plugin hook ${hookName} for ${plugin.name}, expected a function hook.`
                 });
             }
             return hook.apply(context, args);
@@ -15639,7 +15735,7 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     err.pluginCode = err.code;
                 err.code = 'PLUGIN_ERROR';
             }
-            err.plugin = plugin.name || `Plugin at position ${pluginIndex + 1}`;
+            err.plugin = plugin.name;
             err.hook = hookName;
             error(err);
         }
@@ -15651,9 +15747,6 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
         const hook = plugin[hookName];
         if (!hook)
             return undefined;
-        const deprecatedHookNewName = deprecatedHookNames[hookName];
-        if (deprecatedHookNewName)
-            context.warn(hookDeprecationWarning(hookName, deprecatedHookNewName, plugin, pluginIndex));
         if (hookContext) {
             context = hookContext(context, plugin);
             if (!context || context === pluginContexts[pluginIndex])
@@ -15667,8 +15760,7 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     return hook;
                 error({
                     code: 'INVALID_PLUGIN_HOOK',
-                    message: `Error running plugin hook ${hookName} for ${plugin.name ||
-                        `Plugin at position ${pluginIndex + 1}`}, expected a function hook.`
+                    message: `Error running plugin hook ${hookName} for ${plugin.name}, expected a function hook.`
                 });
             }
             return hook.apply(context, args);
@@ -15681,7 +15773,7 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     err.pluginCode = err.code;
                 err.code = 'PLUGIN_ERROR';
             }
-            err.plugin = plugin.name || `Plugin at position ${pluginIndex + 1}`;
+            err.plugin = plugin.name;
             err.hook = hookName;
             error(err);
         });
@@ -15838,7 +15930,7 @@ const noCache = {
     }
 };
 function uncacheablePluginError(pluginName) {
-    if (!pluginName)
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX))
         error({
             code: 'ANONYMOUS_PLUGIN_CACHE',
             message: 'A plugin is trying to use the Rollup cache but is not declaring a plugin name or cacheKey.'
@@ -15866,13 +15958,6 @@ const uncacheablePlugin = pluginName => ({
         return false;
     }
 });
-function hookDeprecationWarning(name, newName, plugin, pluginIndex) {
-    return {
-        code: name.toUpperCase() + '_HOOK_DEPRECATED',
-        message: `The ${name} hook used by plugin ${plugin.name ||
-            `at position ${pluginIndex + 1}`} is deprecated. The ${newName} hook should be used instead.`
-    };
-}
 
 function transform(graph, source, module) {
     const id = module.id;
@@ -15905,7 +15990,7 @@ function transform(graph, source, module) {
             }
         }
         else {
-            // assets emitted by transform are transformDependencies
+            // assets/chunks emitted by a transform hook need to be emitted again if the hook is skipped
             if (emittedAssets.length)
                 module.transformAssets = emittedAssets;
             if (emittedChunks.length)
@@ -15913,10 +15998,7 @@ function transform(graph, source, module) {
             if (result && typeof result === 'object' && Array.isArray(result.dependencies)) {
                 // not great, but a useful way to track this without assuming WeakMap
                 if (!curPlugin.warnedTransformDependencies)
-                    this.warn({
-                        code: 'TRANSFORM_DEPENDENCIES_DEPRECATED',
-                        message: `Returning "dependencies" from plugin transform hook is deprecated for using this.addWatchFile() instead.`
-                    });
+                    graph.warnDeprecation(`Returning "dependencies" from the "transform" hook as done by plugin ${plugin.name} is deprecated. The "this.addWatchFile" plugin context function should be used instead.`, true);
                 curPlugin.warnedTransformDependencies = true;
                 if (!transformDependencies)
                     transformDependencies = [];
@@ -16511,6 +16593,7 @@ class Graph {
         this.watchFiles = Object.create(null);
         this.externalModules = [];
         this.modules = [];
+        this.onwarn = options.onwarn || makeOnwarn();
         this.curChunkIndex = 0;
         this.deoptimizationTracker = new EntityPathTracker();
         this.cachedModules = new Map();
@@ -16529,6 +16612,7 @@ class Graph {
             }
         }
         this.preserveModules = options.preserveModules;
+        this.strictDeprecations = options.strictDeprecations;
         this.cacheExpiry = options.experimentalCacheExpiry;
         if (options.treeshake !== false) {
             this.treeshakingOptions = options.treeshake
@@ -16543,9 +16627,11 @@ class Graph {
                     annotations: true,
                     moduleSideEffects: true,
                     propertyReadSideEffects: true,
-                    pureExternalModules: false,
                     tryCatchDeoptimization: true
                 };
+            if (typeof this.treeshakingOptions.pureExternalModules !== 'undefined') {
+                this.warnDeprecation(`The "treeshake.pureExternalModules" option is deprecated. The "treeshake.moduleSideEffects" option should be used instead. "treeshake.pureExternalModules: true" is equivalent to "treeshake.moduleSideEffects: 'no-external'"`, false);
+            }
         }
         this.contextParse = (code, options = {}) => this.acornParser.parse(code, Object.assign({}, defaultAcornOptions, options, this.acornOptions));
         this.pluginDriver = createPluginDriver(this, options, this.pluginCache, watcher);
@@ -16573,7 +16659,6 @@ class Graph {
         else {
             this.getModuleContext = () => this.context;
         }
-        this.onwarn = options.onwarn || makeOnwarn();
         this.acornOptions = options.acorn || {};
         const acornPluginsToInject = [];
         acornPluginsToInject.push(dynamicImport);
@@ -16752,6 +16837,15 @@ class Graph {
         };
         this.onwarn(warning);
     }
+    warnDeprecation(deprecation, activeDeprecation) {
+        if (activeDeprecation || this.strictDeprecations) {
+            const warning = errDeprecation(deprecation);
+            if (this.strictDeprecations) {
+                return error(warning);
+            }
+            this.warn(warning);
+        }
+    }
     link(entryModules) {
         for (const module of this.modules) {
             module.linkDependencies();
@@ -16822,7 +16916,7 @@ function createAddons(graph, options) {
         .catch((err) => {
         error({
             code: 'ADDON_ERROR',
-            message: `Could not retrieve ${err.hook}. Check configuration of ${err.plugin}.
+            message: `Could not retrieve ${err.hook}. Check configuration of plugin ${err.plugin}.
 \tError Message: ${err.message}`
         });
     });
@@ -17053,6 +17147,7 @@ function getInputOptions(config, command = { external: [], globals: undefined },
         preserveModules: getOption('preserveModules'),
         preserveSymlinks: getOption('preserveSymlinks'),
         shimMissingExports: getOption('shimMissingExports'),
+        strictDeprecations: getOption('strictDeprecations', false),
         treeshake: getObjectOption(config, command, 'treeshake'),
         watch: config.watch
     };
@@ -17109,10 +17204,10 @@ function getOutputOptions(config, command = {}) {
 
 function checkOutputOptions(options) {
     if (options.format === 'es6') {
-        error({
+        error(errDeprecation({
             message: 'The "es6" output format is deprecated – use "esm" instead',
             url: `https://rollupjs.org/guide/en#output-format`
-        });
+        }));
     }
     if (['amd', 'cjs', 'system', 'es', 'iife', 'umd'].indexOf(options.format) < 0) {
         error({
@@ -17142,6 +17237,15 @@ function applyOptionHook(inputOptions, plugin) {
         return plugin.options.call({ meta: { rollupVersion: version } }, inputOptions) || inputOptions;
     return inputOptions;
 }
+function ensureArray(items) {
+    if (Array.isArray(items)) {
+        return items.filter(Boolean);
+    }
+    if (items) {
+        return [items];
+    }
+    return [];
+}
 function getInputOptions$1(rawInputOptions) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
@@ -17151,13 +17255,14 @@ function getInputOptions$1(rawInputOptions) {
     });
     if (optionError)
         inputOptions.onwarn({ message: optionError, code: 'UNKNOWN_OPTION' });
-    const plugins = inputOptions.plugins;
-    inputOptions.plugins = Array.isArray(plugins)
-        ? plugins.filter(Boolean)
-        : plugins
-            ? [plugins]
-            : [];
-    inputOptions = inputOptions.plugins.reduce(applyOptionHook, inputOptions);
+    inputOptions = ensureArray(inputOptions.plugins).reduce(applyOptionHook, inputOptions);
+    inputOptions.plugins = ensureArray(inputOptions.plugins);
+    for (let pluginIndex = 0; pluginIndex < inputOptions.plugins.length; pluginIndex++) {
+        const plugin = inputOptions.plugins[pluginIndex];
+        if (!plugin.name) {
+            plugin.name = `${ANONYMOUS_PLUGIN_PREFIX}${pluginIndex + 1}`;
+        }
+    }
     if (inputOptions.inlineDynamicImports) {
         if (inputOptions.preserveModules)
             error({
@@ -18987,8 +19092,6 @@ const expandRange = (args, options) => {
     args.sort();
     let value = `[${args.join('-')}]`;
     try {
-        /* eslint-disable no-new */
-        new RegExp(value);
     }
     catch (ex) {
         return args.map(v => utils$2.escapeRegex(v)).join('..');
@@ -20454,7 +20557,7 @@ micromatch.braceExpand = (pattern, options) => {
  */
 var micromatch_1 = micromatch;
 
-function ensureArray(thing) {
+function ensureArray$1(thing) {
     if (Array.isArray(thing))
         return thing;
     if (thing == undefined)
@@ -20479,8 +20582,8 @@ const createFilter = function createFilter(include, exclude, options) {
                     .join('/'), { dot: true })
             };
     };
-    const includeMatchers = ensureArray(include).map(getMatcher);
-    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    const includeMatchers = ensureArray$1(include).map(getMatcher);
+    const excludeMatchers = ensureArray$1(exclude).map(getMatcher);
     return function (id) {
         if (typeof id !== 'string')
             return false;