refactor: init cypress-cucumber-preprocessor install.

node_modules/babelify/index.js

@@ -0,0 +1,171 @@
+"use strict";
+
+var stream = require("stream");
+var util   = require("util");
+var path   = require("path");
+
+let babel;
+try {
+  babel = require("@babel/core");
+} catch (err) {
+  if (err.code === "MODULE_NOT_FOUND") {
+    err.message +=
+      "\n babelify@10 requires Babel 7.x (the package '@babel/core'). " +
+      "If you'd like to use Babel 6.x ('babel-core'), you should install 'babelify@8'.";
+  }
+  throw err;
+}
+
+// Since we've got the reverse bridge package at @babel/core@6.x, give
+// people useful feedback if they try to use it alongside babel-loader.
+if (/^6\./.test(babel.version)) {
+  throw new Error(
+    "\n babelify@10 will not work with the '@babel/core@6' bridge package. " +
+      "If you want to use Babel 6.x, install 'babelify@8'."
+  );
+}
+
+module.exports = buildTransform();
+module.exports.configure = buildTransform;
+
+// Allow projects to import this module and check `foo instanceof babelify`
+// to see if the current stream they are working with is one created
+// by Babelify.
+Object.defineProperty(module.exports, Symbol.hasInstance, {
+  value: function hasInstance(obj) {
+    return obj instanceof BabelifyStream;
+  },
+});
+
+function buildTransform(opts) {
+  return function (filename, transformOpts) {
+    const babelOpts = normalizeOptions(opts, transformOpts, filename);
+    if (babelOpts === null) {
+      return stream.PassThrough();
+    }
+
+    return new BabelifyStream(babelOpts);
+  };
+}
+
+function normalizeOptions(preconfiguredOpts, transformOpts, filename) {
+  const basedir = normalizeTransformBasedir(transformOpts);
+  const opts = normalizeTransformOpts(transformOpts);
+
+  // Transform options override preconfigured options unless they are undefined.
+  if (preconfiguredOpts) {
+    for (const key of Object.keys(preconfiguredOpts)) {
+      if (opts[key] === undefined) {
+        opts[key] = preconfiguredOpts[key];
+      }
+    }
+  }
+
+  // babelify specific options
+  var extensions = opts.extensions || babel.DEFAULT_EXTENSIONS;
+  var sourceMapsAbsolute = opts.sourceMapsAbsolute;
+  delete opts.sourceMapsAbsolute;
+  delete opts.extensions;
+
+  var extname = path.extname(filename);
+  if (extensions.indexOf(extname) === -1) {
+    return null;
+  }
+
+  // Browserify doesn't actually always normalize the filename passed
+  // to transforms, so we manually ensure that the filename is relative
+  const absoluteFilename = path.resolve(basedir, filename);
+
+  Object.assign(opts, {
+    cwd: opts.cwd === undefined ? basedir : opts.cwd,
+    caller: Object.assign(
+      {
+        name: "babelify",
+      },
+      opts.caller
+    ),
+    filename: absoluteFilename,
+
+    sourceFileName:
+      sourceMapsAbsolute
+        ? absoluteFilename
+        : undefined,
+  });
+
+  return opts;
+}
+
+function normalizeTransformBasedir(opts) {
+  return path.resolve(opts._flags && opts._flags.basedir || ".");
+}
+
+function normalizeTransformOpts(opts) {
+  opts = Object.assign({}, opts);
+
+  // browserify cli options
+  delete opts._;
+  // "--opt [ a b ]" and "--opt a --opt b" are allowed:
+  if (opts.ignore && opts.ignore._) opts.ignore = opts.ignore._;
+  if (opts.only && opts.only._) opts.only = opts.only._;
+  if (opts.plugins && opts.plugins._) opts.plugins = opts.plugins._;
+  if (opts.presets && opts.presets._) opts.presets = opts.presets._;
+
+  // browserify specific options
+  delete opts._flags;
+  delete opts.basedir;
+  delete opts.global;
+
+  return opts;
+}
+
+class BabelifyStream extends stream.Transform {
+  constructor(opts) {
+    super();
+    this._data = [];
+    this._opts = opts;
+  }
+
+  _transform(buf, enc, callback) {
+    this._data.push(buf);
+    callback();
+  }
+
+  _flush(callback) {
+    // Merge the buffer pieces after all are available, instead of one at a time,
+    // to avoid corrupting multibyte characters.
+    const data = Buffer.concat(this._data).toString();
+
+    transform(data, this._opts, (err, result) => {
+      if (err) {
+        callback(err);
+      } else {
+        this.emit("babelify", result, this._opts.filename);
+        var code = result !== null ? result.code : data;
+
+        // Note: Node 8.x allows passing 'code' to the callback instead of
+        // manually pushing, but we need to support Node 6.x.
+        this.push(code);
+        callback();
+      }
+    });
+  }
+}
+
+function transform(data, inputOpts, done) {
+  let cfg;
+  try {
+    cfg = babel.loadPartialConfig(inputOpts);
+    if (!cfg) return done(null, null);
+  } catch (err) {
+    return done(err);
+  }
+  const opts = cfg.options;
+
+  // Since Browserify can only handle inline sourcemaps, we override any other
+  // values to force inline sourcemaps unless they've been disabled.
+  if (opts.sourceMaps !== false) {
+    opts.sourceMaps = "inline";
+  }
+
+  babel.transform(data, opts, done);
+}