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;
 }

node_modules/@babel/core/lib/gensync-utils/async.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.maybeAsync = maybeAsync;
+exports.forwardAsync = forwardAsync;
+exports.isThenable = isThenable;
+exports.waitFor = exports.onFirstPause = exports.isAsync = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const id = x => x;
+
+const runGenerator = (0, _gensync().default)(function* (item) {
+  return yield* item;
+});
+const isAsync = (0, _gensync().default)({
+  sync: () => false,
+  errback: cb => cb(null, true)
+});
+exports.isAsync = isAsync;
+
+function maybeAsync(fn, message) {
+  return (0, _gensync().default)({
+    sync(...args) {
+      const result = fn.apply(this, args);
+      if (isThenable(result)) throw new Error(message);
+      return result;
+    },
+
+    async(...args) {
+      return Promise.resolve(fn.apply(this, args));
+    }
+
+  });
+}
+
+const withKind = (0, _gensync().default)({
+  sync: cb => cb("sync"),
+  async: cb => cb("async")
+});
+
+function forwardAsync(action, cb) {
+  const g = (0, _gensync().default)(action);
+  return withKind(kind => {
+    const adapted = g[kind];
+    return cb(adapted);
+  });
+}
+
+const onFirstPause = (0, _gensync().default)({
+  name: "onFirstPause",
+  arity: 2,
+  sync: function (item) {
+    return runGenerator.sync(item);
+  },
+  errback: function (item, firstPause, cb) {
+    let completed = false;
+    runGenerator.errback(item, (err, value) => {
+      completed = true;
+      cb(err, value);
+    });
+
+    if (!completed) {
+      firstPause();
+    }
+  }
+});
+exports.onFirstPause = onFirstPause;
+const waitFor = (0, _gensync().default)({
+  sync: id,
+  async: id
+});
+exports.waitFor = waitFor;
+
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
+}

node_modules/@babel/core/lib/gensync-utils/fs.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stat = exports.exists = exports.readFile = void 0;
+
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const readFile = (0, _gensync().default)({
+  sync: _fs().default.readFileSync,
+  errback: _fs().default.readFile
+});
+exports.readFile = readFile;
+const exists = (0, _gensync().default)({
+  sync(path) {
+    try {
+      _fs().default.accessSync(path);
+
+      return true;
+    } catch (_unused) {
+      return false;
+    }
+  },
+
+  errback: (path, cb) => _fs().default.access(path, undefined, err => cb(null, !err))
+});
+exports.exists = exists;
+const stat = (0, _gensync().default)({
+  sync: _fs().default.statSync,
+  errback: _fs().default.stat
+});
+exports.stat = stat;

node_modules/@babel/core/lib/gensync-utils/resolve.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _resolve() {
+  const data = _interopRequireDefault(require("resolve"));
+
+  _resolve = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _gensync().default)({
+  sync: _resolve().default.sync,
+  errback: _resolve().default
+});
+
+exports.default = _default;

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

@@ -70,12 +70,36 @@ Object.defineProperty(exports, "loadPartialConfig", {
     return _config.loadPartialConfig;
   }
 });
+Object.defineProperty(exports, "loadPartialConfigSync", {
+  enumerable: true,
+  get: function () {
+    return _config.loadPartialConfigSync;
+  }
+});
+Object.defineProperty(exports, "loadPartialConfigAsync", {
+  enumerable: true,
+  get: function () {
+    return _config.loadPartialConfigAsync;
+  }
+});
 Object.defineProperty(exports, "loadOptions", {
   enumerable: true,
   get: function () {
     return _config.loadOptions;
   }
 });
+Object.defineProperty(exports, "loadOptionsSync", {
+  enumerable: true,
+  get: function () {
+    return _config.loadOptionsSync;
+  }
+});
+Object.defineProperty(exports, "loadOptionsAsync", {
+  enumerable: true,
+  get: function () {
+    return _config.loadOptionsAsync;
+  }
+});
 Object.defineProperty(exports, "transform", {
   enumerable: true,
   get: function () {
@@ -219,7 +243,9 @@ var _transformAst = require("./transform-ast");
 
 var _parse = require("./parse");
 
-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 _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 }; }
 

node_modules/@babel/core/lib/parse.js

@@ -3,63 +3,48 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.parseSync = parseSync;
-exports.parseAsync = parseAsync;
-exports.parse = void 0;
+exports.parseAsync = exports.parseSync = exports.parse = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _config = _interopRequireDefault(require("./config"));
 
-var _normalizeFile = _interopRequireDefault(require("./transformation/normalize-file"));
+var _parser = _interopRequireDefault(require("./parser"));
 
 var _normalizeOpts = _interopRequireDefault(require("./transformation/normalize-opts"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const parseRunner = (0, _gensync().default)(function* parse(code, opts) {
+  const config = yield* (0, _config.default)(opts);
+
+  if (config === null) {
+    return null;
+  }
+
+  return yield* (0, _parser.default)(config.passes, (0, _normalizeOpts.default)(config), code);
+});
+
 const parse = function parse(code, opts, callback) {
   if (typeof opts === "function") {
     callback = opts;
     opts = undefined;
   }
 
-  if (callback === undefined) return parseSync(code, opts);
-  const config = (0, _config.default)(opts);
-
-  if (config === null) {
-    return null;
-  }
-
-  const cb = callback;
-  process.nextTick(() => {
-    let ast = null;
-
-    try {
-      const cfg = (0, _config.default)(opts);
-      if (cfg === null) return cb(null, null);
-      ast = (0, _normalizeFile.default)(cfg.passes, (0, _normalizeOpts.default)(cfg), code).ast;
-    } catch (err) {
-      return cb(err);
-    }
-
-    cb(null, ast);
-  });
+  if (callback === undefined) return parseRunner.sync(code, opts);
+  parseRunner.errback(code, opts, callback);
 };
 
 exports.parse = parse;
-
-function parseSync(code, opts) {
-  const config = (0, _config.default)(opts);
-
-  if (config === null) {
-    return null;
-  }
-
-  return (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code).ast;
-}
-
-function parseAsync(code, opts) {
-  return new Promise((res, rej) => {
-    parse(code, opts, (err, result) => {
-      if (err == null) res(result);else rej(err);
-    });
-  });
-}
+const parseSync = parseRunner.sync;
+exports.parseSync = parseSync;
+const parseAsync = parseRunner.async;
+exports.parseAsync = parseAsync;

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

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parser;
+
+function _parser() {
+  const data = require("@babel/parser");
+
+  _parser = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _missingPluginHelper = _interopRequireDefault(require("./util/missing-plugin-helper"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function* parser(pluginPasses, {
+  parserOpts,
+  highlightCode = true,
+  filename = "unknown"
+}, code) {
+  try {
+    const results = [];
+
+    for (const plugins of pluginPasses) {
+      for (const plugin of plugins) {
+        const {
+          parserOverride
+        } = plugin;
+
+        if (parserOverride) {
+          const ast = parserOverride(code, parserOpts, _parser().parse);
+          if (ast !== undefined) results.push(ast);
+        }
+      }
+    }
+
+    if (results.length === 0) {
+      return (0, _parser().parse)(code, parserOpts);
+    } else if (results.length === 1) {
+      yield* [];
+
+      if (typeof results[0].then === "function") {
+        throw new Error(`You appear to be using an async parser 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.`);
+      }
+
+      return results[0];
+    }
+
+    throw new Error("More than one plugin attempted to override parsing.");
+  } catch (err) {
+    if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") {
+      err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file.";
+    }
+
+    const {
+      loc,
+      missingPlugin
+    } = err;
+
+    if (loc) {
+      const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
+        start: {
+          line: loc.line,
+          column: loc.column + 1
+        }
+      }, {
+        highlightCode
+      });
+
+      if (missingPlugin) {
+        err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
+      } else {
+        err.message = `${filename}: ${err.message}\n\n` + codeFrame;
+      }
+
+      err.code = "BABEL_PARSE_ERROR";
+    }
+
+    throw err;
+  }
+}

node_modules/@babel/core/lib/parser/util/missing-plugin-helper.js

@@ -15,6 +15,32 @@ const pluginNameMap = {
       url: "https://git.io/vb4SL"
     }
   },
+  classPrivateProperties: {
+    syntax: {
+      name: "@babel/plugin-syntax-class-properties",
+      url: "https://git.io/vb4yQ"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-class-properties",
+      url: "https://git.io/vb4SL"
+    }
+  },
+  classPrivateMethods: {
+    syntax: {
+      name: "@babel/plugin-syntax-class-properties",
+      url: "https://git.io/vb4yQ"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-private-methods",
+      url: "https://git.io/JvpRG"
+    }
+  },
+  decimal: {
+    syntax: {
+      name: "@babel/plugin-syntax-decimal",
+      url: "https://git.io/JfKOH"
+    }
+  },
   decorators: {
     syntax: {
       name: "@babel/plugin-syntax-decorators",
@@ -67,8 +93,8 @@ const pluginNameMap = {
       url: "https://git.io/vb4yb"
     },
     transform: {
-      name: "@babel/plugin-transform-flow-strip-types",
-      url: "https://git.io/vb49g"
+      name: "@babel/preset-flow",
+      url: "https://git.io/JfeDn"
     }
   },
   functionBind: {
@@ -103,28 +129,14 @@ const pluginNameMap = {
       url: "https://git.io/vb4yA"
     },
     transform: {
-      name: "@babel/plugin-transform-react-jsx",
-      url: "https://git.io/vb4yd"
+      name: "@babel/preset-react",
+      url: "https://git.io/JfeDR"
     }
   },
-  logicalAssignment: {
+  moduleAttributes: {
     syntax: {
-      name: "@babel/plugin-syntax-logical-assignment-operators",
-      url: "https://git.io/vAlBp"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-logical-assignment-operators",
-      url: "https://git.io/vAlRe"
-    }
-  },
-  nullishCoalescingOperator: {
-    syntax: {
-      name: "@babel/plugin-syntax-nullish-coalescing-operator",
-      url: "https://git.io/vb4yx"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-nullish-coalescing-operator",
-      url: "https://git.io/vb4Se"
+      name: "@babel/plugin-syntax-module-attributes",
+      url: "https://git.io/JfK3k"
     }
   },
   numericSeparator: {
@@ -157,6 +169,22 @@ const pluginNameMap = {
       url: "https://git.io/vb4SU"
     }
   },
+  privateIn: {
+    syntax: {
+      name: "@babel/plugin-syntax-private-property-in-object",
+      url: "https://git.io/JfK3q"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-private-property-in-object",
+      url: "https://git.io/JfK3O"
+    }
+  },
+  recordAndTuple: {
+    syntax: {
+      name: "@babel/plugin-syntax-record-and-tuple",
+      url: "https://git.io/JvKp3"
+    }
+  },
   throwExpressions: {
     syntax: {
       name: "@babel/plugin-syntax-throw-expressions",
@@ -173,8 +201,8 @@ const pluginNameMap = {
       url: "https://git.io/vb4SC"
     },
     transform: {
-      name: "@babel/plugin-transform-typescript",
-      url: "https://git.io/vb4Sm"
+      name: "@babel/preset-typescript",
+      url: "https://git.io/JfeDz"
     }
   },
   asyncGenerators: {
@@ -187,6 +215,26 @@ const pluginNameMap = {
       url: "https://git.io/vb4yp"
     }
   },
+  logicalAssignment: {
+    syntax: {
+      name: "@babel/plugin-syntax-logical-assignment-operators",
+      url: "https://git.io/vAlBp"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-logical-assignment-operators",
+      url: "https://git.io/vAlRe"
+    }
+  },
+  nullishCoalescingOperator: {
+    syntax: {
+      name: "@babel/plugin-syntax-nullish-coalescing-operator",
+      url: "https://git.io/vb4yx"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-nullish-coalescing-operator",
+      url: "https://git.io/vb4Se"
+    }
+  },
   objectRestSpread: {
     syntax: {
       name: "@babel/plugin-syntax-object-rest-spread",
@@ -208,6 +256,7 @@ const pluginNameMap = {
     }
   }
 };
+pluginNameMap.privateIn.syntax = pluginNameMap.privateIn.transform;
 
 const getNameURLCombination = ({
   name,
@@ -225,11 +274,14 @@ function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
     } = pluginInfo;
 
     if (syntaxPlugin) {
+      const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
+
       if (transformPlugin) {
         const transformPluginInfo = getNameURLCombination(transformPlugin);
-        helpMessage += `\n\nAdd ${transformPluginInfo} to the 'plugins' section of your Babel config ` + `to enable transformation.`;
+        const sectionType = transformPlugin.name.startsWith("@babel/plugin") ? "plugins" : "presets";
+        helpMessage += `\n\nAdd ${transformPluginInfo} to the '${sectionType}' section of your Babel config to enable transformation.
+If you want to leave it as-is, add ${syntaxPluginInfo} to the 'plugins' section to enable parsing.`;
       } else {
-        const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
         helpMessage += `\n\nAdd ${syntaxPluginInfo} to the 'plugins' section of your Babel config ` + `to enable parsing.`;
       }
     }

node_modules/@babel/core/lib/tools/build-external-helpers.js

@@ -45,11 +45,15 @@ function t() {
   return data;
 }
 
+var _file = _interopRequireDefault(require("../transformation/file/file"));
+
 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 _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-const buildUmdWrapper = replacements => _template().default`
+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; }
+
+const buildUmdWrapper = replacements => (0, _template().default)`
     (function (root, factory) {
       if (typeof define === "function" && define.amd) {
         define(AMD_ARGUMENTS, factory);
@@ -63,30 +67,30 @@ const buildUmdWrapper = replacements => _template().default`
     });
   `(replacements);
 
-function buildGlobal(whitelist) {
+function buildGlobal(allowlist) {
   const namespace = t().identifier("babelHelpers");
   const body = [];
   const container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
   const tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]);
   body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().assignmentExpression("=", t().memberExpression(t().identifier("global"), namespace), t().objectExpression([])))]));
-  buildHelpers(body, namespace, whitelist);
+  buildHelpers(body, namespace, allowlist);
   return tree;
 }
 
-function buildModule(whitelist) {
+function buildModule(allowlist) {
   const body = [];
-  const refs = buildHelpers(body, null, whitelist);
+  const refs = buildHelpers(body, null, allowlist);
   body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(name => {
     return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name));
   })));
   return t().program(body, [], "module");
 }
 
-function buildUmd(whitelist) {
+function buildUmd(allowlist) {
   const namespace = t().identifier("babelHelpers");
   const body = [];
   body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().identifier("global"))]));
-  buildHelpers(body, namespace, whitelist);
+  buildHelpers(body, namespace, allowlist);
   return t().program([buildUmdWrapper({
     FACTORY_PARAMETERS: t().identifier("global"),
     BROWSER_ARGUMENTS: t().assignmentExpression("=", t().memberExpression(t().identifier("root"), namespace), t().objectExpression([])),
@@ -97,25 +101,26 @@ function buildUmd(whitelist) {
   })]);
 }
 
-function buildVar(whitelist) {
+function buildVar(allowlist) {
   const namespace = t().identifier("babelHelpers");
   const body = [];
   body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))]));
   const tree = t().program(body);
-  buildHelpers(body, namespace, whitelist);
+  buildHelpers(body, namespace, allowlist);
   body.push(t().expressionStatement(namespace));
   return tree;
 }
 
-function buildHelpers(body, namespace, whitelist) {
+function buildHelpers(body, namespace, allowlist) {
   const getHelperReference = name => {
     return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier(`_${name}`);
   };
 
   const refs = {};
   helpers().list.forEach(function (name) {
-    if (whitelist && whitelist.indexOf(name) < 0) return;
+    if (allowlist && allowlist.indexOf(name) < 0) return;
     const ref = refs[name] = getHelperReference(name);
+    helpers().ensure(name, _file.default);
     const {
       nodes
     } = helpers().get(name, getHelperReference, ref);
@@ -124,7 +129,7 @@ function buildHelpers(body, namespace, whitelist) {
   return refs;
 }
 
-function _default(whitelist, outputType = "global") {
+function _default(allowlist, outputType = "global") {
   let tree;
   const build = {
     global: buildGlobal,
@@ -134,7 +139,7 @@ function _default(whitelist, outputType = "global") {
   }[outputType];
 
   if (build) {
-    tree = build(whitelist);
+    tree = build(allowlist);
   } else {
     throw new Error(`Unsupported output type ${outputType}`);
   }

node_modules/@babel/core/lib/transform-ast.js

@@ -3,9 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformFromAstSync = transformFromAstSync;
-exports.transformFromAstAsync = transformFromAstAsync;
-exports.transformFromAst = void 0;
+exports.transformFromAstAsync = exports.transformFromAstSync = exports.transformFromAst = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _config = _interopRequireDefault(require("./config"));
 
@@ -13,42 +21,28 @@ var _transformation = require("./transformation");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const transformFromAstRunner = (0, _gensync().default)(function* (ast, code, opts) {
+  const config = yield* (0, _config.default)(opts);
+  if (config === null) return null;
+  if (!ast) throw new Error("No AST given");
+  return yield* (0, _transformation.run)(config, code, ast);
+});
+
 const transformFromAst = function transformFromAst(ast, code, opts, callback) {
   if (typeof opts === "function") {
     callback = opts;
     opts = undefined;
   }
 
-  if (callback === undefined) return transformFromAstSync(ast, code, opts);
-  const cb = callback;
-  process.nextTick(() => {
-    let cfg;
+  if (callback === undefined) {
+    return transformFromAstRunner.sync(ast, code, opts);
+  }
 
-    try {
-      cfg = (0, _config.default)(opts);
-      if (cfg === null) return cb(null, null);
-    } catch (err) {
-      return cb(err);
-    }
-
-    if (!ast) return cb(new Error("No AST given"));
-    (0, _transformation.runAsync)(cfg, code, ast, cb);
-  });
+  transformFromAstRunner.errback(ast, code, opts, callback);
 };
 
 exports.transformFromAst = transformFromAst;
-
-function transformFromAstSync(ast, code, opts) {
-  const config = (0, _config.default)(opts);
-  if (config === null) return null;
-  if (!ast) throw new Error("No AST given");
-  return (0, _transformation.runSync)(config, code, ast);
-}
-
-function transformFromAstAsync(ast, code, opts) {
-  return new Promise((res, rej) => {
-    transformFromAst(ast, code, opts, (err, result) => {
-      if (err == null) res(result);else rej(err);
-    });
-  });
-}
+const transformFromAstSync = transformFromAstRunner.sync;
+exports.transformFromAstSync = transformFromAstSync;
+const transformFromAstAsync = transformFromAstRunner.async;
+exports.transformFromAstAsync = transformFromAstAsync;

node_modules/@babel/core/lib/transform-file.js

@@ -3,14 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformFileSync = transformFileSync;
-exports.transformFileAsync = transformFileAsync;
-exports.transformFile = void 0;
+exports.transformFileAsync = exports.transformFileSync = exports.transformFile = void 0;
 
-function _fs() {
-  const data = _interopRequireDefault(require("fs"));
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
 
-  _fs = function () {
+  _gensync = function () {
     return data;
   };
 
@@ -21,71 +19,27 @@ var _config = _interopRequireDefault(require("./config"));
 
 var _transformation = require("./transformation");
 
+var fs = _interopRequireWildcard(require("./gensync-utils/fs"));
+
+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 transformFile = function transformFile(filename, opts, callback) {
-  let options;
-
-  if (typeof opts === "function") {
-    callback = opts;
-    opts = undefined;
-  }
-
-  if (opts == null) {
-    options = {
-      filename
-    };
-  } else if (opts && typeof opts === "object") {
-    options = Object.assign({}, opts, {
-      filename
-    });
-  }
-
-  process.nextTick(() => {
-    let cfg;
-
-    try {
-      cfg = (0, _config.default)(options);
-      if (cfg === null) return callback(null, null);
-    } catch (err) {
-      return callback(err);
-    }
-
-    const config = cfg;
-
-    _fs().default.readFile(filename, "utf8", function (err, code) {
-      if (err) return callback(err, null);
-      (0, _transformation.runAsync)(config, code, null, callback);
-    });
+const transformFileRunner = (0, _gensync().default)(function* (filename, opts) {
+  const options = Object.assign({}, opts, {
+    filename
   });
-};
-
-exports.transformFile = transformFile;
-
-function transformFileSync(filename, opts) {
-  let options;
-
-  if (opts == null) {
-    options = {
-      filename
-    };
-  } else if (opts && typeof opts === "object") {
-    options = Object.assign({}, opts, {
-      filename
-    });
-  }
-
-  const config = (0, _config.default)(options);
+  const config = yield* (0, _config.default)(options);
   if (config === null) return null;
-  return (0, _transformation.runSync)(config, _fs().default.readFileSync(filename, "utf8"));
-}
-
-function transformFileAsync(filename, opts) {
-  return new Promise((res, rej) => {
-    transformFile(filename, opts, (err, result) => {
-      if (err == null) res(result);else rej(err);
-    });
-  });
-}
+  const code = yield* fs.readFile(filename, "utf8");
+  return yield* (0, _transformation.run)(config, code);
+});
+const transformFile = transformFileRunner.errback;
+exports.transformFile = transformFile;
+const transformFileSync = transformFileRunner.sync;
+exports.transformFileSync = transformFileSync;
+const transformFileAsync = transformFileRunner.async;
+exports.transformFileAsync = transformFileAsync;

node_modules/@babel/core/lib/transform.js

@@ -3,9 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformSync = transformSync;
-exports.transformAsync = transformAsync;
-exports.transform = void 0;
+exports.transformAsync = exports.transformSync = exports.transform = void 0;
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _config = _interopRequireDefault(require("./config"));
 
@@ -13,40 +21,24 @@ var _transformation = require("./transformation");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const transformRunner = (0, _gensync().default)(function* transform(code, opts) {
+  const config = yield* (0, _config.default)(opts);
+  if (config === null) return null;
+  return yield* (0, _transformation.run)(config, code);
+});
+
 const transform = function transform(code, opts, callback) {
   if (typeof opts === "function") {
     callback = opts;
     opts = undefined;
   }
 
-  if (callback === undefined) return transformSync(code, opts);
-  const cb = callback;
-  process.nextTick(() => {
-    let cfg;
-
-    try {
-      cfg = (0, _config.default)(opts);
-      if (cfg === null) return cb(null, null);
-    } catch (err) {
-      return cb(err);
-    }
-
-    (0, _transformation.runAsync)(cfg, code, null, cb);
-  });
+  if (callback === undefined) return transformRunner.sync(code, opts);
+  transformRunner.errback(code, opts, callback);
 };
 
 exports.transform = transform;
-
-function transformSync(code, opts) {
-  const config = (0, _config.default)(opts);
-  if (config === null) return null;
-  return (0, _transformation.runSync)(config, code);
-}
-
-function transformAsync(code, opts) {
-  return new Promise((res, rej) => {
-    transform(code, opts, (err, result) => {
-      if (err == null) res(result);else rej(err);
-    });
-  });
-}
+const transformSync = transformRunner.sync;
+exports.transformSync = transformSync;
+const transformAsync = transformRunner.async;
+exports.transformAsync = transformAsync;

node_modules/@babel/core/lib/transformation/block-hoist-plugin.js

@@ -23,11 +23,12 @@ let LOADED_PLUGIN;
 
 function loadBlockHoistPlugin() {
   if (!LOADED_PLUGIN) {
-    const config = (0, _config.default)({
+    const config = _config.default.sync({
       babelrc: false,
       configFile: false,
       plugins: [blockHoistPlugin]
     });
+
     LOADED_PLUGIN = config ? config.passes[0][0] : undefined;
     if (!LOADED_PLUGIN) throw new Error("Assertion failure");
   }
@@ -47,7 +48,7 @@ const blockHoistPlugin = {
         for (let i = 0; i < node.body.length; i++) {
           const bodyNode = node.body[i];
 
-          if (bodyNode && bodyNode._blockHoist != null) {
+          if ((bodyNode == null ? void 0 : bodyNode._blockHoist) != null) {
             hasChange = true;
             break;
           }
@@ -55,7 +56,7 @@ const blockHoistPlugin = {
 
         if (!hasChange) return;
         node.body = (0, _sortBy().default)(node.body, function (bodyNode) {
-          let priority = bodyNode && bodyNode._blockHoist;
+          let priority = bodyNode == null ? void 0 : bodyNode._blockHoist;
           if (priority == null) priority = 1;
           if (priority === true) priority = 2;
           return -1 * priority;

node_modules/@babel/core/lib/transformation/file/file.js

@@ -45,6 +45,16 @@ function t() {
   return data;
 }
 
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _semver() {
   const data = _interopRequireDefault(require("semver"));
 
@@ -57,7 +67,9 @@ function _semver() {
 
 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 _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; }
 
 const errorVisitor = {
   enter(path, state) {
@@ -137,36 +149,7 @@ class File {
   }
 
   getModuleName() {
-    const {
-      filename,
-      filenameRelative = filename,
-      moduleId,
-      moduleIds = !!moduleId,
-      getModuleId,
-      sourceRoot: sourceRootTmp,
-      moduleRoot = sourceRootTmp,
-      sourceRoot = moduleRoot
-    } = this.opts;
-    if (!moduleIds) return null;
-
-    if (moduleId != null && !getModuleId) {
-      return moduleId;
-    }
-
-    let moduleName = moduleRoot != null ? moduleRoot + "/" : "";
-
-    if (filenameRelative) {
-      const sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : "";
-      moduleName += filenameRelative.replace(sourceRootReplacer, "").replace(/\.(\w*?)$/, "");
-    }
-
-    moduleName = moduleName.replace(/\\/g, "/");
-
-    if (getModuleId) {
-      return getModuleId(moduleName) || moduleName;
-    } else {
-      return moduleName;
-    }
+    return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts);
   }
 
   addImport() {
@@ -198,7 +181,7 @@ class File {
       if (res) return res;
     }
 
-    helpers().ensure(name);
+    helpers().ensure(name, File);
     const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
     const dependencies = {};
 
@@ -232,7 +215,6 @@ class File {
 
   buildCodeFrameError(node, msg, Error = SyntaxError) {
     let loc = node && (node.loc || node._loc);
-    msg = `${this.opts.filename}: ${msg}`;
 
     if (!loc && node) {
       const state = {
@@ -253,7 +235,11 @@ class File {
         start: {
           line: loc.start.line,
           column: loc.start.column + 1
-        }
+        },
+        end: loc.end && loc.start.line === loc.end.line ? {
+          line: loc.end.line,
+          column: loc.end.column + 1
+        } : undefined
       }, {
         highlightCode
       });

node_modules/@babel/core/lib/transformation/file/generate.js

@@ -59,7 +59,7 @@ function generateCode(pluginPasses, file) {
     result = results[0];
 
     if (typeof result.then === "function") {
-      throw new Error(`You appear to be using an async parser 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.`);
+      throw new Error(`You appear to be using an async codegen 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.`);
     }
   } else {
     throw new Error("More than one plugin attempted to override codegen.");

node_modules/@babel/core/lib/transformation/file/merge-map.js

@@ -22,11 +22,9 @@ function mergeSourceMap(inputMap, map) {
   const output = buildMappingData(map);
   const mergedGenerator = new (_sourceMap().default.SourceMapGenerator)();
 
-  for (const _ref of input.sources) {
-    const {
-      source
-    } = _ref;
-
+  for (const {
+    source
+  } of input.sources) {
     if (typeof source.content === "string") {
       mergedGenerator.setSourceContent(source.path, source.content);
     }
@@ -95,11 +93,9 @@ function makeMappingKey(item) {
 function eachOverlappingGeneratedOutputRange(outputFile, inputGeneratedRange, callback) {
   const overlappingOriginal = filterApplicableOriginalRanges(outputFile, inputGeneratedRange);
 
-  for (const _ref2 of overlappingOriginal) {
-    const {
-      generated
-    } = _ref2;
-
+  for (const {
+    generated
+  } of overlappingOriginal) {
     for (const item of generated) {
       callback(item);
     }
@@ -125,18 +121,14 @@ function filterApplicableOriginalRanges({
 }
 
 function eachInputGeneratedRange(map, callback) {
-  for (const _ref3 of map.sources) {
-    const {
-      source,
-      mappings
-    } = _ref3;
-
-    for (const _ref4 of mappings) {
-      const {
-        original,
-        generated
-      } = _ref4;
-
+  for (const {
+    source,
+    mappings
+  } of map.sources) {
+    for (const {
+      original,
+      generated
+    } of mappings) {
       for (const item of generated) {
         callback(item, original, source);
       }

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

@@ -3,8 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runAsync = runAsync;
-exports.runSync = runSync;
+exports.run = run;
 
 function _traverse() {
   const data = _interopRequireDefault(require("@babel/traverse"));
@@ -28,26 +27,45 @@ var _generate = _interopRequireDefault(require("./file/generate"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function runAsync(config, code, ast, callback) {
-  let result;
+function* run(config, code, ast) {
+  const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
+  const opts = file.opts;
 
   try {
-    result = runSync(config, code, ast);
-  } catch (err) {
-    return callback(err);
+    yield* transformFile(file, config.passes);
+  } catch (e) {
+    var _opts$filename;
+
+    e.message = `${(_opts$filename = opts.filename) != null ? _opts$filename : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_TRANSFORM_ERROR";
+    }
+
+    throw e;
   }
 
-  return callback(null, result);
-}
+  let outputCode, outputMap;
+
+  try {
+    if (opts.code !== false) {
+      ({
+        outputCode,
+        outputMap
+      } = (0, _generate.default)(config.passes, file));
+    }
+  } catch (e) {
+    var _opts$filename2;
+
+    e.message = `${(_opts$filename2 = opts.filename) != null ? _opts$filename2 : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_GENERATE_ERROR";
+    }
+
+    throw e;
+  }
 
-function runSync(config, code, ast) {
-  const file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
-  transformFile(file, config.passes);
-  const opts = file.opts;
-  const {
-    outputCode,
-    outputMap
-  } = opts.code !== false ? (0, _generate.default)(config.passes, file) : {};
   return {
     metadata: file.metadata,
     options: opts,
@@ -58,7 +76,7 @@ function runSync(config, code, ast) {
   };
 }
 
-function transformFile(file, pluginPasses) {
+function* transformFile(file, pluginPasses) {
   for (const pluginPairs of pluginPasses) {
     const passPairs = [];
     const passes = [];
@@ -76,6 +94,7 @@ function transformFile(file, pluginPasses) {
 
       if (fn) {
         const result = fn.call(pass, file);
+        yield* [];
 
         if (isThenable(result)) {
           throw new Error(`You appear to be using an plugin with an async .pre, ` + `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.`);
@@ -92,6 +111,7 @@ function transformFile(file, pluginPasses) {
 
       if (fn) {
         const result = fn.call(pass, file);
+        yield* [];
 
         if (isThenable(result)) {
           throw new Error(`You appear to be using an plugin with an async .post, ` + `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.`);

node_modules/@babel/core/lib/transformation/normalize-file.js

@@ -5,6 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = normalizeFile;
 
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _path() {
   const data = _interopRequireDefault(require("path"));
 
@@ -55,76 +65,21 @@ function _convertSourceMap() {
   return data;
 }
 
-function _parser() {
-  const data = require("@babel/parser");
-
-  _parser = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _codeFrame() {
-  const data = require("@babel/code-frame");
-
-  _codeFrame = function () {
-    return data;
-  };
-
-  return data;
-}
-
 var _file = _interopRequireDefault(require("./file/file"));
 
-var _missingPluginHelper = _interopRequireDefault(require("./util/missing-plugin-helper"));
+var _parser = _interopRequireDefault(require("../parser"));
 
-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 _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:transform:file");
+const LARGE_INPUT_SOURCEMAP_THRESHOLD = 1000000;
 
-function normalizeFile(pluginPasses, options, code, ast) {
+function* normalizeFile(pluginPasses, options, code, ast) {
   code = `${code || ""}`;
-  let inputMap = null;
-
-  if (options.inputSourceMap !== false) {
-    if (typeof options.inputSourceMap === "object") {
-      inputMap = _convertSourceMap().default.fromObject(options.inputSourceMap);
-    }
-
-    if (!inputMap) {
-      try {
-        inputMap = _convertSourceMap().default.fromSource(code);
-
-        if (inputMap) {
-          code = _convertSourceMap().default.removeComments(code);
-        }
-      } catch (err) {
-        debug("discarding unknown inline input sourcemap", err);
-        code = _convertSourceMap().default.removeComments(code);
-      }
-    }
-
-    if (!inputMap) {
-      if (typeof options.filename === "string") {
-        try {
-          inputMap = _convertSourceMap().default.fromMapFileSource(code, _path().default.dirname(options.filename));
-
-          if (inputMap) {
-            code = _convertSourceMap().default.removeMapFileComments(code);
-          }
-        } catch (err) {
-          debug("discarding unknown file input sourcemap", err);
-          code = _convertSourceMap().default.removeMapFileComments(code);
-        }
-      } else {
-        debug("discarding un-loadable file input sourcemap");
-        code = _convertSourceMap().default.removeMapFileComments(code);
-      }
-    }
-  }
 
   if (ast) {
     if (ast.type === "Program") {
@@ -133,9 +88,57 @@ function normalizeFile(pluginPasses, options, code, ast) {
       throw new Error("AST root must be a Program or File node");
     }
 
-    ast = (0, _cloneDeep().default)(ast);
+    const {
+      cloneInputAst
+    } = options;
+
+    if (cloneInputAst) {
+      ast = (0, _cloneDeep().default)(ast);
+    }
   } else {
-    ast = parser(pluginPasses, options, code);
+    ast = yield* (0, _parser.default)(pluginPasses, options, code);
+  }
+
+  let inputMap = null;
+
+  if (options.inputSourceMap !== false) {
+    if (typeof options.inputSourceMap === "object") {
+      inputMap = _convertSourceMap().default.fromObject(options.inputSourceMap);
+    }
+
+    if (!inputMap) {
+      const lastComment = extractComments(INLINE_SOURCEMAP_REGEX, ast);
+
+      if (lastComment) {
+        try {
+          inputMap = _convertSourceMap().default.fromComment(lastComment);
+        } catch (err) {
+          debug("discarding unknown inline input sourcemap", err);
+        }
+      }
+    }
+
+    if (!inputMap) {
+      const lastComment = extractComments(EXTERNAL_SOURCEMAP_REGEX, ast);
+
+      if (typeof options.filename === "string" && lastComment) {
+        try {
+          const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment);
+
+          const inputMapContent = _fs().default.readFileSync(_path().default.resolve(_path().default.dirname(options.filename), match[1]));
+
+          if (inputMapContent.length > LARGE_INPUT_SOURCEMAP_THRESHOLD) {
+            debug("skip merging input map > 1 MB");
+          } else {
+            inputMap = _convertSourceMap().default.fromJSON(inputMapContent);
+          }
+        } catch (err) {
+          debug("discarding unknown file input sourcemap", err);
+        }
+      } else if (lastComment) {
+        debug("discarding un-loadable file input sourcemap");
+      }
+    }
   }
 
   return new _file.default(options, {
@@ -145,67 +148,32 @@ function normalizeFile(pluginPasses, options, code, ast) {
   });
 }
 
-function parser(pluginPasses, {
-  parserOpts,
-  highlightCode = true,
-  filename = "unknown"
-}, code) {
-  try {
-    const results = [];
+const INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/;
+const EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
 
-    for (const plugins of pluginPasses) {
-      for (const plugin of plugins) {
-        const {
-          parserOverride
-        } = plugin;
-
-        if (parserOverride) {
-          const ast = parserOverride(code, parserOpts, _parser().parse);
-          if (ast !== undefined) results.push(ast);
-        }
-      }
-    }
-
-    if (results.length === 0) {
-      return (0, _parser().parse)(code, parserOpts);
-    } else if (results.length === 1) {
-      if (typeof results[0].then === "function") {
-        throw new Error(`You appear to be using an async codegen 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.`);
+function extractCommentsFromList(regex, comments, lastComment) {
+  if (comments) {
+    comments = comments.filter(({
+      value
+    }) => {
+      if (regex.test(value)) {
+        lastComment = value;
+        return false;
       }
 
-      return results[0];
-    }
-
-    throw new Error("More than one plugin attempted to override parsing.");
-  } catch (err) {
-    if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") {
-      err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file.";
-    }
-
-    const {
-      loc,
-      missingPlugin
-    } = err;
-
-    if (loc) {
-      const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
-        start: {
-          line: loc.line,
-          column: loc.column + 1
-        }
-      }, {
-        highlightCode
-      });
-
-      if (missingPlugin) {
-        err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
-      } else {
-        err.message = `${filename}: ${err.message}\n\n` + codeFrame;
-      }
-
-      err.code = "BABEL_PARSE_ERROR";
-    }
-
-    throw err;
+      return true;
+    });
   }
+
+  return [comments, lastComment];
+}
+
+function extractComments(regex, ast) {
+  let lastComment = null;
+  t().traverseFast(ast, node => {
+    [node.leadingComments, lastComment] = extractCommentsFromList(regex, node.leadingComments, lastComment);
+    [node.innerComments, lastComment] = extractCommentsFromList(regex, node.innerComments, lastComment);
+    [node.trailingComments, lastComment] = extractCommentsFromList(regex, node.trailingComments, lastComment);
+  });
+  return lastComment;
 }

node_modules/@babel/core/node_modules/debug/package.json

@@ -1,33 +1,27 @@
 {
-  "_args": [
-    [
-      "debug@4.1.1",
-      "/Users/pjquirk/Source/GitHub/actions/labeler"
-    ]
-  ],
-  "_development": true,
-  "_from": "debug@4.1.1",
+  "_from": "debug@^4.1.0",
   "_id": "debug@4.1.1",
   "_inBundle": false,
   "_integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
   "_location": "/@babel/core/debug",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "debug@4.1.1",
+    "raw": "debug@^4.1.0",
     "name": "debug",
     "escapedName": "debug",
-    "rawSpec": "4.1.1",
+    "rawSpec": "^4.1.0",
     "saveSpec": null,
-    "fetchSpec": "4.1.1"
+    "fetchSpec": "^4.1.0"
   },
   "_requiredBy": [
     "/@babel/core"
   ],
   "_resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
-  "_spec": "4.1.1",
-  "_where": "/Users/pjquirk/Source/GitHub/actions/labeler",
+  "_shasum": "3b72260255109c6b589cee050f1d516139664791",
+  "_spec": "debug@^4.1.0",
+  "_where": "/Users/dakale/dev/GitHub/actions/labeler/node_modules/@babel/core",
   "author": {
     "name": "TJ Holowaychuk",
     "email": "tj@vision-media.ca"
@@ -36,6 +30,7 @@
   "bugs": {
     "url": "https://github.com/visionmedia/debug/issues"
   },
+  "bundleDependencies": false,
   "contributors": [
     {
       "name": "Nathan Rajlich",
@@ -50,6 +45,7 @@
   "dependencies": {
     "ms": "^2.1.1"
   },
+  "deprecated": false,
   "description": "small debugging utility",
   "devDependencies": {
     "@babel/cli": "^7.0.0",

node_modules/@babel/core/node_modules/ms/package.json

@@ -1,36 +1,32 @@
 {
-  "_args": [
-    [
-      "ms@2.1.2",
-      "/Users/pjquirk/Source/GitHub/actions/labeler"
-    ]
-  ],
-  "_development": true,
-  "_from": "ms@2.1.2",
+  "_from": "ms@^2.1.1",
   "_id": "ms@2.1.2",
   "_inBundle": false,
   "_integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
   "_location": "/@babel/core/ms",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "ms@2.1.2",
+    "raw": "ms@^2.1.1",
     "name": "ms",
     "escapedName": "ms",
-    "rawSpec": "2.1.2",
+    "rawSpec": "^2.1.1",
     "saveSpec": null,
-    "fetchSpec": "2.1.2"
+    "fetchSpec": "^2.1.1"
   },
   "_requiredBy": [
     "/@babel/core/debug"
   ],
   "_resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-  "_spec": "2.1.2",
-  "_where": "/Users/pjquirk/Source/GitHub/actions/labeler",
+  "_shasum": "d09d1f357b443f493382a8eb3ccd183872ae6009",
+  "_spec": "ms@^2.1.1",
+  "_where": "/Users/dakale/dev/GitHub/actions/labeler/node_modules/@babel/core/node_modules/debug",
   "bugs": {
     "url": "https://github.com/zeit/ms/issues"
   },
+  "bundleDependencies": false,
+  "deprecated": false,
   "description": "Tiny millisecond conversion utility",
   "devDependencies": {
     "eslint": "4.12.1",

node_modules/@babel/core/node_modules/semver/README.md

@@ -398,14 +398,15 @@ range, use the `satisfies(version, range)` function.
 
 * `coerce(version)`: Coerces a string to semver if possible
 
-This aims to provide a very forgiving translation of a non-semver
-string to semver. It looks for the first digit in a string, and
-consumes all remaining characters which satisfy at least a partial semver
-(e.g., `1`, `1.2`, `1.2.3`) up to the max permitted length (256 characters).
-Longer versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).
-All surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes `3.4.0`).
-Only text which lacks digits will fail coercion (`version one` is not valid).
-The maximum  length for any semver component considered for coercion is 16 characters;
-longer components will be ignored (`10000000000000000.4.7.4` becomes `4.7.4`).
-The maximum value for any semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`;
-higher value components are invalid (`9999999999999999.4.7.4` is likely invalid).
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).

node_modules/@babel/core/node_modules/semver/package.json

@@ -1,39 +1,35 @@
 {
-  "_args": [
-    [
-      "semver@5.7.0",
-      "/Users/pjquirk/Source/GitHub/actions/labeler"
-    ]
-  ],
-  "_development": true,
-  "_from": "semver@5.7.0",
-  "_id": "semver@5.7.0",
+  "_from": "semver@^5.4.1",
+  "_id": "semver@5.7.1",
   "_inBundle": false,
-  "_integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==",
+  "_integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
   "_location": "/@babel/core/semver",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "semver@5.7.0",
+    "raw": "semver@^5.4.1",
     "name": "semver",
     "escapedName": "semver",
-    "rawSpec": "5.7.0",
+    "rawSpec": "^5.4.1",
     "saveSpec": null,
-    "fetchSpec": "5.7.0"
+    "fetchSpec": "^5.4.1"
   },
   "_requiredBy": [
     "/@babel/core"
   ],
-  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.0.tgz",
-  "_spec": "5.7.0",
-  "_where": "/Users/pjquirk/Source/GitHub/actions/labeler",
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+  "_shasum": "a954f931aeba508d307bbf069eff0c01c96116f7",
+  "_spec": "semver@^5.4.1",
+  "_where": "/Users/dakale/dev/GitHub/actions/labeler/node_modules/@babel/core",
   "bin": {
     "semver": "./bin/semver"
   },
   "bugs": {
     "url": "https://github.com/npm/node-semver/issues"
   },
+  "bundleDependencies": false,
+  "deprecated": false,
   "description": "The semantic version parser used by npm.",
   "devDependencies": {
     "tap": "^13.0.0-rc.18"
@@ -60,5 +56,5 @@
   "tap": {
     "check-coverage": true
   },
-  "version": "5.7.0"
+  "version": "5.7.1"
 }

node_modules/@babel/core/node_modules/source-map/package.json

@@ -1,33 +1,27 @@
 {
-  "_args": [
-    [
-      "source-map@0.5.7",
-      "/Users/pjquirk/Source/GitHub/actions/labeler"
-    ]
-  ],
-  "_development": true,
-  "_from": "source-map@0.5.7",
+  "_from": "source-map@^0.5.0",
   "_id": "source-map@0.5.7",
   "_inBundle": false,
   "_integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
   "_location": "/@babel/core/source-map",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "source-map@0.5.7",
+    "raw": "source-map@^0.5.0",
     "name": "source-map",
     "escapedName": "source-map",
-    "rawSpec": "0.5.7",
+    "rawSpec": "^0.5.0",
     "saveSpec": null,
-    "fetchSpec": "0.5.7"
+    "fetchSpec": "^0.5.0"
   },
   "_requiredBy": [
     "/@babel/core"
   ],
   "_resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-  "_spec": "0.5.7",
-  "_where": "/Users/pjquirk/Source/GitHub/actions/labeler",
+  "_shasum": "8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc",
+  "_spec": "source-map@^0.5.0",
+  "_where": "/Users/dakale/dev/GitHub/actions/labeler/node_modules/@babel/core",
   "author": {
     "name": "Nick Fitzgerald",
     "email": "nfitzgerald@mozilla.com"
@@ -35,6 +29,7 @@
   "bugs": {
     "url": "https://github.com/mozilla/source-map/issues"
   },
+  "bundleDependencies": false,
   "contributors": [
     {
       "name": "Tobias Koppers",
@@ -181,6 +176,7 @@
       "email": "nicolas.lalevee@hibnet.org"
     }
   ],
+  "deprecated": false,
   "description": "Generates and consumes source maps",
   "devDependencies": {
     "doctoc": "^0.15.0",

node_modules/@babel/core/package.json

@@ -1,68 +1,74 @@
 {
-  "_args": [
-    [
-      "@babel/core@7.5.5",
-      "/Users/pjquirk/Source/GitHub/actions/labeler"
-    ]
-  ],
-  "_development": true,
-  "_from": "@babel/core@7.5.5",
-  "_id": "@babel/core@7.5.5",
+  "_from": "@babel/core@^7.1.0",
+  "_id": "@babel/core@7.11.6",
   "_inBundle": false,
-  "_integrity": "sha512-i4qoSr2KTtce0DmkuuQBV4AuQgGPUcPXMr9L5MyYAtk06z068lQ10a4O009fe5OB/DfNV+h+qqT7ddNV8UnRjg==",
+  "_integrity": "sha512-Wpcv03AGnmkgm6uS6k8iwhIwTrcP0m17TL1n1sy7qD0qelDu4XNeW0dN0mHfa+Gei211yDaLoEe/VlbXQzM4Bg==",
   "_location": "/@babel/core",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "@babel/core@7.5.5",
+    "raw": "@babel/core@^7.1.0",
     "name": "@babel/core",
     "escapedName": "@babel%2fcore",
     "scope": "@babel",
-    "rawSpec": "7.5.5",
+    "rawSpec": "^7.1.0",
     "saveSpec": null,
-    "fetchSpec": "7.5.5"
+    "fetchSpec": "^7.1.0"
   },
   "_requiredBy": [
     "/@jest/transform",
     "/jest-config"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/core/-/core-7.5.5.tgz",
-  "_spec": "7.5.5",
-  "_where": "/Users/pjquirk/Source/GitHub/actions/labeler",
+  "_resolved": "https://registry.npmjs.org/@babel/core/-/core-7.11.6.tgz",
+  "_shasum": "3a9455dc7387ff1bac45770650bc13ba04a15651",
+  "_spec": "@babel/core@^7.1.0",
+  "_where": "/Users/dakale/dev/GitHub/actions/labeler/node_modules/@jest/transform",
   "author": {
     "name": "Sebastian McKenzie",
     "email": "sebmck@gmail.com"
   },
   "browser": {
     "./lib/config/files/index.js": "./lib/config/files/index-browser.js",
-    "./lib/transform-file.js": "./lib/transform-file-browser.js"
+    "./lib/transform-file.js": "./lib/transform-file-browser.js",
+    "./src/config/files/index.js": "./src/config/files/index-browser.js",
+    "./src/transform-file.js": "./src/transform-file-browser.js"
   },
+  "bugs": {
+    "url": "https://github.com/babel/babel/issues"
+  },
+  "bundleDependencies": false,
   "dependencies": {
-    "@babel/code-frame": "^7.5.5",
-    "@babel/generator": "^7.5.5",
-    "@babel/helpers": "^7.5.5",
-    "@babel/parser": "^7.5.5",
-    "@babel/template": "^7.4.4",
-    "@babel/traverse": "^7.5.5",
-    "@babel/types": "^7.5.5",
-    "convert-source-map": "^1.1.0",
+    "@babel/code-frame": "^7.10.4",
+    "@babel/generator": "^7.11.6",
+    "@babel/helper-module-transforms": "^7.11.0",
+    "@babel/helpers": "^7.10.4",
+    "@babel/parser": "^7.11.5",
+    "@babel/template": "^7.10.4",
+    "@babel/traverse": "^7.11.5",
+    "@babel/types": "^7.11.5",
+    "convert-source-map": "^1.7.0",
     "debug": "^4.1.0",
-    "json5": "^2.1.0",
-    "lodash": "^4.17.13",
+    "gensync": "^1.0.0-beta.1",
+    "json5": "^2.1.2",
+    "lodash": "^4.17.19",
     "resolve": "^1.3.2",
     "semver": "^5.4.1",
     "source-map": "^0.5.0"
   },
+  "deprecated": false,
   "description": "Babel compiler core.",
   "devDependencies": {
-    "@babel/helper-transform-fixture-test-runner": "^7.5.5",
-    "@babel/register": "^7.5.5"
+    "@babel/helper-transform-fixture-test-runner": "^7.11.6"
   },
   "engines": {
     "node": ">=6.9.0"
   },
-  "gitHead": "0407f034f09381b95e9cabefbf6b176c76485a43",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/babel"
+  },
+  "gitHead": "e51139d7fd850e7f5b8cd6aafb17cc88b7010218",
   "homepage": "https://babeljs.io/",
   "keywords": [
     "6to5",
@@ -87,7 +93,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/babel/babel/tree/master/packages/babel-core"
+    "url": "git+https://github.com/babel/babel.git",
+    "directory": "packages/babel-core"
   },
-  "version": "7.5.5"
+  "version": "7.11.6"
 }