build

node_modules/@babel/core/lib/config/caching.js

@@ -3,74 +3,177 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.makeStrongCache = makeStrongCache;
 exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
 exports.assertSimpleType = assertSimpleType;
 
-function makeStrongCache(handler) {
-  return makeCachedFunction(new Map(), handler);
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _async = require("../gensync-utils/async");
+
+var _util = require("./util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const synchronize = gen => {
+  return (0, _gensync().default)(gen).sync;
+};
+
+function* genTrue(data) {
+  return true;
 }
 
 function makeWeakCache(handler) {
-  return makeCachedFunction(new WeakMap(), handler);
+  return makeCachedFunction(WeakMap, handler);
 }
 
-function makeCachedFunction(callCache, handler) {
-  return function cachedFunction(arg, data) {
-    let cachedValue = callCache.get(arg);
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
 
-    if (cachedValue) {
-      for (const _ref of cachedValue) {
-        const {
-          value,
-          valid
-        } = _ref;
-        if (valid(data)) return value;
-      }
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
+
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
+
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      const gen = handlerResult;
+      value = yield* (0, _async.onFirstPause)(gen, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
     }
 
-    const cache = new CacheConfigurator(data);
-    const value = handler(arg, cache);
-    if (!cache.configured()) cache.forever();
-    cache.deactivate();
-
-    switch (cache.mode()) {
-      case "forever":
-        cachedValue = [{
-          value,
-          valid: () => true
-        }];
-        callCache.set(arg, cachedValue);
-        break;
-
-      case "invalidate":
-        cachedValue = [{
-          value,
-          valid: cache.validator()
-        }];
-        callCache.set(arg, cachedValue);
-        break;
-
-      case "valid":
-        if (cachedValue) {
-          cachedValue.push({
-            value,
-            valid: cache.validator()
-          });
-        } else {
-          cachedValue = [{
-            value,
-            valid: cache.validator()
-          }];
-          callCache.set(arg, cachedValue);
-        }
+    updateFunctionCache(callCache, cache, arg, value);
 
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
     }
 
     return value;
   };
 }
 
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+
+  return {
+    valid: false,
+    value: null
+  };
+}
+
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+
+  if (cached.valid) {
+    return cached;
+  }
+
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+
+  return {
+    valid: false,
+    value: null
+  };
+}
+
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+
+  }
+}
+
 class CacheConfigurator {
   constructor(data) {
     this._active = true;
@@ -130,33 +233,35 @@ class CacheConfigurator {
 
     this._configured = true;
     const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
 
-    this._pairs.push([key, handler]);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+
+        return key;
+      });
+    }
+
+    this._pairs.push([key, fn]);
 
     return key;
   }
 
   invalidate(handler) {
-    if (!this._active) {
-      throw new Error("Cannot change caching after evaluation has completed.");
-    }
-
-    if (this._never || this._forever) {
-      throw new Error("Caching has already been configured with .never or .forever()");
-    }
-
     this._invalidate = true;
-    this._configured = true;
-    const key = handler(this._data);
-
-    this._pairs.push([key, handler]);
-
-    return key;
+    return this.using(handler);
   }
 
   validator() {
     const pairs = this._pairs;
-    return data => pairs.every(([key, fn]) => key === fn(data));
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+
+      return true;
+    };
   }
 
   deactivate() {
@@ -191,9 +296,29 @@ function makeSimpleConfigurator(cache) {
 }
 
 function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+
   if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
     throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
   }
 
   return value;
+}
+
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+
+  release(value) {
+    this.released = true;
+
+    this._resolve(value);
+  }
+
 }

node_modules/@babel/core/lib/config/config-chain.js

@@ -31,6 +31,8 @@ var _options = require("./validation/options");
 
 var _patternToRegex = _interopRequireDefault(require("./pattern-to-regex"));
 
+var _printer = require("./printer");
+
 var _files = require("./files");
 
 var _caching = require("./caching");
@@ -41,8 +43,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 const debug = (0, _debug().default)("babel:config:config-chain");
 
-function buildPresetChain(arg, context) {
-  const chain = buildPresetChainWalker(arg, context);
+function* buildPresetChain(arg, context) {
+  const chain = yield* buildPresetChainWalker(arg, context);
   if (!chain) return null;
   return {
     plugins: dedupDescriptors(chain.plugins),
@@ -52,30 +54,33 @@ function buildPresetChain(arg, context) {
 }
 
 const buildPresetChainWalker = makeChainWalker({
-  init: arg => arg,
   root: preset => loadPresetDescriptors(preset),
   env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
   overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
-  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName)
+  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName),
+  createLogger: () => () => {}
 });
 exports.buildPresetChainWalker = buildPresetChainWalker;
-const loadPresetDescriptors = (0, _caching.makeWeakCache)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
-const loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
-const loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
-const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
 
-function buildRootChain(opts, context) {
-  const programmaticChain = loadProgrammaticChain({
+function* buildRootChain(opts, context) {
+  let configReport, babelRcReport;
+  const programmaticLogger = new _printer.ConfigPrinter();
+  const programmaticChain = yield* loadProgrammaticChain({
     options: opts,
     dirname: context.cwd
-  }, context);
+  }, context, undefined, programmaticLogger);
   if (!programmaticChain) return null;
+  const programmaticReport = programmaticLogger.output();
   let configFile;
 
   if (typeof opts.configFile === "string") {
-    configFile = (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
+    configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
   } else if (opts.configFile !== false) {
-    configFile = (0, _files.findRootConfig)(context.root, context.envName, context.caller);
+    configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
   }
 
   let {
@@ -84,11 +89,13 @@ function buildRootChain(opts, context) {
   } = opts;
   let babelrcRootsDirectory = context.cwd;
   const configFileChain = emptyChain();
+  const configFileLogger = new _printer.ConfigPrinter();
 
   if (configFile) {
     const validatedFile = validateConfigFile(configFile);
-    const result = loadFileChain(validatedFile, context);
+    const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger);
     if (!result) return null;
+    configReport = configFileLogger.output();
 
     if (babelrc === undefined) {
       babelrc = validatedFile.options.babelrc;
@@ -102,7 +109,7 @@ function buildRootChain(opts, context) {
     mergeChain(configFileChain, result);
   }
 
-  const pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
+  const pkgData = typeof context.filename === "string" ? yield* (0, _files.findPackageData)(context.filename) : null;
   let ignoreFile, babelrcFile;
   const fileChain = emptyChain();
 
@@ -110,19 +117,27 @@ function buildRootChain(opts, context) {
     ({
       ignore: ignoreFile,
       config: babelrcFile
-    } = (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
+    } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
 
     if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
       return null;
     }
 
     if (babelrcFile) {
-      const result = loadFileChain(validateBabelrcFile(babelrcFile), context);
+      const validatedFile = validateBabelrcFile(babelrcFile);
+      const babelrcLogger = new _printer.ConfigPrinter();
+      const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);
       if (!result) return null;
+      babelRcReport = babelrcLogger.output();
       mergeChain(fileChain, result);
     }
   }
 
+  if (context.showConfig) {
+    console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n"));
+    return null;
+  }
+
   const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
   return {
     plugins: dedupDescriptors(chain.plugins),
@@ -163,17 +178,17 @@ function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirector
   });
 }
 
-const validateConfigFile = (0, _caching.makeWeakCache)(file => ({
+const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("configfile", file.options)
 }));
-const validateBabelrcFile = (0, _caching.makeWeakCache)(file => ({
+const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("babelrcfile", file.options)
 }));
-const validateExtendFile = (0, _caching.makeWeakCache)(file => ({
+const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("extendsfile", file.options)
@@ -182,18 +197,30 @@ const loadProgrammaticChain = makeChainWalker({
   root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
   env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
   overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
-  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName)
+  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
+  createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
 });
 const loadFileChain = makeChainWalker({
   root: file => loadFileDescriptors(file),
   env: (file, envName) => loadFileEnvDescriptors(file)(envName),
   overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
-  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName)
+  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName),
+  createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
 });
-const loadFileDescriptors = (0, _caching.makeWeakCache)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
-const loadFileEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
-const loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
-const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+
+function buildFileLogger(filepath, context, baseLogger) {
+  if (!baseLogger) {
+    return () => {};
+  }
+
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
+    filepath
+  });
+}
 
 function buildRootDescriptors({
   dirname,
@@ -202,6 +229,18 @@ function buildRootDescriptors({
   return descriptors(dirname, options, alias);
 }
 
+function buildProgrammaticLogger(_, context, baseLogger) {
+  var _context$caller;
+
+  if (!baseLogger) {
+    return () => {};
+  }
+
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
+    callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
+  });
+}
+
 function buildEnvDescriptors({
   dirname,
   options
@@ -233,9 +272,10 @@ function makeChainWalker({
   root,
   env,
   overrides,
-  overridesEnv
+  overridesEnv,
+  createLogger
 }) {
-  return (input, context, files = new Set()) => {
+  return function* (input, context, files = new Set(), baseLogger) {
     const {
       dirname
     } = input;
@@ -243,60 +283,84 @@ function makeChainWalker({
     const rootOpts = root(input);
 
     if (configIsApplicable(rootOpts, dirname, context)) {
-      flattenedConfigs.push(rootOpts);
+      flattenedConfigs.push({
+        config: rootOpts,
+        envName: undefined,
+        index: undefined
+      });
       const envOpts = env(input, context.envName);
 
       if (envOpts && configIsApplicable(envOpts, dirname, context)) {
-        flattenedConfigs.push(envOpts);
+        flattenedConfigs.push({
+          config: envOpts,
+          envName: context.envName,
+          index: undefined
+        });
       }
 
       (rootOpts.options.overrides || []).forEach((_, index) => {
         const overrideOps = overrides(input, index);
 
         if (configIsApplicable(overrideOps, dirname, context)) {
-          flattenedConfigs.push(overrideOps);
+          flattenedConfigs.push({
+            config: overrideOps,
+            index,
+            envName: undefined
+          });
           const overrideEnvOpts = overridesEnv(input, index, context.envName);
 
           if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
-            flattenedConfigs.push(overrideEnvOpts);
+            flattenedConfigs.push({
+              config: overrideEnvOpts,
+              index,
+              envName: context.envName
+            });
           }
         }
       });
     }
 
     if (flattenedConfigs.some(({
-      options: {
-        ignore,
-        only
+      config: {
+        options: {
+          ignore,
+          only
+        }
       }
     }) => shouldIgnore(context, ignore, only, dirname))) {
       return null;
     }
 
     const chain = emptyChain();
+    const logger = createLogger(input, context, baseLogger);
 
-    for (const op of flattenedConfigs) {
-      if (!mergeExtendsChain(chain, op.options, dirname, context, files)) {
+    for (const {
+      config,
+      index,
+      envName
+    } of flattenedConfigs) {
+      if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
         return null;
       }
 
-      mergeChainOpts(chain, op);
+      logger(config, index, envName);
+      mergeChainOpts(chain, config);
     }
 
     return chain;
   };
 }
 
-function mergeExtendsChain(chain, opts, dirname, context, files) {
+function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
   if (opts.extends === undefined) return true;
-  const file = (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
+  const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
 
   if (files.has(file)) {
     throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
   }
 
   files.add(file);
-  const fileChain = loadFileChain(validateExtendFile(file), context, files);
+  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
   files.delete(file);
   if (!fileChain) return false;
   mergeChain(chain, fileChain);
@@ -343,7 +407,7 @@ function normalizeOptions(opts) {
   delete options.include;
   delete options.exclude;
 
-  if (options.hasOwnProperty("sourceMap")) {
+  if (Object.prototype.hasOwnProperty.call(options, "sourceMap")) {
     options.sourceMaps = options.sourceMap;
     delete options.sourceMap;
   }
@@ -402,12 +466,28 @@ function configFieldIsApplicable(context, test, dirname) {
 
 function shouldIgnore(context, ignore, only, dirname) {
   if (ignore && matchesPatterns(context, ignore, dirname)) {
-    debug("Ignored %o because it matched one of %O from %o", context.filename, ignore, dirname);
+    var _context$filename;
+
+    const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore)}\` from "${dirname}"`;
+    debug(message);
+
+    if (context.showConfig) {
+      console.log(message);
+    }
+
     return true;
   }
 
   if (only && !matchesPatterns(context, only, dirname)) {
-    debug("Ignored %o because it failed to match one of %O from %o", context.filename, only, dirname);
+    var _context$filename2;
+
+    const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only)}\` from "${dirname}"`;
+    debug(message);
+
+    if (context.showConfig) {
+      console.log(message);
+    }
+
     return true;
   }
 

node_modules/@babel/core/lib/config/config-descriptors.js

@@ -53,14 +53,14 @@ function createUncachedDescriptors(dirname, options, alias) {
 }
 
 const PRESET_DESCRIPTOR_CACHE = new WeakMap();
-const createCachedPresetDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
+const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
   const dirname = cache.using(dir => dir);
-  return (0, _caching.makeStrongCache)(alias => (0, _caching.makeStrongCache)(passPerPreset => createPresetDescriptors(items, dirname, alias, passPerPreset).map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc))));
+  return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCacheSync)(passPerPreset => createPresetDescriptors(items, dirname, alias, passPerPreset).map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc))));
 });
 const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
-const createCachedPluginDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
+const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
   const dirname = cache.using(dir => dir);
-  return (0, _caching.makeStrongCache)(alias => createPluginDescriptors(items, dirname, alias).map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc)));
+  return (0, _caching.makeStrongCacheSync)(alias => createPluginDescriptors(items, dirname, alias).map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc)));
 });
 const DEFAULT_OPTIONS = {};
 
@@ -202,7 +202,8 @@ function assertNoDuplicates(items) {
     }
 
     if (nameMap.has(item.name)) {
-      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`].join("\n"));
+      const conflicts = items.filter(i => i.value === item.value);
+      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n"));
     }
 
     nameMap.add(item.name);

node_modules/@babel/core/lib/config/files/configuration.js

@@ -7,6 +7,8 @@ exports.findConfigUpwards = findConfigUpwards;
 exports.findRelativeConfig = findRelativeConfig;
 exports.findRootConfig = findRootConfig;
 exports.loadConfig = loadConfig;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+exports.ROOT_CONFIG_FILENAMES = void 0;
 
 function _debug() {
   const data = _interopRequireDefault(require("debug"));
@@ -28,16 +30,6 @@ function _path() {
   return data;
 }
 
-function _fs() {
-  const data = _interopRequireDefault(require("fs"));
-
-  _fs = function () {
-    return data;
-  };
-
-  return data;
-}
-
 function _json() {
   const data = _interopRequireDefault(require("json5"));
 
@@ -48,10 +40,10 @@ function _json() {
   return data;
 }
 
-function _resolve() {
-  const data = _interopRequireDefault(require("resolve"));
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
 
-  _resolve = function () {
+  _gensync = function () {
     return data;
   };
 
@@ -64,22 +56,34 @@ var _configApi = _interopRequireDefault(require("../helpers/config-api"));
 
 var _utils = require("./utils");
 
+var _moduleTypes = _interopRequireDefault(require("./module-types"));
+
 var _patternToRegex = _interopRequireDefault(require("../pattern-to-regex"));
 
+var fs = _interopRequireWildcard(require("../../gensync-utils/fs"));
+
+var _resolve = _interopRequireDefault(require("../../gensync-utils/resolve"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const debug = (0, _debug().default)("babel:config:loading:files:configuration");
-const BABEL_CONFIG_JS_FILENAME = "babel.config.js";
-const BABELRC_FILENAME = ".babelrc";
-const BABELRC_JS_FILENAME = ".babelrc.js";
+const ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json"];
+exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
+const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json"];
 const BABELIGNORE_FILENAME = ".babelignore";
 
-function findConfigUpwards(rootDir) {
+function* findConfigUpwards(rootDir) {
   let dirname = rootDir;
 
   while (true) {
-    if (_fs().default.existsSync(_path().default.join(dirname, BABEL_CONFIG_JS_FILENAME))) {
-      return dirname;
+    for (const filename of ROOT_CONFIG_FILENAMES) {
+      if (yield* fs.exists(_path().default.join(dirname, filename))) {
+        return dirname;
+      }
     }
 
     const nextDir = _path().default.dirname(dirname);
@@ -91,7 +95,7 @@ function findConfigUpwards(rootDir) {
   return null;
 }
 
-function findRelativeConfig(packageData, envName, caller) {
+function* findRelativeConfig(packageData, envName, caller) {
   let config = null;
   let ignore = null;
 
@@ -99,36 +103,15 @@ function findRelativeConfig(packageData, envName, caller) {
 
   for (const loc of packageData.directories) {
     if (!config) {
-      config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce((previousConfig, name) => {
-        const filepath = _path().default.join(loc, name);
+      var _packageData$pkg;
 
-        const config = readConfig(filepath, envName, caller);
-
-        if (config && previousConfig) {
-          throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(previousConfig.filepath)}\n` + ` - ${name}\n` + `from ${loc}`);
-        }
-
-        return config || previousConfig;
-      }, null);
-      const pkgConfig = packageData.pkg && packageData.pkg.dirname === loc ? packageToBabelConfig(packageData.pkg) : null;
-
-      if (pkgConfig) {
-        if (config) {
-          throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(pkgConfig.filepath)}#babel\n` + ` - ${_path().default.basename(config.filepath)}\n` + `from ${loc}`);
-        }
-
-        config = pkgConfig;
-      }
-
-      if (config) {
-        debug("Found configuration %o from %o.", config.filepath, dirname);
-      }
+      config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
     }
 
     if (!ignore) {
       const ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
 
-      ignore = readIgnoreConfig(ignoreLoc);
+      ignore = yield* readIgnoreConfig(ignoreLoc);
 
       if (ignore) {
         debug("Found ignore %o from %o.", ignore.filepath, dirname);
@@ -143,23 +126,31 @@ function findRelativeConfig(packageData, envName, caller) {
 }
 
 function findRootConfig(dirname, envName, caller) {
-  const filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
-
-  const conf = readConfig(filepath, envName, caller);
-
-  if (conf) {
-    debug("Found root config %o in %o.", BABEL_CONFIG_JS_FILENAME, dirname);
-  }
-
-  return conf;
+  return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
 }
 
-function loadConfig(name, dirname, envName, caller) {
-  const filepath = _resolve().default.sync(name, {
+function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
+  const configs = yield* _gensync().default.all(names.map(filename => readConfig(_path().default.join(dirname, filename), envName, caller)));
+  const config = configs.reduce((previousConfig, config) => {
+    if (config && previousConfig) {
+      throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
+    }
+
+    return config || previousConfig;
+  }, previousConfig);
+
+  if (config) {
+    debug("Found configuration %o from %o.", config.filepath, dirname);
+  }
+
+  return config;
+}
+
+function* loadConfig(name, dirname, envName, caller) {
+  const filepath = yield* (0, _resolve.default)(name, {
     basedir: dirname
   });
-
-  const conf = readConfig(filepath, envName, caller);
+  const conf = yield* readConfig(filepath, envName, caller);
 
   if (!conf) {
     throw new Error(`Config file ${filepath} contains no configuration data`);
@@ -170,15 +161,17 @@ function loadConfig(name, dirname, envName, caller) {
 }
 
 function readConfig(filepath, envName, caller) {
-  return _path().default.extname(filepath) === ".js" ? readConfigJS(filepath, {
+  const ext = _path().default.extname(filepath);
+
+  return ext === ".js" || ext === ".cjs" || ext === ".mjs" ? readConfigJS(filepath, {
     envName,
     caller
   }) : readConfigJSON5(filepath);
 }
 
 const LOADING_CONFIGS = new Set();
-const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
-  if (!_fs().default.existsSync(filepath)) {
+const readConfigJS = (0, _caching.makeStrongCache)(function* readConfigJS(filepath, cache) {
+  if (!fs.exists.sync(filepath)) {
     cache.forever();
     return null;
   }
@@ -197,10 +190,7 @@ const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
 
   try {
     LOADING_CONFIGS.add(filepath);
-
-    const configModule = require(filepath);
-
-    options = configModule && configModule.__esModule ? configModule.default || undefined : configModule;
+    options = yield* (0, _moduleTypes.default)(filepath, "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously.");
   } catch (err) {
     err.message = `${filepath}: Error while loading config - ${err.message}`;
     throw err;
@@ -208,9 +198,12 @@ const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
     LOADING_CONFIGS.delete(filepath);
   }
 
+  let assertCache = false;
+
   if (typeof options === "function") {
+    yield* [];
     options = options((0, _configApi.default)(cache));
-    if (!cache.configured()) throwConfigError();
+    assertCache = true;
   }
 
   if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -221,13 +214,14 @@ const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
     throw new Error(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`);
   }
 
+  if (assertCache && !cache.configured()) throwConfigError();
   return {
     filepath,
     dirname: _path().default.dirname(filepath),
     options
   };
 });
-const packageToBabelConfig = (0, _caching.makeWeakCache)(file => {
+const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
   const babel = file.options["babel"];
   if (typeof babel === "undefined") return null;
 
@@ -285,6 +279,24 @@ const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) =>
   };
 });
 
+function* resolveShowConfigPath(dirname) {
+  const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
+
+  if (targetPath != null) {
+    const absolutePath = _path().default.resolve(dirname, targetPath);
+
+    const stats = yield* fs.stat(absolutePath);
+
+    if (!stats.isFile()) {
+      throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
+    }
+
+    return absolutePath;
+  }
+
+  return null;
+}
+
 function throwConfigError() {
   throw new Error(`\
 Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured

node_modules/@babel/core/lib/config/files/import.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = import_;
+
+function import_(filepath) {
+  return import(filepath);
+}

node_modules/@babel/core/lib/config/files/index-browser.js

@@ -8,16 +8,18 @@ exports.findPackageData = findPackageData;
 exports.findRelativeConfig = findRelativeConfig;
 exports.findRootConfig = findRootConfig;
 exports.loadConfig = loadConfig;
+exports.resolveShowConfigPath = resolveShowConfigPath;
 exports.resolvePlugin = resolvePlugin;
 exports.resolvePreset = resolvePreset;
 exports.loadPlugin = loadPlugin;
 exports.loadPreset = loadPreset;
+exports.ROOT_CONFIG_FILENAMES = void 0;
 
-function findConfigUpwards(rootDir) {
+function* findConfigUpwards(rootDir) {
   return null;
 }
 
-function findPackageData(filepath) {
+function* findPackageData(filepath) {
   return {
     filepath,
     directories: [],
@@ -26,7 +28,7 @@ function findPackageData(filepath) {
   };
 }
 
-function findRelativeConfig(pkgData, envName, caller) {
+function* findRelativeConfig(pkgData, envName, caller) {
   return {
     pkg: null,
     config: null,
@@ -34,14 +36,21 @@ function findRelativeConfig(pkgData, envName, caller) {
   };
 }
 
-function findRootConfig(dirname, envName, caller) {
+function* findRootConfig(dirname, envName, caller) {
   return null;
 }
 
-function loadConfig(name, dirname, envName, caller) {
+function* loadConfig(name, dirname, envName, caller) {
   throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
 }
 
+function* resolveShowConfigPath(dirname) {
+  return null;
+}
+
+const ROOT_CONFIG_FILENAMES = [];
+exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
+
 function resolvePlugin(name, dirname) {
   return null;
 }

node_modules/@babel/core/lib/config/files/index.js

@@ -33,6 +33,18 @@ Object.defineProperty(exports, "loadConfig", {
     return _configuration.loadConfig;
   }
 });
+Object.defineProperty(exports, "resolveShowConfigPath", {
+  enumerable: true,
+  get: function () {
+    return _configuration.resolveShowConfigPath;
+  }
+});
+Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
+  enumerable: true,
+  get: function () {
+    return _configuration.ROOT_CONFIG_FILENAMES;
+  }
+});
 Object.defineProperty(exports, "resolvePlugin", {
   enumerable: true,
   get: function () {

node_modules/@babel/core/lib/config/files/module-types.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadCjsOrMjsDefault;
+
+var _async = require("../../gensync-utils/async");
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _url() {
+  const data = require("url");
+
+  _url = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+let import_;
+
+try {
+  import_ = require("./import").default;
+} catch (_unused) {}
+
+function* loadCjsOrMjsDefault(filepath, asyncError) {
+  switch (guessJSModuleType(filepath)) {
+    case "cjs":
+      return loadCjsDefault(filepath);
+
+    case "unknown":
+      try {
+        return loadCjsDefault(filepath);
+      } catch (e) {
+        if (e.code !== "ERR_REQUIRE_ESM") throw e;
+      }
+
+    case "mjs":
+      if (yield* (0, _async.isAsync)()) {
+        return yield* (0, _async.waitFor)(loadMjsDefault(filepath));
+      }
+
+      throw new Error(asyncError);
+  }
+}
+
+function guessJSModuleType(filename) {
+  switch (_path().default.extname(filename)) {
+    case ".cjs":
+      return "cjs";
+
+    case ".mjs":
+      return "mjs";
+
+    default:
+      return "unknown";
+  }
+}
+
+function loadCjsDefault(filepath) {
+  const module = require(filepath);
+
+  return (module == null ? void 0 : module.__esModule) ? module.default || undefined : module;
+}
+
+function loadMjsDefault(_x) {
+  return _loadMjsDefault.apply(this, arguments);
+}
+
+function _loadMjsDefault() {
+  _loadMjsDefault = _asyncToGenerator(function* (filepath) {
+    if (!import_) {
+      throw new Error("Internal error: Native ECMAScript modules aren't supported" + " by this platform.\n");
+    }
+
+    const module = yield import_((0, _url().pathToFileURL)(filepath));
+    return module.default;
+  });
+  return _loadMjsDefault.apply(this, arguments);
+}

node_modules/@babel/core/lib/config/files/package.js

@@ -21,7 +21,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 const PACKAGE_FILENAME = "package.json";
 
-function findPackageData(filepath) {
+function* findPackageData(filepath) {
   let pkg = null;
   const directories = [];
   let isPackage = true;
@@ -30,7 +30,7 @@ function findPackageData(filepath) {
 
   while (!pkg && _path().default.basename(dirname) !== "node_modules") {
     directories.push(dirname);
-    pkg = readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
+    pkg = yield* readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
 
     const nextLoc = _path().default.dirname(dirname);
 
@@ -60,6 +60,8 @@ const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) =>
     throw err;
   }
 
+  if (!options) throw new Error(`${filepath}: No config detected`);
+
   if (typeof options !== "object") {
     throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
   }

node_modules/@babel/core/lib/config/files/plugins.js

@@ -113,7 +113,7 @@ function resolveStandardizedName(type, name, dirname = process.cwd()) {
         });
 
         resolvedOriginal = true;
-      } catch (e2) {}
+      } catch (_unused) {}
 
       if (resolvedOriginal) {
         e.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
@@ -128,7 +128,7 @@ function resolveStandardizedName(type, name, dirname = process.cwd()) {
       });
 
       resolvedBabel = true;
-    } catch (e2) {}
+    } catch (_unused2) {}
 
     if (resolvedBabel) {
       e.message += `\n- Did you mean "@babel/${name}"?`;
@@ -143,7 +143,7 @@ function resolveStandardizedName(type, name, dirname = process.cwd()) {
       });
 
       resolvedOppositeType = true;
-    } catch (e2) {}
+    } catch (_unused3) {}
 
     if (resolvedOppositeType) {
       e.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;

node_modules/@babel/core/lib/config/files/utils.js

@@ -5,34 +5,41 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.makeStaticFileCache = makeStaticFileCache;
 
-function _fs() {
+var _caching = require("../caching");
+
+var fs = _interopRequireWildcard(require("../../gensync-utils/fs"));
+
+function _fs2() {
   const data = _interopRequireDefault(require("fs"));
 
-  _fs = function () {
+  _fs2 = function () {
     return data;
   };
 
   return data;
 }
 
-var _caching = require("../caching");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function makeStaticFileCache(fn) {
-  return (0, _caching.makeStrongCache)((filepath, cache) => {
-    if (cache.invalidate(() => fileMtime(filepath)) === null) {
-      cache.forever();
+  return (0, _caching.makeStrongCache)(function* (filepath, cache) {
+    const cached = cache.invalidate(() => fileMtime(filepath));
+
+    if (cached === null) {
       return null;
     }
 
-    return fn(filepath, _fs().default.readFileSync(filepath, "utf8"));
+    return fn(filepath, yield* fs.readFile(filepath, "utf8"));
   });
 }
 
 function fileMtime(filepath) {
   try {
-    return +_fs().default.statSync(filepath).mtime;
+    return +_fs2().default.statSync(filepath).mtime;
   } catch (e) {
     if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
   }

node_modules/@babel/core/lib/config/full.js

@@ -3,7 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = loadFullConfig;
+exports.default = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _async = require("../gensync-utils/async");
 
 var _util = require("./util");
 
@@ -35,12 +47,14 @@ var _configApi = _interopRequireDefault(require("./helpers/config-api"));
 
 var _partial = _interopRequireDefault(require("./partial"));
 
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
-
-function loadFullConfig(inputOpts) {
-  const result = (0, _partial.default)(inputOpts);
+var _default = (0, _gensync().default)(function* loadFullConfig(inputOpts) {
+  const result = yield* (0, _partial.default)(inputOpts);
 
   if (!result) {
     return null;
@@ -63,35 +77,55 @@ function loadFullConfig(inputOpts) {
       throw new Error("Assertion failure - plugins and presets exist");
     }
 
-    const ignored = function recurseDescriptors(config, pass) {
-      const plugins = config.plugins.reduce((acc, descriptor) => {
-        if (descriptor.options !== false) {
-          acc.push(loadPluginDescriptor(descriptor, context));
-        }
+    const ignored = yield* function* recurseDescriptors(config, pass) {
+      const plugins = [];
 
-        return acc;
-      }, []);
-      const presets = config.presets.reduce((acc, descriptor) => {
-        if (descriptor.options !== false) {
-          acc.push({
-            preset: loadPresetDescriptor(descriptor, context),
-            pass: descriptor.ownPass ? [] : pass
-          });
-        }
+      for (let i = 0; i < config.plugins.length; i++) {
+        const descriptor = config.plugins[i];
 
-        return acc;
-      }, []);
+        if (descriptor.options !== false) {
+          try {
+            plugins.push(yield* loadPluginDescriptor(descriptor, context));
+          } catch (e) {
+            if (i > 0 && e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
+              (0, _options.checkNoUnwrappedItemOptionPairs)(config.plugins[i - 1], descriptor, "plugin", i, e);
+            }
+
+            throw e;
+          }
+        }
+      }
+
+      const presets = [];
+
+      for (let i = 0; i < config.presets.length; i++) {
+        const descriptor = config.presets[i];
+
+        if (descriptor.options !== false) {
+          try {
+            presets.push({
+              preset: yield* loadPresetDescriptor(descriptor, context),
+              pass: descriptor.ownPass ? [] : pass
+            });
+          } catch (e) {
+            if (i > 0 && e.code === "BABEL_UNKNOWN_OPTION") {
+              (0, _options.checkNoUnwrappedItemOptionPairs)(config.presets[i - 1], descriptor, "preset", i, e);
+            }
+
+            throw e;
+          }
+        }
+      }
 
       if (presets.length > 0) {
         passes.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pass));
 
-        for (const _ref of presets) {
-          const {
-            preset,
-            pass
-          } = _ref;
+        for (const {
+          preset,
+          pass
+        } of presets) {
           if (!preset) return true;
-          const ignored = recurseDescriptors({
+          const ignored = yield* recurseDescriptors({
             plugins: preset.plugins,
             presets: preset.presets
           }, pass);
@@ -125,7 +159,6 @@ function loadFullConfig(inputOpts) {
         return desc;
       })
     }, passes[0]);
-
     if (ignored) return null;
   } catch (e) {
     if (!/^\[BABEL\]/.test(e.message)) {
@@ -146,14 +179,15 @@ function loadFullConfig(inputOpts) {
     options: opts,
     passes: passes
   };
-}
+});
 
-const loadDescriptor = (0, _caching.makeWeakCache)(({
+exports.default = _default;
+const loadDescriptor = (0, _caching.makeWeakCache)(function* ({
   value,
   options,
   dirname,
   alias
-}, cache) => {
+}, cache) {
   if (options === false) throw new Error("Assertion failure");
   options = options || {};
   let item = value;
@@ -177,6 +211,7 @@ const loadDescriptor = (0, _caching.makeWeakCache)(({
   }
 
   if (typeof item.then === "function") {
+    yield* [];
     throw new Error(`You appear to be using an async plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`);
   }
 
@@ -188,7 +223,7 @@ const loadDescriptor = (0, _caching.makeWeakCache)(({
   };
 });
 
-function loadPluginDescriptor(descriptor, context) {
+function* loadPluginDescriptor(descriptor, context) {
   if (descriptor.value instanceof _plugin.default) {
     if (descriptor.options) {
       throw new Error("Passed options to an existing Plugin instance will not work.");
@@ -197,15 +232,15 @@ function loadPluginDescriptor(descriptor, context) {
     return descriptor.value;
   }
 
-  return instantiatePlugin(loadDescriptor(descriptor, context), context);
+  return yield* instantiatePlugin(yield* loadDescriptor(descriptor, context), context);
 }
 
-const instantiatePlugin = (0, _caching.makeWeakCache)(({
+const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({
   value,
   options,
   dirname,
   alias
-}, cache) => {
+}, cache) {
   const pluginObj = (0, _plugins.validatePluginObject)(value);
   const plugin = Object.assign({}, pluginObj);
 
@@ -221,7 +256,9 @@ const instantiatePlugin = (0, _caching.makeWeakCache)(({
       options,
       dirname
     };
-    const inherits = cache.invalidate(data => loadPluginDescriptor(inheritsDescriptor, data));
+    const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => {
+      return cache.invalidate(data => run(inheritsDescriptor, data));
+    });
     plugin.pre = chain(inherits.pre, plugin.pre);
     plugin.post = chain(inherits.post, plugin.post);
     plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
@@ -231,11 +268,33 @@ const instantiatePlugin = (0, _caching.makeWeakCache)(({
   return new _plugin.default(plugin, options, alias);
 });
 
-const loadPresetDescriptor = (descriptor, context) => {
-  return (0, _configChain.buildPresetChain)(instantiatePreset(loadDescriptor(descriptor, context)), context);
+const validateIfOptionNeedsFilename = (options, descriptor) => {
+  if (options.test || options.include || options.exclude) {
+    const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */";
+    throw new Error([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transform(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
+  }
 };
 
-const instantiatePreset = (0, _caching.makeWeakCache)(({
+const validatePreset = (preset, context, descriptor) => {
+  if (!context.filename) {
+    const {
+      options
+    } = preset;
+    validateIfOptionNeedsFilename(options, descriptor);
+
+    if (options.overrides) {
+      options.overrides.forEach(overrideOptions => validateIfOptionNeedsFilename(overrideOptions, descriptor));
+    }
+  }
+};
+
+function* loadPresetDescriptor(descriptor, context) {
+  const preset = instantiatePreset(yield* loadDescriptor(descriptor, context));
+  validatePreset(preset, context, descriptor);
+  return yield* (0, _configChain.buildPresetChain)(preset, context);
+}
+
+const instantiatePreset = (0, _caching.makeWeakCacheSync)(({
   value,
   dirname,
   alias

node_modules/@babel/core/lib/config/helpers/config-api.js

@@ -47,8 +47,7 @@ function makeAPI(cache) {
     env,
     async: () => false,
     caller,
-    assertVersion,
-    tokTypes: undefined
+    assertVersion
   };
 }
 

node_modules/@babel/core/lib/config/index.js

@@ -3,19 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadOptions = loadOptions;
 Object.defineProperty(exports, "default", {
   enumerable: true,
   get: function () {
     return _full.default;
   }
 });
-Object.defineProperty(exports, "loadPartialConfig", {
-  enumerable: true,
-  get: function () {
-    return _partial.loadPartialConfig;
-  }
-});
+exports.loadOptionsAsync = exports.loadOptionsSync = exports.loadOptions = exports.loadPartialConfigAsync = exports.loadPartialConfigSync = exports.loadPartialConfig = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _full = _interopRequireDefault(require("./full"));
 
@@ -23,7 +27,31 @@ var _partial = require("./partial");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function loadOptions(opts) {
-  const config = (0, _full.default)(opts);
-  return config ? config.options : null;
-}
+const loadOptionsRunner = (0, _gensync().default)(function* (opts) {
+  var _config$options;
+
+  const config = yield* (0, _full.default)(opts);
+  return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null;
+});
+
+const maybeErrback = runner => (opts, callback) => {
+  if (callback === undefined && typeof opts === "function") {
+    callback = opts;
+    opts = undefined;
+  }
+
+  return callback ? runner.errback(opts, callback) : runner.sync(opts);
+};
+
+const loadPartialConfig = maybeErrback(_partial.loadPartialConfig);
+exports.loadPartialConfig = loadPartialConfig;
+const loadPartialConfigSync = _partial.loadPartialConfig.sync;
+exports.loadPartialConfigSync = loadPartialConfigSync;
+const loadPartialConfigAsync = _partial.loadPartialConfig.async;
+exports.loadPartialConfigAsync = loadPartialConfigAsync;
+const loadOptions = maybeErrback(loadOptionsRunner);
+exports.loadOptions = loadOptions;
+const loadOptionsSync = loadOptionsRunner.sync;
+exports.loadOptionsSync = loadOptionsSync;
+const loadOptionsAsync = loadOptionsRunner.async;
+exports.loadOptionsAsync = loadOptionsAsync;

node_modules/@babel/core/lib/config/partial.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = loadPrivatePartialConfig;
-exports.loadPartialConfig = loadPartialConfig;
+exports.loadPartialConfig = void 0;
 
 function _path() {
   const data = _interopRequireDefault(require("path"));
@@ -16,6 +16,16 @@ function _path() {
   return data;
 }
 
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
 var _plugin = _interopRequireDefault(require("./plugin"));
 
 var _util = require("./util");
@@ -32,33 +42,33 @@ var _files = require("./files");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function resolveRootMode(rootDir, rootMode) {
+function* resolveRootMode(rootDir, rootMode) {
   switch (rootMode) {
     case "root":
       return rootDir;
 
     case "upward-optional":
       {
-        const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
+        const upwardRootDir = yield* (0, _files.findConfigUpwards)(rootDir);
         return upwardRootDir === null ? rootDir : upwardRootDir;
       }
 
     case "upward":
       {
-        const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
+        const upwardRootDir = yield* (0, _files.findConfigUpwards)(rootDir);
         if (upwardRootDir !== null) return upwardRootDir;
-        throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}"`), {
+        throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), {
           code: "BABEL_ROOT_NOT_FOUND",
           dirname: rootDir
         });
       }
 
     default:
-      throw new Error(`Assertion failure - unknown rootMode value`);
+      throw new Error(`Assertion failure - unknown rootMode value.`);
   }
 }
 
-function loadPrivatePartialConfig(inputOpts) {
+function* loadPrivatePartialConfig(inputOpts) {
   if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
     throw new Error("Babel options must be an object, null, or undefined");
   }
@@ -69,25 +79,30 @@ function loadPrivatePartialConfig(inputOpts) {
     cwd = ".",
     root: rootDir = ".",
     rootMode = "root",
-    caller
+    caller,
+    cloneInputAst = true
   } = args;
 
   const absoluteCwd = _path().default.resolve(cwd);
 
-  const absoluteRootDir = resolveRootMode(_path().default.resolve(absoluteCwd, rootDir), rootMode);
+  const absoluteRootDir = yield* resolveRootMode(_path().default.resolve(absoluteCwd, rootDir), rootMode);
+  const filename = typeof args.filename === "string" ? _path().default.resolve(cwd, args.filename) : undefined;
+  const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd);
   const context = {
-    filename: typeof args.filename === "string" ? _path().default.resolve(cwd, args.filename) : undefined,
+    filename,
     cwd: absoluteCwd,
     root: absoluteRootDir,
     envName,
-    caller
+    caller,
+    showConfig: showConfigPath === filename
   };
-  const configChain = (0, _configChain.buildRootChain)(args, context);
+  const configChain = yield* (0, _configChain.buildRootChain)(args, context);
   if (!configChain) return null;
   const options = {};
   configChain.options.forEach(opts => {
     (0, _util.mergeOptions)(options, opts);
   });
+  options.cloneInputAst = cloneInputAst;
   options.babelrc = false;
   options.configFile = false;
   options.passPerPreset = false;
@@ -106,8 +121,8 @@ function loadPrivatePartialConfig(inputOpts) {
   };
 }
 
-function loadPartialConfig(inputOpts) {
-  const result = loadPrivatePartialConfig(inputOpts);
+const loadPartialConfig = (0, _gensync().default)(function* (inputOpts) {
+  const result = yield* loadPrivatePartialConfig(inputOpts);
   if (!result) return null;
   const {
     options,
@@ -121,7 +136,8 @@ function loadPartialConfig(inputOpts) {
     }
   });
   return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined);
-}
+});
+exports.loadPartialConfig = loadPartialConfig;
 
 class PartialConfig {
   constructor(options, babelrc, ignore, config) {

node_modules/@babel/core/lib/config/printer.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConfigPrinter = exports.ChainFormatter = void 0;
+const ChainFormatter = {
+  Programmatic: 0,
+  Config: 1
+};
+exports.ChainFormatter = ChainFormatter;
+const Formatter = {
+  title(type, callerName, filepath) {
+    let title = "";
+
+    if (type === ChainFormatter.Programmatic) {
+      title = "programmatic options";
+
+      if (callerName) {
+        title += " from " + callerName;
+      }
+    } else {
+      title = "config " + filepath;
+    }
+
+    return title;
+  },
+
+  loc(index, envName) {
+    let loc = "";
+
+    if (index != null) {
+      loc += `.overrides[${index}]`;
+    }
+
+    if (envName != null) {
+      loc += `.env["${envName}"]`;
+    }
+
+    return loc;
+  },
+
+  optionsAndDescriptors(opt) {
+    const content = Object.assign({}, opt.options);
+    delete content.overrides;
+    delete content.env;
+    const pluginDescriptors = [...opt.plugins()];
+
+    if (pluginDescriptors.length) {
+      content.plugins = pluginDescriptors.map(d => descriptorToConfig(d));
+    }
+
+    const presetDescriptors = [...opt.presets()];
+
+    if (presetDescriptors.length) {
+      content.presets = [...presetDescriptors].map(d => descriptorToConfig(d));
+    }
+
+    return JSON.stringify(content, undefined, 2);
+  }
+
+};
+
+function descriptorToConfig(d) {
+  var _d$file;
+
+  let name = (_d$file = d.file) == null ? void 0 : _d$file.request;
+
+  if (name == null) {
+    if (typeof d.value === "object") {
+      name = d.value;
+    } else if (typeof d.value === "function") {
+      name = `[Function: ${d.value.toString().substr(0, 50)} ... ]`;
+    }
+  }
+
+  if (name == null) {
+    name = "[Unknown]";
+  }
+
+  if (d.options === undefined) {
+    return name;
+  } else if (d.name == null) {
+    return [name, d.options];
+  } else {
+    return [name, d.options, d.name];
+  }
+}
+
+class ConfigPrinter {
+  constructor() {
+    this._stack = [];
+  }
+
+  configure(enabled, type, {
+    callerName,
+    filepath
+  }) {
+    if (!enabled) return () => {};
+    return (content, index, envName) => {
+      this._stack.push({
+        type,
+        callerName,
+        filepath,
+        content,
+        index,
+        envName
+      });
+    };
+  }
+
+  static format(config) {
+    let title = Formatter.title(config.type, config.callerName, config.filepath);
+    const loc = Formatter.loc(config.index, config.envName);
+    if (loc) title += ` ${loc}`;
+    const content = Formatter.optionsAndDescriptors(config.content);
+    return `${title}\n${content}`;
+  }
+
+  output() {
+    if (this._stack.length === 0) return "";
+    return this._stack.map(s => ConfigPrinter.format(s)).join("\n\n");
+  }
+
+}
+
+exports.ConfigPrinter = ConfigPrinter;

node_modules/@babel/core/lib/config/util.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.mergeOptions = mergeOptions;
+exports.isIterableIterator = isIterableIterator;
 
 function mergeOptions(target, source) {
   for (const k of Object.keys(source)) {
@@ -27,4 +28,8 @@ function mergeDefaultFields(target, source) {
     const val = source[k];
     if (val !== undefined) target[k] = val;
   }
+}
+
+function isIterableIterator(value) {
+  return !!value && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
 }

node_modules/@babel/core/lib/config/validation/options.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.validate = validate;
+exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs;
 
 var _plugin = _interopRequireDefault(require("../plugin"));
 
@@ -23,6 +24,7 @@ const ROOT_VALIDATORS = {
   filenameRelative: _optionAssertions.assertString,
   code: _optionAssertions.assertBoolean,
   ast: _optionAssertions.assertBoolean,
+  cloneInputAst: _optionAssertions.assertBoolean,
   envName: _optionAssertions.assertString
 };
 const BABELRC_VALIDATORS = {
@@ -117,10 +119,11 @@ function throwUnknownError(loc) {
       message,
       version = 5
     } = _removed.default[key];
-    throw new ReferenceError(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
+    throw new Error(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
   } else {
-    const unknownOptErr = `Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`;
-    throw new ReferenceError(unknownOptErr);
+    const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
+    unknownOptErr.code = "BABEL_UNKNOWN_OPTION";
+    throw unknownOptErr;
   }
 }
 
@@ -185,4 +188,10 @@ function assertOverridesList(loc, value) {
   }
 
   return arr;
+}
+
+function checkNoUnwrappedItemOptionPairs(lastItem, thisItem, type, index, e) {
+  if (lastItem.file && lastItem.options === undefined && typeof thisItem.value === "object") {
+    e.message += `\n- Maybe you meant to use\n` + `"${type}": [\n  ["${lastItem.file.request}", ${JSON.stringify(thisItem.value, undefined, 2)}]\n]\n` + `To be a valid ${type}, its name and options should be wrapped in a pair of brackets`;
+  }
 }

node_modules/@babel/core/lib/config/validation/plugins.js

@@ -18,14 +18,14 @@ const VALIDATORS = {
   generatorOverride: _optionAssertions.assertFunction
 };
 
-function assertVisitorMap(key, value) {
-  const obj = (0, _optionAssertions.assertObject)(key, value);
+function assertVisitorMap(loc, value) {
+  const obj = (0, _optionAssertions.assertObject)(loc, value);
 
   if (obj) {
     Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
 
     if (obj.enter || obj.exit) {
-      throw new Error(`.${key} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
+      throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
     }
   }
 
@@ -47,9 +47,25 @@ function assertVisitorHandler(key, value) {
 }
 
 function validatePluginObject(obj) {
+  const rootPath = {
+    type: "root",
+    source: "plugin"
+  };
   Object.keys(obj).forEach(key => {
     const validator = VALIDATORS[key];
-    if (validator) validator(key, obj[key]);else throw new Error(`.${key} is not a valid Plugin property`);
+
+    if (validator) {
+      const optLoc = {
+        type: "option",
+        name: key,
+        parent: rootPath
+      };
+      validator(optLoc, obj[key]);
+    } else {
+      const invalidPluginPropertyError = new Error(`.${key} is not a valid Plugin property`);
+      invalidPluginPropertyError.code = "BABEL_UNKNOWN_PLUGIN_PROPERTY";
+      throw invalidPluginPropertyError;
+    }
   });
   return obj;
 }