@rollup/plugin-commonjs 14.0.0 → 17.0.0

package/dist/index.js

@@ -1,223 +1,162 @@
 'use strict';
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var fs = require('fs');
 var path = require('path');
 var pluginutils = require('@rollup/pluginutils');
-var getCommonDir = _interopDefault(require('commondir'));
-var glob = _interopDefault(require('glob'));
+var getCommonDir = require('commondir');
+var fs = require('fs');
+var glob = require('glob');
 var estreeWalker = require('estree-walker');
-var MagicString = _interopDefault(require('magic-string'));
+var MagicString = require('magic-string');
+var isReference = require('is-reference');
 var resolve = require('resolve');
-var isReference = _interopDefault(require('is-reference'));
 
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
+var getCommonDir__default = /*#__PURE__*/_interopDefaultLegacy(getCommonDir);
+var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
+var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
 
-function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
+var peerDependencies = {
+	rollup: "^2.30.0"
+};
 
+function tryParse(parse, code, id) {
   try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
+    return parse(code, { allowReturnOutsideFunction: true });
   } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
+    err.message += ` in ${id}`;
+    throw err;
   }
-
-  return _arr;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(n);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
+const firstpassGlobal = /\b(?:require|module|exports|global)\b/;
 
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+const firstpassNoGlobal = /\b(?:require|module|exports)\b/;
 
-  return arr2;
+function hasCjsKeywords(code, ignoreGlobal) {
+  const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
+  return firstpass.test(code);
 }
 
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
+/* eslint-disable no-underscore-dangle */
 
-function _createForOfIteratorHelper(o) {
-  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-    if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) {
-      var i = 0;
-
-      var F = function () {};
-
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
+function analyzeTopLevelStatements(parse, code, id) {
+  const ast = tryParse(parse, code, id);
 
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
+  let isEsModule = false;
+  let hasDefaultExport = false;
+  let hasNamedExports = false;
 
-  var it,
-      normalCompletion = true,
-      didErr = false,
-      err;
-  return {
-    s: function () {
-      it = o[Symbol.iterator]();
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
+  for (const node of ast.body) {
+    switch (node.type) {
+      case 'ExportDefaultDeclaration':
+        isEsModule = true;
+        hasDefaultExport = true;
+        break;
+      case 'ExportNamedDeclaration':
+        isEsModule = true;
+        if (node.declaration) {
+          hasNamedExports = true;
+        } else {
+          for (const specifier of node.specifiers) {
+            if (specifier.exported.name === 'default') {
+              hasDefaultExport = true;
+            } else {
+              hasNamedExports = true;
+            }
+          }
+        }
+        break;
+      case 'ExportAllDeclaration':
+        isEsModule = true;
+        if (node.exported && node.exported.name === 'default') {
+          hasDefaultExport = true;
+        } else {
+          hasNamedExports = true;
+        }
+        break;
+      case 'ImportDeclaration':
+        isEsModule = true;
+        break;
     }
-  };
-}
-
-var peerDependencies = {
-	rollup: "^2.3.4"
-};
-
-/* eslint-disable no-undefined */
-const operators = {
-  '==': x => equals(x.left, x.right, false),
-  '!=': x => not(operators['=='](x)),
-  '===': x => equals(x.left, x.right, true),
-  '!==': x => not(operators['==='](x)),
-  '!': x => isFalsy(x.argument),
-  '&&': x => isTruthy(x.left) && isTruthy(x.right),
-  '||': x => isTruthy(x.left) || isTruthy(x.right)
-};
-function flatten(node) {
-  const parts = [];
-
-  while (node.type === 'MemberExpression') {
-    if (node.computed) return null;
-    parts.unshift(node.property.name); // eslint-disable-next-line no-param-reassign
-
-    node = node.object;
   }
 
-  if (node.type !== 'Identifier') return null;
-  const _node = node,
-        name = _node.name;
-  parts.unshift(name);
-  return {
-    name,
-    keypath: parts.join('.')
-  };
-}
-
-function isTruthy(node) {
-  if (node.type === 'Literal') return !!node.value;
-  if (node.type === 'ParenthesizedExpression') return isTruthy(node.expression);
-  if (node.operator in operators) return operators[node.operator](node);
-  return undefined;
-}
-function isFalsy(node) {
-  return not(isTruthy(node));
-}
-
-function not(value) {
-  return value === undefined ? value : !value;
+  return { isEsModule, hasDefaultExport, hasNamedExports, ast };
 }
 
-function equals(a, b, strict) {
-  if (a.type !== b.type) return undefined; // eslint-disable-next-line eqeqeq
-
-  if (a.type === 'Literal') return strict ? a.value === b.value : a.value == b.value;
-  return undefined;
-}
+const isWrappedId = (id, suffix) => id.endsWith(suffix);
+const wrapId = (id, suffix) => `\0${id}${suffix}`;
+const unwrapId = (wrappedId, suffix) => wrappedId.slice(1, -suffix.length);
 
 const PROXY_SUFFIX = '?commonjs-proxy';
-const getProxyId = id => `\0${id}${PROXY_SUFFIX}`;
-const getIdFromProxyId = proxyId => proxyId.slice(1, -PROXY_SUFFIX.length);
+const REQUIRE_SUFFIX = '?commonjs-require';
 const EXTERNAL_SUFFIX = '?commonjs-external';
-const getExternalProxyId = id => `\0${id}${EXTERNAL_SUFFIX}`;
-const getIdFromExternalProxyId = proxyId => proxyId.slice(1, -EXTERNAL_SUFFIX.length);
-const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
-const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
-  if (path.startsWith(commonDir)) return VIRTUAL_PATH_BASE + path.slice(commonDir.length);
-  return path;
-};
+
 const DYNAMIC_REGISTER_PREFIX = '\0commonjs-dynamic-register:';
 const DYNAMIC_JSON_PREFIX = '\0commonjs-dynamic-json:';
 const DYNAMIC_PACKAGES_ID = '\0commonjs-dynamic-packages';
-const HELPERS_ID = '\0commonjsHelpers.js'; // `x['default']` is used instead of `x.default` for backward compatibility with ES3 browsers.
+
+const HELPERS_ID = '\0commonjsHelpers.js';
+
+// `x['default']` is used instead of `x.default` for backward compatibility with ES3 browsers.
 // Minifiers like uglify will usually transpile it back if compatibility with ES3 is not enabled.
+// This will no longer be necessary once Rollup switches to ES6 output, likely
+// in Rollup 3
 
 const HELPERS = `
 export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-export function createCommonjsModule(fn, basedir, module) {
-	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
-	}, fn(module, module.exports), module.exports;
+export function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export function getDefaultExportFromNamespaceIfPresent (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
 }
 
-export function getCjsExportFromNamespace (n) {
-	return n && n['default'] || n;
+export function getDefaultExportFromNamespaceIfNotNamed (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+}
+
+export 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;
 }
 `;
+
 const HELPER_NON_DYNAMIC = `
-export function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+export function createCommonjsModule(fn) {
+  var module = { exports: {} }
+	return fn(module, module.exports), module.exports;
+}
+
+export function commonjsRequire (target) {
+	throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
 }
 `;
+
 const HELPERS_DYNAMIC = `
+export function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
 export function commonjsRegister (path, loader) {
 	DYNAMIC_REQUIRE_LOADERS[path] = loader;
 }
@@ -356,878 +295,1217 @@ export function commonjsRequire (path, originalModuleDir) {
 commonjsRequire.cache = DYNAMIC_REQUIRE_CACHE;
 `;
 
-/* eslint-disable import/prefer-default-export */
-function getName(id) {
-  const name = pluginutils.makeLegalIdentifier(path.basename(id, path.extname(id)));
-
-  if (name !== 'index') {
-    return name;
-  }
-
-  const segments = path.dirname(id).split(path.sep);
-  return pluginutils.makeLegalIdentifier(segments[segments.length - 1]);
+function getHelpersModule(isDynamicRequireModulesEnabled) {
+  return `${HELPERS}${isDynamicRequireModulesEnabled ? HELPERS_DYNAMIC : HELPER_NON_DYNAMIC}`;
 }
 
-const reserved = 'process location abstract arguments boolean break byte case catch char class const continue debugger default delete do double else enum eval export extends false final finally float for from function goto if implements import in instanceof int interface let long native new null package private protected public return short static super switch synchronized this throw throws transient true try typeof var void volatile while with yield'.split(' ');
-const blacklist = {
-  __esModule: true
-};
-reserved.forEach(word => blacklist[word] = true);
-const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
-const firstpassGlobal = /\b(?:require|module|exports|global)\b/;
-const firstpassNoGlobal = /\b(?:require|module|exports)\b/;
-const importExportDeclaration = /^(?:Import|Export(?:Named|Default))Declaration/;
-const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
+/* eslint-disable import/prefer-default-export */
 
 function deconflict(scope, globals, identifier) {
   let i = 1;
   let deconflicted = pluginutils.makeLegalIdentifier(identifier);
 
-  while (scope.contains(deconflicted) || globals.has(deconflicted) || deconflicted in blacklist) {
-    deconflicted = `${identifier}_${i}`;
+  while (scope.contains(deconflicted) || globals.has(deconflicted)) {
+    deconflicted = pluginutils.makeLegalIdentifier(`${identifier}_${i}`);
     i += 1;
   }
-
+  // eslint-disable-next-line no-param-reassign
   scope.declarations[deconflicted] = true;
+
   return deconflicted;
 }
 
-function tryParse(parse, code, id) {
-  try {
-    return parse(code, {
-      allowReturnOutsideFunction: true
-    });
-  } catch (err) {
-    err.message += ` in ${id}`;
-    throw err;
+function getName(id) {
+  const name = pluginutils.makeLegalIdentifier(path.basename(id, path.extname(id)));
+  if (name !== 'index') {
+    return name;
   }
+  const segments = path.dirname(id).split(path.sep);
+  return pluginutils.makeLegalIdentifier(segments[segments.length - 1]);
 }
 
 function normalizePathSlashes(path) {
   return path.replace(/\\/g, '/');
 }
-function hasCjsKeywords(code, ignoreGlobal) {
-  const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
-  return firstpass.test(code);
-}
-function checkEsModule(parse, code, id) {
-  const ast = tryParse(parse, code, id);
-  let isEsModule = false;
-
-  var _iterator = _createForOfIteratorHelper(ast.body),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      const node = _step.value;
-      if (node.type === 'ExportDefaultDeclaration') return {
-        isEsModule: true,
-        hasDefaultExport: true,
-        ast
-      };
 
-      if (node.type === 'ExportNamedDeclaration') {
-        isEsModule = true;
-
-        var _iterator2 = _createForOfIteratorHelper(node.specifiers),
-            _step2;
+const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
+const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
+  const normalizedPath = normalizePathSlashes(path);
+  return normalizedPath.startsWith(commonDir)
+    ? VIRTUAL_PATH_BASE + normalizedPath.slice(commonDir.length)
+    : normalizedPath;
+};
 
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            const specifier = _step2.value;
+function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
+  let code = `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');`;
+  for (const dir of dynamicRequireModuleDirPaths) {
+    let entryPoint = 'index.js';
 
-            if (specifier.exported.name === 'default') {
-              return {
-                isEsModule: true,
-                hasDefaultExport: true,
-                ast
-              };
-            }
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
-        }
-      } else if (importExportDeclaration.test(node.type)) isEsModule = true;
+    try {
+      if (fs.existsSync(path.join(dir, 'package.json'))) {
+        entryPoint =
+          JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), { encoding: 'utf8' })).main ||
+          entryPoint;
+      }
+    } catch (ignored) {
+      // ignored
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
 
-  return {
-    isEsModule,
-    hasDefaultExport: false,
-    ast
-  };
+    code += `\ncommonjsRegister(${JSON.stringify(
+      getVirtualPathForDynamicRequirePath(dir, commonDir)
+    )}, function (module, exports) {
+  module.exports = require(${JSON.stringify(normalizePathSlashes(path.join(dir, entryPoint)))});
+});`;
+  }
+  return code;
 }
 
-function getDefinePropertyCallName(node, targetName) {
-  if (node.type !== 'CallExpression') return;
-  const _node$callee = node.callee,
-        object = _node$callee.object,
-        property = _node$callee.property;
-  if (!object || object.type !== 'Identifier' || object.name !== 'Object') return;
-  if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
-  if (node.arguments.length !== 3) return;
-
-  const _node$arguments = _slicedToArray(node.arguments, 2),
-        target = _node$arguments[0],
-        val = _node$arguments[1];
+function getDynamicPackagesEntryIntro(
+  dynamicRequireModuleDirPaths,
+  dynamicRequireModuleSet
+) {
+  let dynamicImports = Array.from(
+    dynamicRequireModuleSet,
+    (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
+  ).join('\n');
 
-  if (target.type !== 'Identifier' || target.name !== targetName) return; // eslint-disable-next-line consistent-return
+  if (dynamicRequireModuleDirPaths.length) {
+    dynamicImports += `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID)});`;
+  }
 
-  return val.value;
+  return dynamicImports;
 }
 
-function transformCommonjs(parse, code, id, isEntry, hasImporters, isEsModule, ignoreGlobal, ignoreRequire, sourceMap, isDynamicRequireModulesEnabled, dynamicRequireModuleSet, commonDir, astCache) {
-  const ast = astCache || tryParse(parse, code, id);
-  const magicString = new MagicString(code);
-  const required = {}; // Because objects have no guaranteed ordering, yet we need it,
-  // we need to keep track of the order in a array
-
-  const sources = [];
-  let uid = 0;
-  let scope = pluginutils.attachScopes(ast, 'scope');
-  const uses = {
-    module: false,
-    exports: false,
-    global: false,
-    require: false
-  };
-  let lexicalDepth = 0;
-  let programDepth = 0;
-  const globals = new Set(); // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
-
-  const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
-  const namedExports = {}; // TODO handle transpiled modules
-
-  let shouldWrap = /__esModule/.test(code);
-  let usesCommonjsHelpers = false;
-
-  function isRequireStatement(node) {
-    if (!node) return false;
-    if (node.type !== 'CallExpression') return false; // Weird case of `require()` or `module.require()` without arguments
+function isModuleRegistrationProxy(id, dynamicRequireModuleSet) {
+  const normalizedPath = normalizePathSlashes(id);
+  return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
+}
 
-    if (node.arguments.length === 0) return false;
-    return isRequireIdentifier(node.callee);
+function getDynamicRequirePaths(patterns) {
+  const dynamicRequireModuleSet = new Set();
+  for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
+    const isNegated = pattern.startsWith('!');
+    const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
+    for (const path$1 of glob__default['default'].sync(isNegated ? pattern.substr(1) : pattern)) {
+      modifySet(normalizePathSlashes(path.resolve(path$1)));
+    }
   }
+  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter(
+    (path) => {
+      try {
+        if (fs.statSync(path).isDirectory()) return true;
+      } catch (ignored) {
+        // Nothing to do here
+      }
+      return false;
+    }
+  );
+  return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
+}
 
-  function isRequireIdentifier(node) {
-    if (!node) return false;
+const isCjsPromises = new Map();
 
-    if (node.type === 'Identifier' && node.name === 'require'
-    /* `require` */
-    ) {
-        // `require` is hidden by a variable in local scope
-        if (scope.contains('require')) return false;
-        return true;
-      } else if (node.type === 'MemberExpression'
-    /* `[something].[something]` */
-    ) {
-        // `module.[something]`
-        if (node.object.type !== 'Identifier' || node.object.name !== 'module') return false; // `module` is hidden by a variable in local scope
+function getIsCjsPromise(id) {
+  let isCjsPromise = isCjsPromises.get(id);
+  if (isCjsPromise) return isCjsPromise.promise;
 
-        if (scope.contains('module')) return false; // `module.require(...)`
+  const promise = new Promise((resolve) => {
+    isCjsPromise = {
+      resolve,
+      promise: null
+    };
+    isCjsPromises.set(id, isCjsPromise);
+  });
+  isCjsPromise.promise = promise;
 
-        if (node.property.type !== 'Identifier' || node.property.name !== 'require') return false;
-        return true;
-      }
+  return promise;
+}
 
-    return false;
+function setIsCjsPromise(id, resolution) {
+  const isCjsPromise = isCjsPromises.get(id);
+  if (isCjsPromise) {
+    if (isCjsPromise.resolve) {
+      isCjsPromise.resolve(resolution);
+      isCjsPromise.resolve = null;
+    }
+  } else {
+    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: null });
   }
+}
 
-  function hasDynamicArguments(node) {
-    return node.arguments.length > 1 || node.arguments[0].type !== 'Literal' && (node.arguments[0].type !== 'TemplateLiteral' || node.arguments[0].expressions.length > 0);
-  }
+// e.g. id === "commonjsHelpers?commonjsRegister"
+function getSpecificHelperProxy(id) {
+  return `export {${id.split('?')[1]} as default} from '${HELPERS_ID}';`;
+}
 
-  function isStaticRequireStatement(node) {
-    if (!isRequireStatement(node)) return false;
-    if (hasDynamicArguments(node)) return false;
-    return true;
+function getUnknownRequireProxy(id, requireReturnsDefault) {
+  if (requireReturnsDefault === true || id.endsWith('.json')) {
+    return `export {default} from ${JSON.stringify(id)};`;
   }
+  const name = getName(id);
+  const exported =
+    requireReturnsDefault === 'auto'
+      ? `import {getDefaultExportFromNamespaceIfNotNamed} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(${name});`
+      : requireReturnsDefault === 'preferred'
+      ? `import {getDefaultExportFromNamespaceIfPresent} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name});`
+      : !requireReturnsDefault
+      ? `import {getAugmentedNamespace} from "${HELPERS_ID}"; export default /*@__PURE__*/getAugmentedNamespace(${name});`
+      : `export default ${name};`;
+  return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
+}
 
-  function isNodeRequireStatement(parent) {
-    const reservedMethod = ['resolve', 'cache', 'main'];
-
-    if (parent && parent.property && reservedMethod.indexOf(parent.property.name) > -1) {
-      return true;
-    }
+function getDynamicJsonProxy(id, commonDir) {
+  const normalizedPath = normalizePathSlashes(id.slice(DYNAMIC_JSON_PREFIX.length));
+  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
+    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
+  )}, function (module, exports) {
+  module.exports = require(${JSON.stringify(normalizedPath)});
+});`;
+}
 
-    return false;
-  }
+function getDynamicRequireProxy(normalizedPath, commonDir) {
+  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
+    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
+  )}, function (module, exports) {
+  ${fs.readFileSync(normalizedPath, { encoding: 'utf8' })}
+});`;
+}
 
-  function isIgnoredRequireStatement(requiredNode) {
-    return ignoreRequire(requiredNode.arguments[0].value);
+async function getStaticRequireProxy(
+  id,
+  requireReturnsDefault,
+  esModulesWithDefaultExport,
+  esModulesWithNamedExports
+) {
+  const name = getName(id);
+  const isCjs = await getIsCjsPromise(id);
+  if (isCjs) {
+    return `import { __moduleExports } from ${JSON.stringify(id)}; export default __moduleExports;`;
+  } else if (isCjs === null) {
+    return getUnknownRequireProxy(id, requireReturnsDefault);
+  } else if (!requireReturnsDefault) {
+    return `import {getAugmentedNamespace} from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
+      id
+    )}; export default /*@__PURE__*/getAugmentedNamespace(${name});`;
+  } else if (
+    requireReturnsDefault !== true &&
+    (requireReturnsDefault === 'namespace' ||
+      !esModulesWithDefaultExport.has(id) ||
+      (requireReturnsDefault === 'auto' && esModulesWithNamedExports.has(id)))
+  ) {
+    return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
   }
+  return `export {default} from ${JSON.stringify(id)};`;
+}
 
-  function getRequireStringArg(node) {
-    return node.arguments[0].type === 'Literal' ? node.arguments[0].value : node.arguments[0].quasis[0].value.cooked;
-  }
+/* eslint-disable no-param-reassign, no-undefined */
 
-  function getRequired(node, name) {
-    let sourceId = getRequireStringArg(node);
-    const isDynamicRegister = sourceId.startsWith(DYNAMIC_REGISTER_PREFIX);
+function getCandidatesForExtension(resolved, extension) {
+  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
+}
 
-    if (isDynamicRegister) {
-      sourceId = sourceId.substr(DYNAMIC_REGISTER_PREFIX.length);
-    }
+function getCandidates(resolved, extensions) {
+  return extensions.reduce(
+    (paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)),
+    [resolved]
+  );
+}
 
-    const existing = required[sourceId]; // eslint-disable-next-line no-undefined
+function getResolveId(extensions) {
+  function resolveExtensions(importee, importer) {
+    // not our problem
+    if (importee[0] !== '.' || !importer) return undefined;
 
-    if (existing === undefined) {
-      const isDynamic = hasDynamicModuleForPath(sourceId);
+    const resolved = path.resolve(path.dirname(importer), importee);
+    const candidates = getCandidates(resolved, extensions);
 
-      if (!name) {
-        do {
-          name = `require$$${uid}`;
-          uid += 1;
-        } while (scope.contains(name));
+    for (let i = 0; i < candidates.length; i += 1) {
+      try {
+        const stats = fs.statSync(candidates[i]);
+        if (stats.isFile()) return { id: candidates[i] };
+      } catch (err) {
+        /* noop */
       }
+    }
 
-      if (isDynamicRegister && sourceId.endsWith('.json')) {
-        sourceId = DYNAMIC_JSON_PREFIX + sourceId;
-      }
+    return undefined;
+  }
 
-      if (isDynamicRegister || !isDynamic || sourceId.endsWith('.json')) {
-        sources.push([sourceId, !isDynamicRegister]);
-      }
-
-      required[sourceId] = {
-        source: sourceId,
-        name,
-        importsDefault: false,
-        isDynamic
-      };
+  return function resolveId(importee, importer) {
+    // Proxies are only importing resolved ids, no need to resolve again
+    if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
+      return importee;
     }
 
-    return required[sourceId];
-  }
-
-  function hasDynamicModuleForPath(source) {
-    if (!/[/\\]/.test(source)) {
-      try {
-        const resolvedPath = normalizePathSlashes(resolve.sync(source, {
-          basedir: path.dirname(id)
-        }));
-
-        if (dynamicRequireModuleSet.has(resolvedPath)) {
-          return true;
-        }
-      } catch (ex) {
-        // Probably a node.js internal module
-        return false;
+    const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
+    const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
+    if (isProxyModule) {
+      importee = unwrapId(importee, PROXY_SUFFIX);
+    } else if (isRequiredModule) {
+      importee = unwrapId(importee, REQUIRE_SUFFIX);
+    }
+    if (importee.startsWith('\0')) {
+      if (
+        importee.startsWith(HELPERS_ID) ||
+        importee === DYNAMIC_PACKAGES_ID ||
+        importee.startsWith(DYNAMIC_JSON_PREFIX)
+      ) {
+        return importee;
       }
-
-      return false;
+      return null;
     }
 
-    for (var _i = 0, _arr = ['', '.js', '.json']; _i < _arr.length; _i++) {
-      const attemptExt = _arr[_i];
-      const resolvedPath = normalizePathSlashes(path.resolve(path.dirname(id), source + attemptExt));
-
-      if (dynamicRequireModuleSet.has(resolvedPath)) {
-        return true;
+    return this.resolve(importee, importer, {
+      skipSelf: true,
+      custom: { 'node-resolve': { isRequire: isProxyModule || isRequiredModule } }
+    }).then((resolved) => {
+      if (!resolved) {
+        resolved = resolveExtensions(importee, importer);
       }
-    }
+      if (resolved && isProxyModule) {
+        resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
+        resolved.external = false;
+      } else if (!resolved && (isProxyModule || isRequiredModule)) {
+        return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
+      }
+      return resolved;
+    });
+  };
+}
 
-    return false;
+function validateRollupVersion(rollupVersion, peerDependencyVersion) {
+  const [major, minor] = rollupVersion.split('.').map(Number);
+  const versionRegexp = /\^(\d+\.\d+)\.\d+/g;
+  let minMajor = Infinity;
+  let minMinor = Infinity;
+  let foundVersion;
+  // eslint-disable-next-line no-cond-assign
+  while ((foundVersion = versionRegexp.exec(peerDependencyVersion))) {
+    const [foundMajor, foundMinor] = foundVersion[1].split('.').map(Number);
+    if (foundMajor < minMajor) {
+      minMajor = foundMajor;
+      minMinor = foundMinor;
+    }
   }
+  if (major < minMajor || (major === minMajor && minor < minMinor)) {
+    throw new Error(
+      `Insufficient Rollup version: "@rollup/plugin-commonjs" requires at least rollup@${minMajor}.${minMinor} but found rollup@${rollupVersion}.`
+    );
+  }
+}
 
-  function shouldUseSimulatedRequire(required) {
-    return hasDynamicModuleForPath(required.source) && ( // We only do `commonjsRequire` for json if it's the `commonjsRegister` call.
-    required.source.startsWith(DYNAMIC_REGISTER_PREFIX) || !required.source.endsWith('.json'));
-  } // do a first pass, see which names are assigned to. This is necessary to prevent
-  // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
-  // where `foo` is later reassigned. (This happens in the wild. CommonJS, sigh)
+const operators = {
+  '==': (x) => equals(x.left, x.right, false),
 
+  '!=': (x) => not(operators['=='](x)),
 
-  const assignedTo = new Set();
-  estreeWalker.walk(ast, {
-    enter(node) {
-      if (node.type !== 'AssignmentExpression') return;
-      if (node.left.type === 'MemberExpression') return;
-      pluginutils.extractAssignedNames(node.left).forEach(name => {
-        assignedTo.add(name);
-      });
-    }
+  '===': (x) => equals(x.left, x.right, true),
 
-  });
-  estreeWalker.walk(ast, {
-    enter(node, parent) {
-      if (sourceMap) {
-        magicString.addSourcemapLocation(node.start);
-        magicString.addSourcemapLocation(node.end);
-      } // skip dead branches
+  '!==': (x) => not(operators['==='](x)),
 
+  '!': (x) => isFalsy(x.argument),
 
-      if (parent && (parent.type === 'IfStatement' || parent.type === 'ConditionalExpression')) {
-        if (node === parent.consequent && isFalsy(parent.test)) {
-          this.skip();
-          return;
-        }
+  '&&': (x) => isTruthy(x.left) && isTruthy(x.right),
 
-        if (node === parent.alternate && isTruthy(parent.test)) {
-          this.skip();
-          return;
-        }
-      }
+  '||': (x) => isTruthy(x.left) || isTruthy(x.right)
+};
 
-      if (node._skip) {
-        this.skip();
-        return;
-      }
+function not(value) {
+  return value === null ? value : !value;
+}
 
-      programDepth += 1;
+function equals(a, b, strict) {
+  if (a.type !== b.type) return null;
+  // eslint-disable-next-line eqeqeq
+  if (a.type === 'Literal') return strict ? a.value === b.value : a.value == b.value;
+  return null;
+}
 
-      if (node.scope) {
-        scope = node.scope;
-      }
+function isTruthy(node) {
+  if (!node) return false;
+  if (node.type === 'Literal') return !!node.value;
+  if (node.type === 'ParenthesizedExpression') return isTruthy(node.expression);
+  if (node.operator in operators) return operators[node.operator](node);
+  return null;
+}
 
-      if (functionType.test(node.type)) lexicalDepth += 1; // if toplevel return, we need to wrap it
+function isFalsy(node) {
+  return not(isTruthy(node));
+}
 
-      if (node.type === 'ReturnStatement' && lexicalDepth === 0) {
-        shouldWrap = true;
-      } // rewrite `this` as `commonjsHelpers.commonjsGlobal`
+function getKeypath(node) {
+  const parts = [];
 
+  while (node.type === 'MemberExpression') {
+    if (node.computed) return null;
 
-      if (node.type === 'ThisExpression' && lexicalDepth === 0) {
-        uses.global = true;
+    parts.unshift(node.property.name);
+    // eslint-disable-next-line no-param-reassign
+    node = node.object;
+  }
 
-        if (!ignoreGlobal) {
-          magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-            storeName: true
-          });
-          usesCommonjsHelpers = true;
-        }
+  if (node.type !== 'Identifier') return null;
 
-        return;
-      } // rewrite `typeof module`, `typeof module.exports` and `typeof exports` (https://github.com/rollup/rollup-plugin-commonjs/issues/151)
+  const { name } = node;
+  parts.unshift(name);
 
+  return { name, keypath: parts.join('.') };
+}
 
-      if (node.type === 'UnaryExpression' && node.operator === 'typeof') {
-        const flattened = flatten(node.argument);
-        if (!flattened) return;
-        if (scope.contains(flattened.name)) return;
+const KEY_COMPILED_ESM = '__esModule';
 
-        if (flattened.keypath === 'module.exports' || flattened.keypath === 'module' || flattened.keypath === 'exports') {
-          magicString.overwrite(node.start, node.end, `'object'`, {
-            storeName: false
-          });
-        }
-      } // rewrite `require` (if not already handled) `global` and `define`, and handle free references to
-      // `module` and `exports` as these mean we need to wrap the module in commonjsHelpers.createCommonjsModule
+function isDefineCompiledEsm(node) {
+  const definedProperty =
+    getDefinePropertyCallName(node, 'exports') || getDefinePropertyCallName(node, 'module.exports');
+  if (definedProperty && definedProperty.key === KEY_COMPILED_ESM) {
+    return isTruthy(definedProperty.value);
+  }
+  return false;
+}
 
+function getDefinePropertyCallName(node, targetName) {
+  const targetNames = targetName.split('.');
 
-      if (node.type === 'Identifier') {
-        if (isReference(node, parent) && !scope.contains(node.name)) {
-          if (node.name in uses) {
-            if (isRequireIdentifier(node)) {
-              if (isNodeRequireStatement(parent)) {
-                return;
-              }
+  const {
+    callee: { object, property }
+  } = node;
+  if (!object || object.type !== 'Identifier' || object.name !== 'Object') return;
+  if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
+  if (node.arguments.length !== 3) return;
 
-              if (!isDynamicRequireModulesEnabled && isStaticRequireStatement(parent)) {
-                return;
-              }
+  const [target, key, value] = node.arguments;
+  if (targetNames.length === 1) {
+    if (target.type !== 'Identifier' || target.name !== targetNames[0]) {
+      return;
+    }
+  }
 
-              if (isDynamicRequireModulesEnabled && isRequireStatement(parent)) {
-                magicString.appendLeft(parent.end - 1, `,${JSON.stringify(path.dirname(id) === '.' ? null
-                /* default behavior */
-                : getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir))}`);
-              }
+  if (targetNames.length === 2) {
+    if (
+      target.type !== 'MemberExpression' ||
+      target.object.name !== targetNames[0] ||
+      target.property.name !== targetNames[1]
+    ) {
+      return;
+    }
+  }
 
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-                storeName: true
-              });
-              usesCommonjsHelpers = true;
-            }
+  if (value.type !== 'ObjectExpression' || !value.properties) return;
 
-            uses[node.name] = true;
+  const valueProperty = value.properties.find((p) => p.key && p.key.name === 'value');
+  if (!valueProperty || !valueProperty.value) return;
 
-            if (node.name === 'global' && !ignoreGlobal) {
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-                storeName: true
-              });
-              usesCommonjsHelpers = true;
-            } // if module or exports are used outside the context of an assignment
-            // expression, we need to wrap the module
+  // eslint-disable-next-line consistent-return
+  return { key: key.value, value: valueProperty.value };
+}
+
+function isLocallyShadowed(name, scope) {
+  while (scope.parent) {
+    if (scope.declarations[name]) {
+      return true;
+    }
+    // eslint-disable-next-line no-param-reassign
+    scope = scope.parent;
+  }
+  return false;
+}
 
+function wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath) {
+  const args = `module${uses.exports ? ', exports' : ''}`;
 
-            if (node.name === 'module' || node.name === 'exports') {
-              shouldWrap = true;
-            }
-          }
+  magicString
+    .trim()
+    .prepend(`var ${moduleName} = ${HELPERS_NAME}.createCommonjsModule(function (${args}) {\n`)
+    .append(
+      `\n}${virtualDynamicRequirePath ? `, ${JSON.stringify(virtualDynamicRequirePath)}` : ''});`
+    );
+}
 
-          if (node.name === 'define') {
-            magicString.overwrite(node.start, node.end, 'undefined', {
-              storeName: true
-            });
-          }
+function rewriteExportsAndGetExportsBlock(
+  magicString,
+  moduleName,
+  wrapped,
+  topLevelModuleExportsAssignments,
+  topLevelExportsAssignmentsByName,
+  defineCompiledEsmExpressions,
+  deconflict,
+  isRestorableCompiledEsm,
+  code,
+  uses,
+  HELPERS_NAME
+) {
+  const namedExportDeclarations = [`export { ${moduleName} as __moduleExports };`];
+  const moduleExportsPropertyAssignments = [];
+  let deconflictedDefaultExportName;
+
+  if (!wrapped) {
+    let hasModuleExportsAssignment = false;
+    const namedExportProperties = [];
+
+    // Collect and rewrite module.exports assignments
+    for (const { left } of topLevelModuleExportsAssignments) {
+      hasModuleExportsAssignment = true;
+      magicString.overwrite(left.start, left.end, `var ${moduleName}`);
+    }
 
-          globals.add(node.name);
-        }
+    // Collect and rewrite named exports
+    for (const [exportName, node] of topLevelExportsAssignmentsByName) {
+      const deconflicted = deconflict(exportName);
+      magicString.overwrite(node.start, node.left.end, `var ${deconflicted}`);
 
-        return;
-      } // Is this an assignment to exports or module.exports?
-
-
-      if (node.type === 'AssignmentExpression') {
-        if (node.left.type !== 'MemberExpression') return;
-        const flattened = flatten(node.left);
-        if (!flattened) return;
-        if (scope.contains(flattened.name)) return;
-        const match = exportsPattern.exec(flattened.keypath);
-        if (!match || flattened.keypath === 'exports') return;
-        uses[flattened.name] = true; // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
-        // if this isn't top-level, we'll need to wrap the module
-
-        if (programDepth > 3) shouldWrap = true;
-        node.left._skip = true;
-
-        if (flattened.keypath === 'module.exports' && node.right.type === 'ObjectExpression') {
-          node.right.properties.forEach(prop => {
-            if (prop.computed || !('key' in prop) || prop.key.type !== 'Identifier') return;
-            const name = prop.key.name;
-            if (name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
-          });
-          return;
-        }
+      if (exportName === 'default') {
+        deconflictedDefaultExportName = deconflicted;
+      } else {
+        namedExportDeclarations.push(
+          exportName === deconflicted
+            ? `export { ${exportName} };`
+            : `export { ${deconflicted} as ${exportName} };`
+        );
+      }
 
-        if (match[1]) namedExports[match[1]] = true;
-        return;
+      if (hasModuleExportsAssignment) {
+        moduleExportsPropertyAssignments.push(`${moduleName}.${exportName} = ${deconflicted};`);
+      } else {
+        namedExportProperties.push(`\t${exportName}: ${deconflicted}`);
       }
+    }
 
-      const name = getDefinePropertyCallName(node, 'exports');
-      if (name && name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true; // if this is `var x = require('x')`, we can do `import x from 'x'`
+    // Regenerate CommonJS namespace
+    if (!hasModuleExportsAssignment) {
+      const moduleExports = `{\n${namedExportProperties.join(',\n')}\n}`;
+      magicString
+        .trim()
+        .append(
+          `\n\nvar ${moduleName} = ${
+            isRestorableCompiledEsm
+              ? `/*#__PURE__*/Object.defineProperty(${moduleExports}, '__esModule', {value: true})`
+              : moduleExports
+          };`
+        );
+    }
+  }
 
-      if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier' && isStaticRequireStatement(node.init) && !isIgnoredRequireStatement(node.init)) {
-        // for now, only do this for top-level requires. maybe fix this in future
-        if (scope.parent) return; // edge case — CJS allows you to assign to imports. ES doesn't
+  // Generate default export
+  const defaultExport = [];
+  if (isRestorableCompiledEsm) {
+    defaultExport.push(`export default ${deconflictedDefaultExportName || moduleName};`);
+  } else if (
+    (wrapped || deconflictedDefaultExportName) &&
+    (defineCompiledEsmExpressions.length > 0 || code.indexOf('__esModule') >= 0)
+  ) {
+    // eslint-disable-next-line no-param-reassign
+    uses.commonjsHelpers = true;
+    defaultExport.push(
+      `export default /*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${moduleName});`
+    );
+  } else {
+    defaultExport.push(`export default ${moduleName};`);
+  }
 
-        if (assignedTo.has(node.id.name)) return;
-        const required = getRequired(node.init, node.id.name);
-        required.importsDefault = true;
+  return `\n\n${defaultExport
+    .concat(namedExportDeclarations)
+    .concat(moduleExportsPropertyAssignments)
+    .join('\n')}`;
+}
 
-        if (required.name === node.id.name && !required.isDynamic) {
-          node._shouldRemove = true;
-        }
-      }
+function isRequireStatement(node, scope) {
+  if (!node) return false;
+  if (node.type !== 'CallExpression') return false;
 
-      if (!isStaticRequireStatement(node) || isIgnoredRequireStatement(node)) {
-        return;
-      }
+  // Weird case of `require()` or `module.require()` without arguments
+  if (node.arguments.length === 0) return false;
 
-      const required = getRequired(node);
+  return isRequire(node.callee, scope);
+}
 
-      if (parent.type === 'ExpressionStatement') {
-        // is a bare import, e.g. `require('foo');`
-        magicString.remove(parent.start, parent.end);
-      } else {
-        required.importsDefault = true;
+function isRequire(node, scope) {
+  return (
+    (node.type === 'Identifier' && node.name === 'require' && !scope.contains('require')) ||
+    (node.type === 'MemberExpression' && isModuleRequire(node, scope))
+  );
+}
 
-        if (shouldUseSimulatedRequire(required)) {
-          magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(getVirtualPathForDynamicRequirePath(normalizePathSlashes(required.source), commonDir))}, ${JSON.stringify(path.dirname(id) === '.' ? null
-          /* default behavior */
-          : getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir))})`);
-          usesCommonjsHelpers = true;
-        } else {
-          magicString.overwrite(node.start, node.end, required.name);
-        }
-      }
+function isModuleRequire({ object, property }, scope) {
+  return (
+    object.type === 'Identifier' &&
+    object.name === 'module' &&
+    property.type === 'Identifier' &&
+    property.name === 'require' &&
+    !scope.contains('module')
+  );
+}
 
-      node.callee._skip = true;
-    },
+function isStaticRequireStatement(node, scope) {
+  if (!isRequireStatement(node, scope)) return false;
+  return !hasDynamicArguments(node);
+}
 
-    leave(node) {
-      programDepth -= 1;
-      if (node.scope) scope = scope.parent;
-      if (functionType.test(node.type)) lexicalDepth -= 1;
+function hasDynamicArguments(node) {
+  return (
+    node.arguments.length > 1 ||
+    (node.arguments[0].type !== 'Literal' &&
+      (node.arguments[0].type !== 'TemplateLiteral' || node.arguments[0].expressions.length > 0))
+  );
+}
 
-      if (node.type === 'VariableDeclaration') {
-        let keepDeclaration = false;
-        let c = node.declarations[0].start;
+const reservedMethod = { resolve: true, cache: true, main: true };
 
-        for (let i = 0; i < node.declarations.length; i += 1) {
-          const declarator = node.declarations[i];
+function isNodeRequirePropertyAccess(parent) {
+  return parent && parent.property && reservedMethod[parent.property.name];
+}
 
-          if (declarator._shouldRemove) {
-            magicString.remove(c, declarator.end);
-          } else {
-            if (!keepDeclaration) {
-              magicString.remove(c, declarator.start);
-              keepDeclaration = true;
-            }
+function isIgnoredRequireStatement(requiredNode, ignoreRequire) {
+  return ignoreRequire(requiredNode.arguments[0].value);
+}
 
-            c = declarator.end;
-          }
-        }
+function getRequireStringArg(node) {
+  return node.arguments[0].type === 'Literal'
+    ? node.arguments[0].value
+    : node.arguments[0].quasis[0].value.cooked;
+}
 
-        if (!keepDeclaration) {
-          magicString.remove(node.start, node.end);
-        }
+function hasDynamicModuleForPath(source, id, dynamicRequireModuleSet) {
+  if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
+    try {
+      const resolvedPath = normalizePathSlashes(resolve.sync(source, { basedir: path.dirname(id) }));
+      if (dynamicRequireModuleSet.has(resolvedPath)) {
+        return true;
       }
+    } catch (ex) {
+      // Probably a node.js internal module
+      return false;
     }
 
-  });
-
-  if (!sources.length && !uses.module && !uses.exports && !uses.require && (ignoreGlobal || !uses.global)) {
-    // not a CommonJS module
-    return null;
-  } // If `isEsModule` is on, it means it has ES6 import/export statements,
-  //   which just can't be wrapped in a function.
-
-
-  if (isEsModule) shouldWrap = false;
-  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
-  const importBlock = `${(usesCommonjsHelpers ? [`import * as ${HELPERS_NAME} from '${HELPERS_ID}';`] : []).concat(sources.map(([source]) => // import the actual module before the proxy, so that we know
-  // what kind of proxy to build
-  `import '${source}';`), sources.filter(([, importProxy]) => importProxy).map(([source]) => {
-    const _required$source = required[source],
-          name = _required$source.name,
-          importsDefault = _required$source.importsDefault;
-    return `import ${importsDefault ? `${name} from ` : ``}'${getProxyId(source)}';`;
-  })).join('\n')}\n\n`;
-  const namedExportDeclarations = [];
-  let wrapperStart = '';
-  let wrapperEnd = '';
-  const moduleName = deconflict(scope, globals, getName(id));
-
-  if ((!isEntry || hasImporters) && !isEsModule) {
-    const exportModuleExports = {
-      str: `export { ${moduleName} as __moduleExports };`,
-      name: '__moduleExports'
-    };
-    namedExportDeclarations.push(exportModuleExports);
+    return false;
   }
 
-  const defaultExportPropertyAssignments = [];
-  let hasDefaultExport = false;
-
-  if (shouldWrap) {
-    const args = `module${uses.exports ? ', exports' : ''}`;
-    wrapperStart = `var ${moduleName} = ${HELPERS_NAME}.createCommonjsModule(function (${args}) {\n`;
-    wrapperEnd = `\n}`;
-
-    if (isDynamicRequireModulesEnabled) {
-      wrapperEnd += `, ${JSON.stringify(getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir))}`;
+  for (const attemptExt of ['', '.js', '.json']) {
+    const resolvedPath = normalizePathSlashes(path.resolve(path.dirname(id), source + attemptExt));
+    if (dynamicRequireModuleSet.has(resolvedPath)) {
+      return true;
     }
+  }
 
-    wrapperEnd += `);`;
-  } else {
-    const names = [];
-
-    var _iterator3 = _createForOfIteratorHelper(ast.body),
-        _step3;
+  return false;
+}
 
-    try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        const node = _step3.value;
+function getRequireHandlers() {
+  const requiredSources = [];
+  const requiredBySource = Object.create(null);
+  const requiredByNode = new Map();
+  const requireExpressionsWithUsedReturnValue = [];
+
+  function addRequireStatement(sourceId, node, scope, usesReturnValue) {
+    const required = getRequired(sourceId);
+    requiredByNode.set(node, { scope, required });
+    if (usesReturnValue) {
+      required.nodesUsingRequired.push(node);
+      requireExpressionsWithUsedReturnValue.push(node);
+    }
+  }
 
-        if (node.type === 'ExpressionStatement' && node.expression.type === 'AssignmentExpression') {
-          const left = node.expression.left;
-          const flattened = flatten(left);
+  function getRequired(sourceId) {
+    if (!requiredBySource[sourceId]) {
+      requiredSources.push(sourceId);
 
-          if (!flattened) {
-            continue;
-          }
+      requiredBySource[sourceId] = {
+        source: sourceId,
+        name: null,
+        nodesUsingRequired: []
+      };
+    }
 
-          const match = exportsPattern.exec(flattened.keypath);
+    return requiredBySource[sourceId];
+  }
 
-          if (!match) {
-            continue;
-          }
+  function rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    topLevelRequireDeclarators,
+    reassignedNames,
+    helpersNameIfUsed,
+    dynamicRegisterSources
+  ) {
+    const removedDeclarators = getDeclaratorsReplacedByImportsAndSetImportNames(
+      topLevelRequireDeclarators,
+      requiredByNode,
+      reassignedNames
+    );
+    setRemainingImportNamesAndRewriteRequires(
+      requireExpressionsWithUsedReturnValue,
+      requiredByNode,
+      magicString
+    );
+    removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString);
+    const importBlock = `${(helpersNameIfUsed
+      ? [`import * as ${helpersNameIfUsed} from '${HELPERS_ID}';`]
+      : []
+    )
+      .concat(
+        // dynamic registers first, as the may be required in the other modules
+        [...dynamicRegisterSources].map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+        // now the actual modules so that they are analyzed before creating the proxies;
+        // no need to do this for virtual modules as we never proxy them
+        requiredSources
+          .filter((source) => !source.startsWith('\0'))
+          .map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+        // now the proxy modules
+        requiredSources.map((source) => {
+          const { name, nodesUsingRequired } = requiredBySource[source];
+          return `import ${nodesUsingRequired.length ? `${name} from ` : ``}'${
+            source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
+          }';`;
+        })
+      )
+      .join('\n')}`;
+    return importBlock ? `${importBlock}\n\n` : '';
+  }
 
-          if (flattened.keypath === 'module.exports') {
-            hasDefaultExport = true;
-            magicString.overwrite(left.start, left.end, `var ${moduleName}`);
-          } else {
-            const _match = _slicedToArray(match, 2),
-                  name = _match[1];
+  return {
+    addRequireStatement,
+    requiredSources,
+    rewriteRequireExpressionsAndGetImportBlock
+  };
+}
 
-            const deconflicted = deconflict(scope, globals, name);
-            names.push({
-              name,
-              deconflicted
-            });
-            magicString.overwrite(node.start, left.end, `var ${deconflicted}`);
-            const declaration = name === deconflicted ? `export { ${name} };` : `export { ${deconflicted} as ${name} };`;
+function getDeclaratorsReplacedByImportsAndSetImportNames(
+  topLevelRequireDeclarators,
+  requiredByNode,
+  reassignedNames
+) {
+  const removedDeclarators = new Set();
+  for (const declarator of topLevelRequireDeclarators) {
+    const { required } = requiredByNode.get(declarator.init);
+    if (!required.name) {
+      const potentialName = declarator.id.name;
+      if (
+        !reassignedNames.has(potentialName) &&
+        !required.nodesUsingRequired.some((node) =>
+          isLocallyShadowed(potentialName, requiredByNode.get(node).scope)
+        )
+      ) {
+        required.name = potentialName;
+        removedDeclarators.add(declarator);
+      }
+    }
+  }
+  return removedDeclarators;
+}
 
-            if (name !== 'default') {
-              namedExportDeclarations.push({
-                str: declaration,
-                name
-              });
-            }
+function setRemainingImportNamesAndRewriteRequires(
+  requireExpressionsWithUsedReturnValue,
+  requiredByNode,
+  magicString
+) {
+  let uid = 0;
+  for (const requireExpression of requireExpressionsWithUsedReturnValue) {
+    const { required } = requiredByNode.get(requireExpression);
+    if (!required.name) {
+      let potentialName;
+      const isUsedName = (node) => requiredByNode.get(node).scope.contains(potentialName);
+      do {
+        potentialName = `require$$${uid}`;
+        uid += 1;
+      } while (required.nodesUsingRequired.some(isUsedName));
+      required.name = potentialName;
+    }
+    magicString.overwrite(requireExpression.start, requireExpression.end, required.name);
+  }
+}
 
-            defaultExportPropertyAssignments.push(`${moduleName}.${name} = ${deconflicted};`);
-          }
-        }
+function removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString) {
+  for (const declaration of topLevelDeclarations) {
+    let keepDeclaration = false;
+    let [{ start }] = declaration.declarations;
+    for (const declarator of declaration.declarations) {
+      if (removedDeclarators.has(declarator)) {
+        magicString.remove(start, declarator.end);
+      } else if (!keepDeclaration) {
+        magicString.remove(start, declarator.start);
+        keepDeclaration = true;
       }
-    } catch (err) {
-      _iterator3.e(err);
-    } finally {
-      _iterator3.f();
+      start = declarator.end;
     }
-
-    if (!hasDefaultExport && (names.length || (!isEntry || hasImporters) && !isEsModule)) {
-      wrapperEnd = `\n\nvar ${moduleName} = {\n${names.map(({
-        name,
-        deconflicted
-      }) => `\t${name}: ${deconflicted}`).join(',\n')}\n};`;
+    if (!keepDeclaration) {
+      magicString.remove(declaration.start, declaration.end);
     }
   }
+}
 
-  const defaultExport = `export default ${moduleName};`;
-  const named = namedExportDeclarations.filter(x => x.name !== 'default' || !hasDefaultExport).map(x => x.str);
-  const exportBlock = `\n\n${(isEsModule ? [] : [defaultExport]).concat(named).concat(hasDefaultExport ? defaultExportPropertyAssignments : []).join('\n')}`;
-  magicString.trim().prepend(importBlock + wrapperStart).trim().append(wrapperEnd);
-  const injectExportBlock = hasDefaultExport || named.length > 0 || shouldWrap || !isEntry || hasImporters;
+/* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
 
-  if (injectExportBlock) {
-    magicString.append(exportBlock);
-  }
+const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
 
-  code = magicString.toString();
-  const map = sourceMap ? magicString.generateMap() : null;
-  return {
-    code,
-    map,
-    syntheticNamedExports: injectExportBlock
+const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
+
+function transformCommonjs(
+  parse,
+  code,
+  id,
+  isEsModule,
+  ignoreGlobal,
+  ignoreRequire,
+  sourceMap,
+  isDynamicRequireModulesEnabled,
+  dynamicRequireModuleSet,
+  disableWrap,
+  commonDir,
+  astCache
+) {
+  const ast = astCache || tryParse(parse, code, id);
+  const magicString = new MagicString__default['default'](code);
+  const uses = {
+    module: false,
+    exports: false,
+    global: false,
+    require: false,
+    commonjsHelpers: false
   };
-}
+  const virtualDynamicRequirePath =
+    isDynamicRequireModulesEnabled && getVirtualPathForDynamicRequirePath(path.dirname(id), commonDir);
+  let scope = pluginutils.attachScopes(ast, 'scope');
+  let lexicalDepth = 0;
+  let programDepth = 0;
+  let shouldWrap = false;
+  const defineCompiledEsmExpressions = [];
 
-function getDynamicRequirePaths(patterns) {
-  const dynamicRequireModuleSet = new Set();
+  const globals = new Set();
 
-  var _iterator = _createForOfIteratorHelper(!patterns || Array.isArray(patterns) ? patterns || [] : [patterns]),
-      _step;
+  // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
+  const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
+  const namedExports = {};
+  const dynamicRegisterSources = new Set();
 
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      const pattern = _step.value;
-      const isNegated = pattern.startsWith('!');
-      const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
+  const {
+    addRequireStatement,
+    requiredSources,
+    rewriteRequireExpressionsAndGetImportBlock
+  } = getRequireHandlers();
 
-      var _iterator2 = _createForOfIteratorHelper(glob.sync(isNegated ? pattern.substr(1) : pattern)),
-          _step2;
+  // See which names are assigned to. This is necessary to prevent
+  // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
+  // where `foo` is later reassigned. (This happens in the wild. CommonJS, sigh)
+  const reassignedNames = new Set();
+  const topLevelDeclarations = [];
+  const topLevelRequireDeclarators = new Set();
+  const skippedNodes = new Set();
+  const topLevelModuleExportsAssignments = [];
+  const topLevelExportsAssignmentsByName = new Map();
 
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          const path$1 = _step2.value;
-          modifySet(normalizePathSlashes(path.resolve(path$1)));
-        }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
+  estreeWalker.walk(ast, {
+    enter(node, parent) {
+      if (skippedNodes.has(node)) {
+        this.skip();
+        return;
       }
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
 
-  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter(path => {
-    try {
-      if (fs.statSync(path).isDirectory()) return true;
-    } catch (ignored) {// Nothing to do here
-    }
+      programDepth += 1;
+      if (node.scope) ({ scope } = node);
+      if (functionType.test(node.type)) lexicalDepth += 1;
+      if (sourceMap) {
+        magicString.addSourcemapLocation(node.start);
+        magicString.addSourcemapLocation(node.end);
+      }
 
-    return false;
-  });
-  return {
-    dynamicRequireModuleSet,
-    dynamicRequireModuleDirPaths
-  };
-}
+      // eslint-disable-next-line default-case
+      switch (node.type) {
+        case 'AssignmentExpression':
+          if (node.left.type === 'MemberExpression') {
+            const flattened = getKeypath(node.left);
+            if (!flattened || scope.contains(flattened.name)) return;
 
-/* eslint-disable no-undefined */
-const isCjsPromises = new Map();
-function getIsCjsPromise(id) {
-  let isCjsPromise = isCjsPromises.get(id);
-  if (isCjsPromise) return isCjsPromise.promise;
-  const promise = new Promise(resolve => {
-    isCjsPromise = {
-      resolve,
-      promise: undefined
-    };
-    isCjsPromises.set(id, isCjsPromise);
-  });
-  isCjsPromise.promise = promise;
-  return promise;
-}
-function setIsCjsPromise(id, resolution) {
-  const isCjsPromise = isCjsPromises.get(id);
+            const exportsPatternMatch = exportsPattern.exec(flattened.keypath);
+            if (!exportsPatternMatch || flattened.keypath === 'exports') return;
 
-  if (isCjsPromise) {
-    if (isCjsPromise.resolve) {
-      isCjsPromise.resolve(resolution);
-      isCjsPromise.resolve = undefined;
-    }
-  } else {
-    isCjsPromises.set(id, {
-      promise: Promise.resolve(resolution),
-      resolve: undefined
-    });
-  }
-}
-
-/* eslint-disable no-param-reassign, no-undefined */
+            const [, exportName] = exportsPatternMatch;
+            uses[flattened.name] = true;
 
-function getCandidatesForExtension(resolved, extension) {
-  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
-}
+            // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
+            if (programDepth > 3) {
+              shouldWrap = true;
+            } else if (exportName === KEY_COMPILED_ESM) {
+              defineCompiledEsmExpressions.push(parent);
+            } else if (flattened.keypath === 'module.exports') {
+              topLevelModuleExportsAssignments.push(node);
+            } else if (!topLevelExportsAssignmentsByName.has(exportName)) {
+              topLevelExportsAssignmentsByName.set(exportName, node);
+            } else {
+              shouldWrap = true;
+            }
 
-function getCandidates(resolved, extensions) {
-  return extensions.reduce((paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)), [resolved]);
-}
+            skippedNodes.add(node.left);
 
-function getResolveId(extensions) {
-  function resolveExtensions(importee, importer) {
-    // not our problem
-    if (importee[0] !== '.' || !importer) return undefined;
-    const resolved = path.resolve(path.dirname(importer), importee);
-    const candidates = getCandidates(resolved, extensions);
-
-    for (let i = 0; i < candidates.length; i += 1) {
-      try {
-        const stats = fs.statSync(candidates[i]);
-        if (stats.isFile()) return {
-          id: candidates[i]
-        };
-      } catch (err) {
-        /* noop */
-      }
-    }
+            if (flattened.keypath === 'module.exports' && node.right.type === 'ObjectExpression') {
+              node.right.properties.forEach((prop) => {
+                if (prop.computed || !('key' in prop) || prop.key.type !== 'Identifier') return;
+                const { name } = prop.key;
+                if (name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
+              });
+              return;
+            }
 
-    return undefined;
-  }
+            if (exportsPatternMatch[1]) namedExports[exportsPatternMatch[1]] = true;
+          } else {
+            for (const name of pluginutils.extractAssignedNames(node.left)) {
+              reassignedNames.add(name);
+            }
+          }
+          return;
+        case 'CallExpression': {
+          if (isDefineCompiledEsm(node)) {
+            if (programDepth === 3 && parent.type === 'ExpressionStatement') {
+              // skip special handling for [module.]exports until we know we render this
+              skippedNodes.add(node.arguments[0]);
+              defineCompiledEsmExpressions.push(parent);
+            } else {
+              shouldWrap = true;
+            }
+            return;
+          }
+          if (!isStaticRequireStatement(node, scope)) return;
+          if (!isDynamicRequireModulesEnabled) {
+            skippedNodes.add(node.callee);
+          }
+          if (!isIgnoredRequireStatement(node, ignoreRequire)) {
+            skippedNodes.add(node.callee);
+            const usesReturnValue = parent.type !== 'ExpressionStatement';
+
+            let sourceId = getRequireStringArg(node);
+            const isDynamicRegister = sourceId.startsWith(DYNAMIC_REGISTER_PREFIX);
+            if (isDynamicRegister) {
+              sourceId = sourceId.substr(DYNAMIC_REGISTER_PREFIX.length);
+              if (sourceId.endsWith('.json')) {
+                sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+              }
+              dynamicRegisterSources.add(sourceId);
+            } else {
+              if (
+                !sourceId.endsWith('.json') &&
+                hasDynamicModuleForPath(sourceId, id, dynamicRequireModuleSet)
+              ) {
+                magicString.overwrite(
+                  node.start,
+                  node.end,
+                  `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(
+                    getVirtualPathForDynamicRequirePath(sourceId, commonDir)
+                  )}, ${JSON.stringify(
+                    path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+                  )})`
+                );
+                uses.commonjsHelpers = true;
+                return;
+              }
+              addRequireStatement(sourceId, node, scope, usesReturnValue);
+            }
 
-  function resolveId(importee, importer) {
-    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
+            if (usesReturnValue) {
+              if (
+                parent.type === 'VariableDeclarator' &&
+                !scope.parent &&
+                parent.id.type === 'Identifier'
+              ) {
+                // This will allow us to reuse this variable name as the imported variable if it is not reassigned
+                // and does not conflict with variables in other places where this is imported
+                topLevelRequireDeclarators.add(parent);
+              }
+            } else {
+              // This is a bare import, e.g. `require('foo');`
+              magicString.remove(parent.start, parent.end);
+            }
+          }
+          return;
+        }
+        case 'ConditionalExpression':
+        case 'IfStatement':
+          // skip dead branches
+          if (isFalsy(node.test)) {
+            skippedNodes.add(node.consequent);
+          } else if (node.alternate && isTruthy(node.test)) {
+            skippedNodes.add(node.alternate);
+          }
+          return;
+        case 'Identifier': {
+          const { name } = node;
+          if (!(isReference__default['default'](node, parent) && !scope.contains(name))) return;
+          switch (name) {
+            case 'require':
+              if (isNodeRequirePropertyAccess(parent)) return;
+
+              if (isDynamicRequireModulesEnabled && isRequireStatement(parent, scope)) {
+                magicString.appendLeft(
+                  parent.end - 1,
+                  `,${JSON.stringify(
+                    path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+                  )}`
+                );
+              }
 
-    if (isProxyModule) {
-      importee = getIdFromProxyId(importee);
-    } else if (importee.startsWith('\0')) {
-      if (importee === HELPERS_ID || importee === DYNAMIC_PACKAGES_ID || importee.startsWith(DYNAMIC_JSON_PREFIX)) {
-        return importee;
+              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+                storeName: true
+              });
+              uses.commonjsHelpers = true;
+              return;
+            case 'module':
+            case 'exports':
+              shouldWrap = true;
+              uses[name] = true;
+              return;
+            case 'global':
+              uses.global = true;
+              if (!ignoreGlobal) {
+                magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
+                  storeName: true
+                });
+                uses.commonjsHelpers = true;
+              }
+              return;
+            case 'define':
+              magicString.overwrite(node.start, node.end, 'undefined', { storeName: true });
+              return;
+            default:
+              globals.add(name);
+              return;
+          }
+        }
+        case 'MemberExpression':
+          if (!isDynamicRequireModulesEnabled && isModuleRequire(node, scope)) {
+            magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+              storeName: true
+            });
+            uses.commonjsHelpers = true;
+            skippedNodes.add(node.object);
+            skippedNodes.add(node.property);
+          }
+          return;
+        case 'ReturnStatement':
+          // if top-level return, we need to wrap it
+          if (lexicalDepth === 0) {
+            shouldWrap = true;
+          }
+          return;
+        case 'ThisExpression':
+          // rewrite top-level `this` as `commonjsHelpers.commonjsGlobal`
+          if (lexicalDepth === 0) {
+            uses.global = true;
+            if (!ignoreGlobal) {
+              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
+                storeName: true
+              });
+              uses.commonjsHelpers = true;
+            }
+          }
+          return;
+        case 'UnaryExpression':
+          // rewrite `typeof module`, `typeof module.exports` and `typeof exports` (https://github.com/rollup/rollup-plugin-commonjs/issues/151)
+          if (node.operator === 'typeof') {
+            const flattened = getKeypath(node.argument);
+            if (!flattened) return;
+
+            if (scope.contains(flattened.name)) return;
+
+            if (
+              flattened.keypath === 'module.exports' ||
+              flattened.keypath === 'module' ||
+              flattened.keypath === 'exports'
+            ) {
+              magicString.overwrite(node.start, node.end, `'object'`, { storeName: false });
+            }
+          }
+          return;
+        case 'VariableDeclaration':
+          if (!scope.parent) {
+            topLevelDeclarations.push(node);
+          }
       }
+    },
 
-      return null;
+    leave(node) {
+      programDepth -= 1;
+      if (node.scope) scope = scope.parent;
+      if (functionType.test(node.type)) lexicalDepth -= 1;
     }
+  });
 
-    if (importee.startsWith(DYNAMIC_JSON_PREFIX)) {
-      return importee;
+  let isRestorableCompiledEsm = false;
+  if (defineCompiledEsmExpressions.length > 0) {
+    if (!shouldWrap && defineCompiledEsmExpressions.length === 1) {
+      isRestorableCompiledEsm = true;
+      magicString.remove(
+        defineCompiledEsmExpressions[0].start,
+        defineCompiledEsmExpressions[0].end
+      );
+    } else {
+      shouldWrap = true;
+      uses.exports = true;
     }
+  }
 
-    if (importer && importer.endsWith(PROXY_SUFFIX)) {
-      importer = getIdFromProxyId(importer);
-    }
+  // We cannot wrap ES/mixed modules
+  shouldWrap = shouldWrap && !disableWrap && !isEsModule;
+  uses.commonjsHelpers = uses.commonjsHelpers || shouldWrap;
+
+  if (
+    !(
+      requiredSources.length ||
+      dynamicRegisterSources.size ||
+      uses.module ||
+      uses.exports ||
+      uses.require ||
+      uses.commonjsHelpers
+    ) &&
+    (ignoreGlobal || !uses.global)
+  ) {
+    return { meta: { commonjs: { isCommonJS: false } } };
+  }
 
-    return this.resolve(importee, importer, {
-      skipSelf: true
-    }).then(resolved => {
-      if (!resolved) {
-        resolved = resolveExtensions(importee, importer);
-      }
+  const moduleName = deconflict(scope, globals, getName(id));
 
-      if (isProxyModule) {
-        if (!resolved) {
-          return {
-            id: getExternalProxyId(importee),
-            external: false
-          };
-        }
+  let leadingComment = '';
+  if (code.startsWith('/*')) {
+    const commentEnd = code.indexOf('*/', 2) + 2;
+    leadingComment = `${code.slice(0, commentEnd)}\n`;
+    magicString.remove(0, commentEnd).trim();
+  }
 
-        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
-        resolved.external = false;
-        return resolved;
-      }
+  const exportBlock = isEsModule
+    ? ''
+    : rewriteExportsAndGetExportsBlock(
+        magicString,
+        moduleName,
+        shouldWrap,
+        topLevelModuleExportsAssignments,
+        topLevelExportsAssignmentsByName,
+        defineCompiledEsmExpressions,
+        (name) => deconflict(scope, globals, name),
+        isRestorableCompiledEsm,
+        code,
+        uses,
+        HELPERS_NAME
+      );
+
+  const importBlock = rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    topLevelRequireDeclarators,
+    reassignedNames,
+    uses.commonjsHelpers && HELPERS_NAME,
+    dynamicRegisterSources
+  );
 
-      return resolved;
-    });
+  if (shouldWrap) {
+    wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath);
   }
 
-  return resolveId;
+  magicString
+    .trim()
+    .prepend(leadingComment + importBlock)
+    .append(exportBlock);
+
+  return {
+    code: magicString.toString(),
+    map: sourceMap ? magicString.generateMap() : null,
+    syntheticNamedExports: isEsModule ? false : '__moduleExports',
+    meta: { commonjs: { isCommonJS: !isEsModule } }
+  };
 }
 
 function commonjs(options = {}) {
   const extensions = options.extensions || ['.js'];
   const filter = pluginutils.createFilter(options.include, options.exclude);
-  const ignoreGlobal = options.ignoreGlobal;
-
-  const _getDynamicRequirePat = getDynamicRequirePaths(options.dynamicRequireTargets),
-        dynamicRequireModuleSet = _getDynamicRequirePat.dynamicRequireModuleSet,
-        dynamicRequireModuleDirPaths = _getDynamicRequirePat.dynamicRequireModuleDirPaths;
-
+  const {
+    ignoreGlobal,
+    requireReturnsDefault: requireReturnsDefaultOption,
+    esmExternals
+  } = options;
+  const getRequireReturnsDefault =
+    typeof requireReturnsDefaultOption === 'function'
+      ? requireReturnsDefaultOption
+      : () => requireReturnsDefaultOption;
+  let esmExternalIds;
+  const isEsmExternal =
+    typeof esmExternals === 'function'
+      ? esmExternals
+      : Array.isArray(esmExternals)
+      ? ((esmExternalIds = new Set(esmExternals)), (id) => esmExternalIds.has(id))
+      : () => esmExternals;
+
+  const { dynamicRequireModuleSet, dynamicRequireModuleDirPaths } = getDynamicRequirePaths(
+    options.dynamicRequireTargets
+  );
   const isDynamicRequireModulesEnabled = dynamicRequireModuleSet.size > 0;
-  const commonDir = isDynamicRequireModulesEnabled ? getCommonDir(null, Array.from(dynamicRequireModuleSet).concat(process.cwd())) : null;
-  const esModulesWithoutDefaultExport = new Set();
+  const commonDir = isDynamicRequireModulesEnabled
+    ? getCommonDir__default['default'](null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
+    : null;
+
   const esModulesWithDefaultExport = new Set();
-  const ignoreRequire = typeof options.ignore === 'function' ? options.ignore : Array.isArray(options.ignore) ? id => options.ignore.includes(id) : () => false;
-  const resolveId = getResolveId(extensions);
-  const sourceMap = options.sourceMap !== false;
+  const esModulesWithNamedExports = new Set();
 
-  function transformAndCheckExports(code, id) {
-    const _checkEsModule = checkEsModule(this.parse, code, id),
-          isEsModule = _checkEsModule.isEsModule,
-          hasDefaultExport = _checkEsModule.hasDefaultExport,
-          ast = _checkEsModule.ast;
+  const ignoreRequire =
+    typeof options.ignore === 'function'
+      ? options.ignore
+      : Array.isArray(options.ignore)
+      ? (id) => options.ignore.includes(id)
+      : () => false;
 
-    const isDynamicRequireModule = dynamicRequireModuleSet.has(normalizePathSlashes(id));
+  const resolveId = getResolveId(extensions);
 
-    if (isEsModule && (!isDynamicRequireModule || !options.transformMixedEsModules)) {
-      (hasDefaultExport ? esModulesWithDefaultExport : esModulesWithoutDefaultExport).add(id);
+  const sourceMap = options.sourceMap !== false;
 
-      if (!options.transformMixedEsModules) {
-        setIsCjsPromise(id, false);
-        return null;
-      }
-    } // it is not an ES module AND it does not have CJS-specific elements.
-    else if (!hasCjsKeywords(code, ignoreGlobal)) {
-        esModulesWithoutDefaultExport.add(id);
-        setIsCjsPromise(id, false);
-        return null;
-      }
+  function transformAndCheckExports(code, id) {
+    if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
+      code =
+        getDynamicPackagesEntryIntro(dynamicRequireModuleDirPaths, dynamicRequireModuleSet) + code;
+    }
 
-    const moduleInfo = this.getModuleInfo(id);
-    const transformed = transformCommonjs(this.parse, code, id, moduleInfo.isEntry, moduleInfo.importers && moduleInfo.importers.length > 0, isEsModule, ignoreGlobal || isEsModule, ignoreRequire, sourceMap, isDynamicRequireModulesEnabled, dynamicRequireModuleSet, commonDir, ast);
-    setIsCjsPromise(id, isEsModule ? false : Boolean(transformed));
+    const { isEsModule, hasDefaultExport, hasNamedExports, ast } = analyzeTopLevelStatements(
+      this.parse,
+      code,
+      id
+    );
+    if (hasDefaultExport) {
+      esModulesWithDefaultExport.add(id);
+    }
+    if (hasNamedExports) {
+      esModulesWithNamedExports.add(id);
+    }
 
-    if (!transformed) {
-      if (!isEsModule || isDynamicRequireModule) esModulesWithoutDefaultExport.add(id);
-      return null;
+    if (
+      !dynamicRequireModuleSet.has(normalizePathSlashes(id)) &&
+      (!hasCjsKeywords(code, ignoreGlobal) || (isEsModule && !options.transformMixedEsModules))
+    ) {
+      return { meta: { commonjs: { isCommonJS: false } } };
     }
 
-    return transformed;
+    // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
+    const disableWrap = isModuleRegistrationProxy(id, dynamicRequireModuleSet);
+
+    return transformCommonjs(
+      this.parse,
+      code,
+      id,
+      isEsModule,
+      ignoreGlobal || isEsModule,
+      ignoreRequire,
+      sourceMap,
+      isDynamicRequireModulesEnabled,
+      dynamicRequireModuleSet,
+      disableWrap,
+      commonDir,
+      ast
+    );
   }
 
   return {
     name: 'commonjs',
 
     buildStart() {
+      validateRollupVersion(this.meta.rollupVersion, peerDependencies.rollup);
       if (options.namedExports != null) {
-        this.warn('The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.');
-      }
-
-      const _this$meta$rollupVers = this.meta.rollupVersion.split('.').map(Number),
-            _this$meta$rollupVers2 = _slicedToArray(_this$meta$rollupVers, 2),
-            major = _this$meta$rollupVers2[0],
-            minor = _this$meta$rollupVers2[1];
-
-      const minVersion = peerDependencies.rollup.slice(2);
-
-      const _minVersion$split$map = minVersion.split('.').map(Number),
-            _minVersion$split$map2 = _slicedToArray(_minVersion$split$map, 2),
-            minMajor = _minVersion$split$map2[0],
-            minMinor = _minVersion$split$map2[1];
-
-      if (major < minMajor || major === minMajor && minor < minMinor) {
-        this.error(`Insufficient Rollup version: "@rollup/plugin-commonjs" requires at least rollup@${minVersion} but found rollup@${this.meta.rollupVersion}.`);
+        this.warn(
+          'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
+        );
       }
     },
 
@@ -1235,136 +1513,74 @@ function commonjs(options = {}) {
 
     load(id) {
       if (id === HELPERS_ID) {
-        let code = HELPERS; // Do not bloat everyone's code with the module manager code
-
-        if (isDynamicRequireModulesEnabled) code += HELPERS_DYNAMIC;else code += HELPER_NON_DYNAMIC;
-        return code;
-      } // generate proxy modules
-
-
-      if (id.endsWith(EXTERNAL_SUFFIX)) {
-        const actualId = getIdFromExternalProxyId(id);
-        const name = getName(actualId);
-        if (actualId === HELPERS_ID || actualId === DYNAMIC_PACKAGES_ID) // These do not export default
-          return `import * as ${name} from ${JSON.stringify(actualId)}; export default ${name};`;
-        return `import ${name} from ${JSON.stringify(actualId)}; export default ${name};`;
+        return getHelpersModule(isDynamicRequireModulesEnabled);
       }
 
-      if (id === DYNAMIC_PACKAGES_ID) {
-        let code = `const { commonjsRegister } = require('${HELPERS_ID}');`;
-
-        var _iterator = _createForOfIteratorHelper(dynamicRequireModuleDirPaths),
-            _step;
-
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            const dir = _step.value;
-            let entryPoint = 'index.js';
-
-            try {
-              if (fs.existsSync(path.join(dir, 'package.json'))) {
-                entryPoint = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), {
-                  encoding: 'utf8'
-                })).main || entryPoint;
-              }
-            } catch (ignored) {// ignored
-            }
-
-            code += `\ncommonjsRegister(${JSON.stringify(getVirtualPathForDynamicRequirePath(dir, commonDir))}, function (module, exports) {
-  module.exports = require(${JSON.stringify(normalizePathSlashes(path.join(dir, entryPoint)))});
-});`;
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-
-        return code;
+      if (id.startsWith(HELPERS_ID)) {
+        return getSpecificHelperProxy(id);
       }
 
-      let actualId = id;
-      const isDynamicJson = actualId.startsWith(DYNAMIC_JSON_PREFIX);
-
-      if (isDynamicJson) {
-        actualId = actualId.slice(DYNAMIC_JSON_PREFIX.length);
+      if (isWrappedId(id, EXTERNAL_SUFFIX)) {
+        const actualId = unwrapId(id, EXTERNAL_SUFFIX);
+        return getUnknownRequireProxy(
+          actualId,
+          isEsmExternal(actualId) ? getRequireReturnsDefault(actualId) : true
+        );
       }
 
-      const normalizedPath = normalizePathSlashes(actualId);
-
-      if (isDynamicJson) {
-        return `require('${HELPERS_ID}').commonjsRegister(${JSON.stringify(getVirtualPathForDynamicRequirePath(normalizedPath, commonDir))}, function (module, exports) {
-  module.exports = require(${JSON.stringify(normalizedPath)});
-});`;
+      if (id === DYNAMIC_PACKAGES_ID) {
+        return getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir);
       }
 
-      if (dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json')) {
-        // Try our best to still export the module fully.
-        // The commonjs polyfill should take care of circular references.
-        return `require('${HELPERS_ID}').commonjsRegister(${JSON.stringify(getVirtualPathForDynamicRequirePath(normalizedPath, commonDir))}, function (module, exports) {
-  ${fs.readFileSync(normalizedPath, {
-          encoding: 'utf8'
-        })}
-});`;
+      if (id.startsWith(DYNAMIC_JSON_PREFIX)) {
+        return getDynamicJsonProxy(id, commonDir);
       }
 
-      if (actualId.endsWith(PROXY_SUFFIX)) {
-        actualId = getIdFromProxyId(actualId);
-        const name = getName(actualId);
-        return getIsCjsPromise(actualId).then(isCjs => {
-          if (dynamicRequireModuleSet.has(normalizePathSlashes(actualId)) && !actualId.endsWith('.json')) return `import {commonjsRequire} from '${HELPERS_ID}'; const ${name} = commonjsRequire(${JSON.stringify(getVirtualPathForDynamicRequirePath(normalizePathSlashes(actualId), commonDir))}); export default (${name} && ${name}['default']) || ${name}`;else if (isCjs) return `import { __moduleExports } from ${JSON.stringify(actualId)}; export default __moduleExports;`;else if (esModulesWithoutDefaultExport.has(actualId)) return `import * as ${name} from ${JSON.stringify(actualId)}; export default ${name};`;else if (esModulesWithDefaultExport.has(actualId)) {
-            return `export {default} from ${JSON.stringify(actualId)};`;
-          }
-          return `import * as ${name} from ${JSON.stringify(actualId)}; import {getCjsExportFromNamespace} from "${HELPERS_ID}"; export default getCjsExportFromNamespace(${name})`;
-        });
+      if (isModuleRegistrationProxy(id, dynamicRequireModuleSet)) {
+        return getDynamicRequireProxy(normalizePathSlashes(id), commonDir);
       }
 
-      if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
-        let code;
-
-        try {
-          code = fs.readFileSync(actualId, {
-            encoding: 'utf8'
-          });
-        } catch (ex) {
-          this.warn(`Failed to read file ${actualId}, dynamic modules might not work correctly`);
-          return null;
-        }
-
-        let dynamicImports = Array.from(dynamicRequireModuleSet).map(dynamicId => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`).join('\n');
-
-        if (dynamicRequireModuleDirPaths.length) {
-          dynamicImports += `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID)});`;
-        }
-
-        code = `${dynamicImports}\n${code}`;
-        return code;
+      if (isWrappedId(id, PROXY_SUFFIX)) {
+        const actualId = unwrapId(id, PROXY_SUFFIX);
+        return getStaticRequireProxy(
+          actualId,
+          getRequireReturnsDefault(actualId),
+          esModulesWithDefaultExport,
+          esModulesWithNamedExports
+        );
       }
 
       return null;
     },
 
     transform(code, id) {
-      if (id !== DYNAMIC_PACKAGES_ID && !id.startsWith(DYNAMIC_JSON_PREFIX)) {
-        if (!filter(id) || extensions.indexOf(path.extname(id)) === -1) {
-          setIsCjsPromise(id, null);
-          return null;
-        }
+      const extName = path.extname(id);
+      if (
+        extName !== '.cjs' &&
+        id !== DYNAMIC_PACKAGES_ID &&
+        !id.startsWith(DYNAMIC_JSON_PREFIX) &&
+        (!filter(id) || !extensions.includes(extName))
+      ) {
+        return null;
       }
 
-      let transformed;
-
       try {
-        transformed = transformAndCheckExports.call(this, code, id);
+        return transformAndCheckExports.call(this, code, id);
       } catch (err) {
-        transformed = null;
-        setIsCjsPromise(id, false);
-        this.error(err, err.loc);
+        return this.error(err, err.loc);
       }
+    },
 
-      return transformed;
+    moduleParsed({ id, meta: { commonjs } }) {
+      if (commonjs) {
+        const isCjs = commonjs.isCommonJS;
+        if (isCjs != null) {
+          setIsCjsPromise(id, isCjs);
+          return;
+        }
+      }
+      setIsCjsPromise(id, null);
     }
-
   };
 }