@rollup/plugin-commonjs 11.0.2 → 11.1.0

package/dist/index.js

@@ -6,9 +6,11 @@ var fs = require('fs');
 var path = require('path');
 var resolve = require('resolve');
 var pluginutils = require('@rollup/pluginutils');
+var glob = _interopDefault(require('glob'));
 var estreeWalker = require('estree-walker');
 var MagicString = _interopDefault(require('magic-string'));
 var isReference = _interopDefault(require('is-reference'));
+var getCommonDir = _interopDefault(require('commondir'));
 
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
@@ -52,144 +54,6 @@ function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance");
 }
 
-var peerDependencies = {
-	rollup: "^1.20.0"
-};
-
-const PROXY_SUFFIX = '?commonjs-proxy';
-const getProxyId = id => `\0${id}${PROXY_SUFFIX}`;
-const getIdFromProxyId = proxyId => proxyId.slice(1, -PROXY_SUFFIX.length);
-const EXTERNAL_SUFFIX = '?commonjs-external';
-const getExternalProxyId = id => `\0${id}${EXTERNAL_SUFFIX}`;
-const getIdFromExternalProxyId = proxyId => proxyId.slice(1, -EXTERNAL_SUFFIX.length);
-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.
-
-const HELPERS = `
-export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-export function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-export function unwrapExports (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-export function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
-}
-
-export function getCjsExportFromNamespace (n) {
-	return n && n['default'] || n;
-}`;
-
-/* 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);
-
-  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 */
-
-function getCandidatesForExtension(resolved, extension) {
-  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
-}
-
-function getCandidates(resolved, extensions) {
-  return extensions.reduce((paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)), [resolved]);
-}
-
-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 */
-      }
-    }
-
-    return undefined;
-  }
-
-  function resolveId(importee, importer) {
-    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
-
-    if (isProxyModule) {
-      importee = getIdFromProxyId(importee);
-    } else if (importee.startsWith('\0')) {
-      if (importee === HELPERS_ID) {
-        return importee;
-      }
-
-      return null;
-    }
-
-    if (importer && importer.endsWith(PROXY_SUFFIX)) {
-      importer = getIdFromProxyId(importer);
-    }
-
-    return this.resolve(importee, importer, {
-      skipSelf: true
-    }).then(resolved => {
-      if (!resolved) {
-        resolved = resolveExtensions(importee, importer);
-      }
-
-      if (isProxyModule) {
-        if (!resolved) {
-          return {
-            id: getExternalProxyId(importee),
-            external: false
-          };
-        }
-
-        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
-        resolved.external = false;
-        return resolved;
-      }
-
-      return resolved;
-    });
-  }
-
-  return resolveId;
-}
-
 /* eslint-disable no-undefined */
 const operators = {
   '==': x => equals(x.left, x.right, false),
@@ -241,6 +105,157 @@ function equals(a, b, strict) {
   return undefined;
 }
 
+const PROXY_SUFFIX = '?commonjs-proxy';
+const getProxyId = id => `\0${id}${PROXY_SUFFIX}`;
+const getIdFromProxyId = proxyId => proxyId.slice(1, -PROXY_SUFFIX.length);
+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.
+// Minifiers like uglify will usually transpile it back if compatibility with ES3 is not enabled.
+
+const HELPERS = `
+export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+export function getCjsExportFromNamespace (n) {
+	return n && n['default'] || n;
+}
+`;
+const HELPER_NON_DYNAMIC = `
+export function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+`;
+const HELPERS_DYNAMIC = `
+export function commonjsRegister (path, loader) {
+	DYNAMIC_REQUIRE_LOADERS[path] = loader;
+}
+
+const DYNAMIC_REQUIRE_LOADERS = Object.create(null);
+const DYNAMIC_REQUIRE_CACHE = Object.create(null);
+const DEFAULT_PARENT_MODULE = {
+	id: '<' + 'rollup>', exports: {}, parent: undefined, filename: null, loaded: false, children: [], paths: []
+};
+const CHECKED_EXTENSIONS = ['', '.js', '.json'];
+
+function normalize (path) {
+	path = path.replace(/\\\\/g, '/');
+	const parts = path.split('/');
+	const slashed = parts[0] === '';
+	for (let i = 1; i < parts.length; i++) {
+		if (parts[i] === '.' || parts[i] === '') {
+			parts.splice(i--, 1);
+		}
+	}
+	for (let i = 1; i < parts.length; i++) {
+		if (parts[i] !== '..') continue;
+		if (i > 0 && parts[i - 1] !== '..' && parts[i - 1] !== '.') {
+			parts.splice(--i, 2);
+			i--;
+		}
+	}
+	path = parts.join('/');
+	if (slashed && path[0] !== '/')
+	  path = '/' + path;
+	else if (path.length === 0)
+	  path = '.';
+	return path;
+}
+
+function join () {
+	if (arguments.length === 0)
+	  return '.';
+	let joined;
+	for (let i = 0; i < arguments.length; ++i) {
+	  let arg = arguments[i];
+	  if (arg.length > 0) {
+		if (joined === undefined)
+		  joined = arg;
+		else
+		  joined += '/' + arg;
+	  }
+	}
+	if (joined === undefined)
+	  return '.';
+  
+	return joined;
+}
+
+function isPossibleNodeModulesPath (modulePath) {
+	let c0 = modulePath[0];
+	if (c0 === '/' || c0 === '\\\\') return false;
+	let c1 = modulePath[1], c2 = modulePath[2];
+	if ((c0 === '.' && (!c1 || c1 === '/' || c1 === '\\\\')) ||
+		(c0 === '.' && c1 === '.' && (!c2 || c2 === '/' || c2 === '\\\\'))) return false;
+	if (c1 === ':' && (c2 === '/' || c2 === '\\\\'))
+		return false;
+	return true;
+}
+
+export function commonjsRequire (path, originalModuleDir) {
+	const shouldTryNodeModules = isPossibleNodeModulesPath(path);
+	path = normalize(path);
+	let relPath;
+	while (true) {
+		if (!shouldTryNodeModules) {
+			relPath = originalModuleDir ? normalize(originalModuleDir + '/' + path) : path;
+		} else if (originalModuleDir) {
+			relPath = normalize(originalModuleDir + '/node_modules/' + path);
+		} else {
+			relPath = normalize(join('node_modules', path));
+		}
+		for (let extensionIndex = 0; extensionIndex < CHECKED_EXTENSIONS.length; extensionIndex++) {
+			const resolvedPath = relPath + CHECKED_EXTENSIONS[extensionIndex];
+			let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
+			if (cachedModule) return cachedModule.exports;
+			const loader = DYNAMIC_REQUIRE_LOADERS[resolvedPath];
+			if (loader) {
+				DYNAMIC_REQUIRE_CACHE[resolvedPath] = cachedModule = {
+					id: resolvedPath,
+					filename: resolvedPath,
+					exports: {},
+					parent: DEFAULT_PARENT_MODULE,
+					loaded: false,
+					children: [],
+					paths: []
+				};
+				try {
+					loader.call(commonjsGlobal, cachedModule, cachedModule.exports);
+				} catch (error) {
+					delete DYNAMIC_REQUIRE_CACHE[resolvedPath];
+					throw error;
+				}
+				cachedModule.loaded = true;
+				return cachedModule.exports;
+			};
+		}
+		if (!shouldTryNodeModules) break;
+		const nextDir = normalize(originalModuleDir + '/..');
+		if (nextDir === originalModuleDir) break;
+		originalModuleDir = nextDir;
+	}
+	return require(path);
+}
+
+commonjsRequire.cache = DYNAMIC_REQUIRE_CACHE;
+`;
+
 /* eslint-disable import/prefer-default-export */
 function getName(id) {
   const name = pluginutils.makeLegalIdentifier(path.basename(id, path.extname(id)));
@@ -266,7 +281,7 @@ const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionEx
 
 function deconflict(scope, globals, identifier) {
   let i = 1;
-  let deconflicted = identifier;
+  let deconflicted = pluginutils.makeLegalIdentifier(identifier);
 
   while (scope.contains(deconflicted) || globals.has(deconflicted) || deconflicted in blacklist) {
     deconflicted = `${identifier}_${i}`;
@@ -288,6 +303,9 @@ function tryParse(parse, code, id) {
   }
 }
 
+function normalizePathSlashes(path) {
+  return path.replace(/\\/g, '/');
+}
 function hasCjsKeywords(code, ignoreGlobal) {
   const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
   return firstpass.test(code);
@@ -363,7 +381,26 @@ function checkEsModule(parse, code, id) {
     ast
   };
 }
-function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire, customNamedExports, sourceMap, allowDynamicRequire, astCache) {
+
+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];
+
+  if (target.type !== 'Identifier' || target.name !== targetName) return; // eslint-disable-next-line consistent-return
+
+  return val.value;
+}
+
+function transformCommonjs(parse, code, id, isEntry, isEsModule, ignoreGlobal, ignoreRequire, customNamedExports, 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,
@@ -386,6 +423,7 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
   const namedExports = {}; // TODO handle transpiled modules
 
   let shouldWrap = /__esModule/.test(code);
+  let usesDynamicHelpers = false;
 
   function isRequireStatement(node) {
     if (!node) return false;
@@ -403,19 +441,30 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
   function isStaticRequireStatement(node) {
     if (!isRequireStatement(node)) return false;
     if (hasDynamicArguments(node)) return false;
-    if (ignoreRequire(node.arguments[0].value)) return false;
     return true;
   }
 
+  function isIgnoredRequireStatement(requiredNode) {
+    return ignoreRequire(requiredNode.arguments[0].value);
+  }
+
   function getRequireStringArg(node) {
     return node.arguments[0].type === 'Literal' ? node.arguments[0].value : node.arguments[0].quasis[0].value.cooked;
   }
 
   function getRequired(node, name) {
-    const sourceId = getRequireStringArg(node);
+    let sourceId = getRequireStringArg(node);
+    const isDynamicRegister = sourceId.startsWith(DYNAMIC_REGISTER_PREFIX);
+
+    if (isDynamicRegister) {
+      sourceId = sourceId.substr(DYNAMIC_REGISTER_PREFIX.length);
+    }
+
     const existing = required[sourceId]; // eslint-disable-next-line no-undefined
 
     if (existing === undefined) {
+      const isDynamic = hasDynamicModuleForPath(sourceId);
+
       if (!name) {
         do {
           name = `require$$${uid}`;
@@ -423,15 +472,58 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
         } while (scope.contains(name));
       }
 
-      sources.push(sourceId);
+      if (isDynamicRegister && sourceId.endsWith('.json')) {
+        sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+      }
+
+      if (isDynamicRegister || !isDynamic || sourceId.endsWith('.json')) {
+        sources.push([sourceId, !isDynamicRegister]);
+      }
+
       required[sourceId] = {
         source: sourceId,
         name,
-        importsDefault: false
+        importsDefault: false,
+        isDynamic
       };
     }
 
     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;
+      }
+
+      return false;
+    }
+
+    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 false;
+  }
+
+  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)
@@ -513,10 +605,20 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
         if (isReference(node, parent) && !scope.contains(node.name)) {
           if (node.name in uses) {
             if (node.name === 'require') {
-              if (allowDynamicRequire) return;
+              if (!isDynamicRequireModulesEnabled && isStaticRequireStatement(parent)) {
+                return;
+              }
+
+              if (isDynamicRequireModulesEnabled && isRequireStatement(parent)) {
+                magicString.appendLeft(parent.end - 1, ',' + JSON.stringify(path.dirname(id) === '.' ? null
+                /* default behavior */
+                : getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir)));
+              }
+
               magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
                 storeName: true
               });
+              usesDynamicHelpers = true;
             }
 
             uses[node.name] = true;
@@ -571,10 +673,12 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
 
         if (match[1]) namedExports[match[1]] = true;
         return;
-      } // if this is `var x = require('x')`, we can do `import x from 'x'`
+      }
 
+      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'`
 
-      if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier' && isStaticRequireStatement(node.init)) {
+      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
 
@@ -582,12 +686,15 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
         const required = getRequired(node.init, node.id.name);
         required.importsDefault = true;
 
-        if (required.name === node.id.name) {
+        if (required.name === node.id.name && !required.isDynamic) {
           node._shouldRemove = true;
         }
       }
 
-      if (!isStaticRequireStatement(node)) return;
+      if (!isStaticRequireStatement(node) || isIgnoredRequireStatement(node)) {
+        return;
+      }
+
       const required = getRequired(node);
 
       if (parent.type === 'ExpressionStatement') {
@@ -595,7 +702,15 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
         magicString.remove(parent.start, parent.end);
       } else {
         required.importsDefault = true;
-        magicString.overwrite(node.start, node.end, required.name);
+
+        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))})`);
+          usesDynamicHelpers = true;
+        } else {
+          magicString.overwrite(node.start, node.end, required.name);
+        }
       }
 
       node.callee._skip = true;
@@ -642,10 +757,10 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
     return null;
   }
 
-  const includeHelpers = shouldWrap || uses.global || uses.require;
-  const importBlock = `${(includeHelpers ? [`import * as ${HELPERS_NAME} from '${HELPERS_ID}';`] : []).concat(sources.map(source => // import the actual module before the proxy, so that we know
+  const includeHelpers = usesDynamicHelpers || shouldWrap || uses.global || uses.require;
+  const importBlock = `${(includeHelpers ? [`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.map(source => {
+  `import '${source}';`), sources.filter(([, importProxy]) => importProxy).map(([source]) => {
     const _required$source = required[source],
           name = _required$source.name,
           importsDefault = _required$source.importsDefault;
@@ -656,7 +771,7 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
   let wrapperEnd = '';
   const moduleName = deconflict(scope, globals, getName(id));
 
-  if (!isEntry) {
+  if (!isEntry && !isEsModule) {
     const exportModuleExports = {
       str: `export { ${moduleName} as __moduleExports };`,
       name: '__moduleExports'
@@ -685,43 +800,71 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
     wrapperEnd = `\n});`;
   } else {
     const names = [];
-    ast.body.forEach(node => {
-      if (node.type === 'ExpressionStatement' && node.expression.type === 'AssignmentExpression') {
-        const left = node.expression.left;
-        const flattened = flatten(left);
-        if (!flattened) return;
-        const match = exportsPattern.exec(flattened.keypath);
-        if (!match) return;
+    var _iteratorNormalCompletion3 = true;
+    var _didIteratorError3 = false;
+    var _iteratorError3 = undefined;
 
-        if (flattened.keypath === 'module.exports') {
-          hasDefaultExport = true;
-          magicString.overwrite(left.start, left.end, `var ${moduleName}`);
-        } else {
-          const _match = _slicedToArray(match, 2),
-                name = _match[1];
+    try {
+      for (var _iterator3 = ast.body[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        const node = _step3.value;
 
-          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} };`;
+        if (node.type === 'ExpressionStatement' && node.expression.type === 'AssignmentExpression') {
+          const left = node.expression.left;
+          const flattened = flatten(left);
 
-          if (name !== 'default') {
-            namedExportDeclarations.push({
-              str: declaration,
-              name
-            });
-            delete namedExports[name];
+          if (!flattened) {
+            continue;
           }
 
-          defaultExportPropertyAssignments.push(`${moduleName}.${name} = ${deconflicted};`);
+          const match = exportsPattern.exec(flattened.keypath);
+
+          if (!match) {
+            continue;
+          }
+
+          if (flattened.keypath === 'module.exports') {
+            hasDefaultExport = true;
+            magicString.overwrite(left.start, left.end, `var ${moduleName}`);
+          } else {
+            const _match = _slicedToArray(match, 2),
+                  name = _match[1];
+
+            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} };`;
+
+            if (name !== 'default') {
+              namedExportDeclarations.push({
+                str: declaration,
+                name
+              });
+              delete namedExports[name];
+            }
+
+            defaultExportPropertyAssignments.push(`${moduleName}.${name} = ${deconflicted};`);
+          }
         }
       }
-    });
+    } catch (err) {
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+          _iterator3.return();
+        }
+      } finally {
+        if (_didIteratorError3) {
+          throw _iteratorError3;
+        }
+      }
+    }
 
-    if (!hasDefaultExport && (names.length || !isEntry)) {
+    if (!hasDefaultExport && (names.length || !isEntry && !isEsModule)) {
       wrapperEnd = `\n\nvar ${moduleName} = {\n${names.map(({
         name,
         deconflicted
@@ -732,10 +875,10 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
   Object.keys(namedExports).filter(key => !blacklist[key]).forEach(addExport);
   const defaultExport = /__esModule/.test(code) ? `export default ${HELPERS_NAME}.unwrapExports(${moduleName});` : `export default ${moduleName};`;
   const named = namedExportDeclarations.filter(x => x.name !== 'default' || !hasDefaultExport).map(x => x.str);
-  const exportBlock = `\n\n${[defaultExport].concat(named).concat(hasDefaultExport ? defaultExportPropertyAssignments : []).join('\n')}`;
+  const exportBlock = `\n\n${(isEsModule ? [] : [defaultExport]).concat(named).concat(hasDefaultExport ? defaultExportPropertyAssignments : []).join('\n')}`;
   magicString.trim().prepend(importBlock + wrapperStart).trim().append(wrapperEnd);
 
-  if (hasDefaultExport || named.length > 0 || shouldWrap || !isEntry) {
+  if (hasDefaultExport || named.length > 0 || shouldWrap || !isEntry && !isEsModule) {
     magicString.append(exportBlock);
   }
 
@@ -747,10 +890,195 @@ function transformCommonjs(parse, code, id, isEntry, ignoreGlobal, ignoreRequire
   };
 }
 
+function getDynamicRequirePaths(patterns) {
+  const dynamicRequireModuleSet = new Set();
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = (!patterns || Array.isArray(patterns) ? patterns || [] : [patterns])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      const pattern = _step.value;
+      const isNegated = pattern.startsWith('!');
+      const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = glob.sync(isNegated ? pattern.substr(1) : pattern)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          const path$1 = _step2.value;
+          modifySet(normalizePathSlashes(path.resolve(path$1)));
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  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
+  };
+}
+
+var peerDependencies = {
+	rollup: "^1.20.0||^2.0.0"
+};
+
+/* 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);
+
+  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 */
+
+function getCandidatesForExtension(resolved, extension) {
+  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
+}
+
+function getCandidates(resolved, extensions) {
+  return extensions.reduce((paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)), [resolved]);
+}
+
+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 */
+      }
+    }
+
+    return undefined;
+  }
+
+  function resolveId(importee, importer) {
+    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
+
+    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;
+      }
+
+      return null;
+    }
+
+    if (importee.startsWith(DYNAMIC_JSON_PREFIX)) {
+      return importee;
+    }
+
+    if (importer && importer.endsWith(PROXY_SUFFIX)) {
+      importer = getIdFromProxyId(importer);
+    }
+
+    return this.resolve(importee, importer, {
+      skipSelf: true
+    }).then(resolved => {
+      if (!resolved) {
+        resolved = resolveExtensions(importee, importer);
+      }
+
+      if (isProxyModule) {
+        if (!resolved) {
+          return {
+            id: getExternalProxyId(importee),
+            external: false
+          };
+        }
+
+        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
+        resolved.external = false;
+        return resolved;
+      }
+
+      return resolved;
+    });
+  }
+
+  return resolveId;
+}
+
 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 isDynamicRequireModulesEnabled = dynamicRequireModuleSet.size > 0;
+  const commonDir = isDynamicRequireModulesEnabled ? getCommonDir(null, Array.from(dynamicRequireModuleSet).concat(process.cwd())) : null;
   const customNamedExports = {};
 
   if (options.namedExports) {
@@ -790,9 +1118,7 @@ function commonjs(options = {}) {
   }
 
   const esModulesWithoutDefaultExport = new Set();
-  const esModulesWithDefaultExport = new Set(); // TODO maybe this should be configurable?
-
-  const allowDynamicRequire = !!options.ignore;
+  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;
@@ -803,22 +1129,23 @@ function commonjs(options = {}) {
           hasDefaultExport = _checkEsModule.hasDefaultExport,
           ast = _checkEsModule.ast;
 
-    if (isEsModule) {
+    const isDynamicRequireModule = dynamicRequireModuleSet.has(normalizePathSlashes(id));
+
+    if (isEsModule && !isDynamicRequireModule) {
       (hasDefaultExport ? esModulesWithDefaultExport : esModulesWithoutDefaultExport).add(id);
-      return null;
     } // it is not an ES module but it does not have CJS-specific elements.
-
-
-    if (!hasCjsKeywords(code, ignoreGlobal)) {
-      esModulesWithoutDefaultExport.add(id);
-      return null;
-    }
+    else if (!hasCjsKeywords(code, ignoreGlobal)) {
+        esModulesWithoutDefaultExport.add(id);
+        setIsCjsPromise(id, false);
+        return null;
+      }
 
     const normalizedId = path.normalize(id);
-    const transformed = transformCommonjs(this.parse, code, id, this.getModuleInfo(id).isEntry, ignoreGlobal, ignoreRequire, customNamedExports[normalizedId], sourceMap, allowDynamicRequire, ast);
+    const transformed = transformCommonjs(this.parse, code, id, this.getModuleInfo(id).isEntry, isEsModule, ignoreGlobal || isEsModule, ignoreRequire, customNamedExports[normalizedId], sourceMap, isDynamicRequireModulesEnabled, dynamicRequireModuleSet, commonDir, ast);
+    setIsCjsPromise(id, isEsModule ? false : Boolean(transformed));
 
     if (!transformed) {
-      esModulesWithoutDefaultExport.add(id);
+      if (!isEsModule || isDynamicRequireModule) esModulesWithoutDefaultExport.add(id);
       return null;
     }
 
@@ -849,32 +1176,131 @@ function commonjs(options = {}) {
     resolveId,
 
     load(id) {
-      if (id === HELPERS_ID) return HELPERS; // generate proxy modules
+      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};`;
       }
 
-      if (id.endsWith(PROXY_SUFFIX)) {
-        const actualId = getIdFromProxyId(id);
+      if (id === DYNAMIC_PACKAGES_ID) {
+        let code = `const { commonjsRegister } = require('${HELPERS_ID}');`;
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = dynamicRequireModuleDirPaths[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            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) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        return code;
+      }
+
+      let actualId = id;
+      const isDynamicJson = actualId.startsWith(DYNAMIC_JSON_PREFIX);
+
+      if (isDynamicJson) {
+        actualId = actualId.slice(DYNAMIC_JSON_PREFIX.length);
+      }
+
+      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 (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 (actualId.endsWith(PROXY_SUFFIX)) {
+        actualId = getIdFromProxyId(actualId);
         const name = getName(actualId);
         return getIsCjsPromise(actualId).then(isCjs => {
-          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)) {
+          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 (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;
+      }
+
       return null;
     },
 
     transform(code, id) {
-      if (!filter(id) || extensions.indexOf(path.extname(id)) === -1) {
-        setIsCjsPromise(id, null);
-        return null;
+      if (id !== DYNAMIC_PACKAGES_ID && !id.startsWith(DYNAMIC_JSON_PREFIX)) {
+        if (!filter(id) || extensions.indexOf(path.extname(id)) === -1) {
+          setIsCjsPromise(id, null);
+          return null;
+        }
       }
 
       let transformed;
@@ -883,10 +1309,10 @@ function commonjs(options = {}) {
         transformed = transformAndCheckExports.call(this, code, id);
       } catch (err) {
         transformed = null;
+        setIsCjsPromise(id, false);
         this.error(err, err.loc);
       }
 
-      setIsCjsPromise(id, Boolean(transformed));
       return transformed;
     }