text: "use strict";
  
  var _v8flags = require("v8flags");
  
  var _path = require("path");
  
  var _child_process = require("child_process");
  
  var _url = require("url");
  
  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
  
  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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 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); }); }; }
  
  const args = [_path.join(_path.dirname(__filename), "_babel-node")];
  let babelArgs = process.argv.slice(2);
  let userArgs;
  const argSeparator = babelArgs.indexOf("--");
  
  if (argSeparator > -1) {
    userArgs = babelArgs.slice(argSeparator);
    babelArgs = babelArgs.slice(0, argSeparator);
  }
  
  function getNormalizedV8Flag(arg) {
    const matches = arg.match(/--(?:no)?(.+)/);
  
    if (matches) {
      return `--${matches[1].replace(/-/g, "_")}`;
    }
  
    return arg;
  }
  
  const aliases = new Map([["-d", "--debug"], ["-gc", "--expose-gc"]]);
  
  _v8flags(function () {
    var _ref = _asyncToGenerator(function* (err, v8Flags) {
      for (let i = 0; i < babelArgs.length; i++) {
        const arg = babelArgs[i];
        const flag = arg.split("=")[0];
  
        if (flag === "-r" || flag === "--require") {
          args.push(flag);
          args.push(babelArgs[++i]);
        } else if (aliases.has(flag)) {
          args.unshift(aliases.get(flag));
        } else if (flag === "debug" || flag === "inspect" || v8Flags.indexOf(getNormalizedV8Flag(flag)) >= 0 || (process.allowedNodeEnvironmentFlags || require("node-environment-flags")).has(flag)) {
          args.unshift(arg);
        } else {
          args.push(arg);
        }
      }
  
      if (argSeparator > -1) {
        args.push(...userArgs);
      }
  
      try {
        const {
          default: kexec
        } = yield Promise.resolve().then(() => _interopRequireWildcard(require("kexec")));
        kexec(process.argv[0], args);
      } catch (err) {
        if (err.code !== "ERR_MODULE_NOT_FOUND" && err.code !== "MODULE_NOT_FOUND" && err.code !== "UNDECLARED_DEPENDENCY") {
          throw err;
        }
  
        const shouldPassthroughIPC = process.send !== undefined;
  
        const proc = _child_process.spawn(process.argv[0], args, {
          stdio: shouldPassthroughIPC ? ["inherit", "inherit", "inherit", "ipc"] : "inherit"
        });
  
        proc.on("exit", function (code, signal) {
          process.on("exit", function () {
            if (signal) {
              process.kill(process.pid, signal);
            } else {
              process.exitCode = code;
            }
          });
        });
  
        if (shouldPassthroughIPC) {
          proc.on("message", message => process.send(message));
        }
  
        process.on("SIGINT", () => proc.kill("SIGINT"));
      }
    });
  
    return function (_x, _x2) {
      return _ref.apply(this, arguments);
    };
  }());