refactor(Cypress): add nodemodules

cypress.json

@@ -1,3 +1,3 @@
 {
-
+    "baseUrl": "https://app.post-prod.lifen.fr"
 }

cypress/integration/lifen-inbox/inbox.spec.js

@@ -1,16 +1,49 @@
 /// <reference types="cypress" />
+context('The login page', () => {
 
-describe('checking the inbox website', () => {
+    describe('Test the login page', () => {
 
-    it('Check the login page', function() {
+        it('Access the webpage', function() {
-        cy.visit('https://app.post-prod.lifen.fr/');
+            cy.visit('/');
-        cy.get('#email').should("have.attr", "type", "email");
+            cy.get('#email').should("have.attr", "type", "email");
-        cy.get('#password').should("have.attr", "type", "password");
+            cy.get('#password').should("have.attr", "type", "password");
+            //cy.get('#password').type(mdp);
+        });
+        
+        it('Log an invalid email', function() {
+            cy.visit('/');
+            cy.get('#email').type("not an email");
+            cy.get('#password').type("somepasseword {enter}");
+            cy.url().should('include', 'login?');
+        });
+
+        it('Log an unexisting user', function() {
+            cy.visit('/');
+            cy.get('#email').type("toto@yopmail.com");
+            cy.get('#password').type("somepasseword {enter}");
+            cy.get('#error-message').should("have.class", "alert alert-danger").should("be.visible");
+        });
         
-        //cy.get('#email').type(login);
-        //cy.get('#password').type(mdp);
     });
 
+    describe("It send an SMS", function() {
+        it('Log the candidate user', function(){
+            cy.visit('/login');
+            cy.get('#email').type("candidature-qa@example.org");
+            cy.get('#password').type("kHwWawhH5ADNuFb");
 
+        });
+    });
+});
 
+context("The inbox page", function() {
+    describe("", function() {
+
+        it("It load the inbox page of a valid user");
+
+        it("It checks for messages in the inbox");
+
+        it("Open the message for data that has been injected previously");
+
+    });
 });

node_modules/cucumber/lib/cli/i18n.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+exports.getLanguages = getLanguages;
+exports.getKeywords = getKeywords;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _gherkin = require('gherkin');
+
+var _gherkin2 = _interopRequireDefault(_gherkin);
+
+var _cliTable = require('cli-table');
+
+var _cliTable2 = _interopRequireDefault(_cliTable);
+
+var _titleCase = require('title-case');
+
+var _titleCase2 = _interopRequireDefault(_titleCase);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var keywords = ['feature', 'background', 'scenario', 'scenarioOutline', 'examples', 'given', 'when', 'then', 'and', 'but'];
+
+function getAsTable(header, rows) {
+  var table = new _cliTable2.default({
+    chars: {
+      bottom: '',
+      'bottom-left': '',
+      'bottom-mid': '',
+      'bottom-right': '',
+      left: '',
+      'left-mid': '',
+      mid: '',
+      'mid-mid': '',
+      middle: ' | ',
+      right: '',
+      'right-mid': '',
+      top: '',
+      'top-left': '',
+      'top-mid': '',
+      'top-right': ''
+    },
+    style: {
+      border: [],
+      'padding-left': 0,
+      'padding-right': 0
+    }
+  });
+  table.push(header);
+  table.push.apply(table, (0, _toConsumableArray3.default)(rows));
+  return table.toString();
+}
+
+function getLanguages() {
+  var rows = _lodash2.default.map(_gherkin2.default.DIALECTS, function (data, isoCode) {
+    return [isoCode, data.name, data.native];
+  });
+  return getAsTable(['ISO 639-1', 'ENGLISH NAME', 'NATIVE NAME'], rows);
+}
+
+function getKeywords(isoCode) {
+  var language = _gherkin2.default.DIALECTS[isoCode];
+  var rows = _lodash2.default.map(keywords, function (keyword) {
+    var words = _lodash2.default.map(language[keyword], function (s) {
+      return '"' + s + '"';
+    }).join(', ');
+    return [(0, _titleCase2.default)(keyword), words];
+  });
+  return getAsTable(['ENGLISH KEYWORD', 'NATIVE KEYWORDS'], rows);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/cli/install_validator.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateInstall = undefined;
+
+var _bluebird = require('bluebird');
+
+var validateInstall = exports.validateInstall = function () {
+  var _ref = (0, _bluebird.coroutine)(function* (cwd) {
+    var projectPath = _path2.default.join(__dirname, '..', '..');
+    if (projectPath === cwd) {
+      return; // cucumber testing itself
+    }
+    var currentCucumberPath = require.resolve(projectPath);
+    var localCucumberPath = yield (0, _bluebird.promisify)(_resolve2.default)('cucumber', {
+      basedir: cwd
+    });
+    localCucumberPath = yield _fs2.default.realpath(localCucumberPath);
+    if (localCucumberPath !== currentCucumberPath) {
+      throw new Error('\n      You appear to be executing an install of cucumber (most likely a global install)\n      that is different from your local install (the one required in your support files).\n      For cucumber to work, you need to execute the same install that is required in your support files.\n      Please execute the locally installed version to run your tests.\n\n      Executed Path: ' + currentCucumberPath + '\n      Local Path:    ' + localCucumberPath + '\n      ');
+    }
+  });
+
+  return function validateInstall(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var _fs = require('mz/fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _resolve = require('resolve');
+
+var _resolve2 = _interopRequireDefault(_resolve);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/cli/option_splitter.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var OptionSplitter = function () {
+  function OptionSplitter() {
+    (0, _classCallCheck3.default)(this, OptionSplitter);
+  }
+
+  (0, _createClass3.default)(OptionSplitter, null, [{
+    key: 'split',
+    value: function split(option) {
+      var parts = option.split(/([^A-Z]):(?!\\)/);
+
+      return parts.reduce(function (memo, part, i) {
+        if (partNeedsRecombined(i)) {
+          memo.push(parts.slice(i, i + 2).join(''));
+        }
+
+        return memo;
+      }, []);
+    }
+  }]);
+  return OptionSplitter;
+}();
+
+exports.default = OptionSplitter;
+
+
+function partNeedsRecombined(i) {
+  return i % 2 === 0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGkvb3B0aW9uX3NwbGl0dGVyLmpzIl0sIm5hbWVzIjpbIk9wdGlvblNwbGl0dGVyIiwib3B0aW9uIiwicGFydHMiLCJzcGxpdCIsInJlZHVjZSIsIm1lbW8iLCJwYXJ0IiwiaSIsInBhcnROZWVkc1JlY29tYmluZWQiLCJwdXNoIiwic2xpY2UiLCJqb2luIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0lBQXFCQSxjOzs7Ozs7OzBCQUNOQyxNLEVBQVE7QUFDbkIsVUFBTUMsUUFBUUQsT0FBT0UsS0FBUCxDQUFhLGlCQUFiLENBQWQ7O0FBRUEsYUFBT0QsTUFBTUUsTUFBTixDQUFhLFVBQUNDLElBQUQsRUFBT0MsSUFBUCxFQUFhQyxDQUFiLEVBQW1CO0FBQ3JDLFlBQUlDLG9CQUFvQkQsQ0FBcEIsQ0FBSixFQUE0QjtBQUMxQkYsZUFBS0ksSUFBTCxDQUFVUCxNQUFNUSxLQUFOLENBQVlILENBQVosRUFBZUEsSUFBSSxDQUFuQixFQUFzQkksSUFBdEIsQ0FBMkIsRUFBM0IsQ0FBVjtBQUNEOztBQUVELGVBQU9OLElBQVA7QUFDRCxPQU5NLEVBTUosRUFOSSxDQUFQO0FBT0Q7Ozs7O2tCQVhrQkwsYzs7O0FBY3JCLFNBQVNRLG1CQUFULENBQTZCRCxDQUE3QixFQUFnQztBQUM5QixTQUFPQSxJQUFJLENBQUosS0FBVSxDQUFqQjtBQUNEIiwiZmlsZSI6Im9wdGlvbl9zcGxpdHRlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGNsYXNzIE9wdGlvblNwbGl0dGVyIHtcbiAgc3RhdGljIHNwbGl0KG9wdGlvbikge1xuICAgIGNvbnN0IHBhcnRzID0gb3B0aW9uLnNwbGl0KC8oW15BLVpdKTooPyFcXFxcKS8pXG5cbiAgICByZXR1cm4gcGFydHMucmVkdWNlKChtZW1vLCBwYXJ0LCBpKSA9PiB7XG4gICAgICBpZiAocGFydE5lZWRzUmVjb21iaW5lZChpKSkge1xuICAgICAgICBtZW1vLnB1c2gocGFydHMuc2xpY2UoaSwgaSArIDIpLmpvaW4oJycpKVxuICAgICAgfVxuXG4gICAgICByZXR1cm4gbWVtb1xuICAgIH0sIFtdKVxuICB9XG59XG5cbmZ1bmN0aW9uIHBhcnROZWVkc1JlY29tYmluZWQoaSkge1xuICByZXR1cm4gaSAlIDIgPT09IDBcbn1cbiJdfQ==

node_modules/cucumber/lib/cli/profile_loader.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _bluebird = require('bluebird');
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _fs = require('mz/fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _stringArgv = require('string-argv');
+
+var _stringArgv2 = _interopRequireDefault(_stringArgv);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ProfileLoader = function () {
+  function ProfileLoader(directory) {
+    (0, _classCallCheck3.default)(this, ProfileLoader);
+
+    this.directory = directory;
+  }
+
+  (0, _createClass3.default)(ProfileLoader, [{
+    key: 'getDefinitions',
+    value: function () {
+      var _ref = (0, _bluebird.coroutine)(function* () {
+        var definitionsFilePath = _path2.default.join(this.directory, 'cucumber.js');
+        var exists = yield _fs2.default.exists(definitionsFilePath);
+        if (!exists) {
+          return {};
+        }
+        var definitions = require(definitionsFilePath);
+        if ((typeof definitions === 'undefined' ? 'undefined' : (0, _typeof3.default)(definitions)) !== 'object') {
+          throw new Error(definitionsFilePath + ' does not export an object');
+        }
+        return definitions;
+      });
+
+      function getDefinitions() {
+        return _ref.apply(this, arguments);
+      }
+
+      return getDefinitions;
+    }()
+  }, {
+    key: 'getArgv',
+    value: function () {
+      var _ref2 = (0, _bluebird.coroutine)(function* (profiles) {
+        var definitions = yield this.getDefinitions();
+        if (profiles.length === 0 && definitions.default) {
+          profiles = ['default'];
+        }
+        var argvs = profiles.map(function (profile) {
+          if (!definitions[profile]) {
+            throw new Error('Undefined profile: ' + profile);
+          }
+          return (0, _stringArgv2.default)(definitions[profile]);
+        });
+        return _lodash2.default.flatten(argvs);
+      });
+
+      function getArgv(_x) {
+        return _ref2.apply(this, arguments);
+      }
+
+      return getArgv;
+    }()
+  }]);
+  return ProfileLoader;
+}();
+
+exports.default = ProfileLoader;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGkvcHJvZmlsZV9sb2FkZXIuanMiXSwibmFtZXMiOlsiUHJvZmlsZUxvYWRlciIsImRpcmVjdG9yeSIsImRlZmluaXRpb25zRmlsZVBhdGgiLCJqb2luIiwiZXhpc3RzIiwiZGVmaW5pdGlvbnMiLCJyZXF1aXJlIiwiRXJyb3IiLCJwcm9maWxlcyIsImdldERlZmluaXRpb25zIiwibGVuZ3RoIiwiZGVmYXVsdCIsImFyZ3ZzIiwibWFwIiwicHJvZmlsZSIsImZsYXR0ZW4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7Ozs7QUFDQTs7OztBQUNBOzs7O0FBQ0E7Ozs7OztJQUVxQkEsYTtBQUNuQix5QkFBWUMsU0FBWixFQUF1QjtBQUFBOztBQUNyQixTQUFLQSxTQUFMLEdBQWlCQSxTQUFqQjtBQUNEOzs7Ozt1REFFc0I7QUFDckIsWUFBTUMsc0JBQXNCLGVBQUtDLElBQUwsQ0FBVSxLQUFLRixTQUFmLEVBQTBCLGFBQTFCLENBQTVCO0FBQ0EsWUFBTUcsU0FBUyxNQUFNLGFBQUdBLE1BQUgsQ0FBVUYsbUJBQVYsQ0FBckI7QUFDQSxZQUFJLENBQUNFLE1BQUwsRUFBYTtBQUNYLGlCQUFPLEVBQVA7QUFDRDtBQUNELFlBQU1DLGNBQWNDLFFBQVFKLG1CQUFSLENBQXBCO0FBQ0EsWUFBSSxRQUFPRyxXQUFQLHVEQUFPQSxXQUFQLE9BQXVCLFFBQTNCLEVBQXFDO0FBQ25DLGdCQUFNLElBQUlFLEtBQUosQ0FBYUwsbUJBQWIsZ0NBQU47QUFDRDtBQUNELGVBQU9HLFdBQVA7QUFDRCxPOzs7Ozs7Ozs7OztzREFFYUcsUSxFQUFVO0FBQ3RCLFlBQU1ILGNBQWMsTUFBTSxLQUFLSSxjQUFMLEVBQTFCO0FBQ0EsWUFBSUQsU0FBU0UsTUFBVCxLQUFvQixDQUFwQixJQUF5QkwsWUFBWU0sT0FBekMsRUFBa0Q7QUFDaERILHFCQUFXLENBQUMsU0FBRCxDQUFYO0FBQ0Q7QUFDRCxZQUFNSSxRQUFRSixTQUFTSyxHQUFULENBQWEsbUJBQVc7QUFDcEMsY0FBSSxDQUFDUixZQUFZUyxPQUFaLENBQUwsRUFBMkI7QUFDekIsa0JBQU0sSUFBSVAsS0FBSix5QkFBZ0NPLE9BQWhDLENBQU47QUFDRDtBQUNELGlCQUFPLDBCQUFXVCxZQUFZUyxPQUFaLENBQVgsQ0FBUDtBQUNELFNBTGEsQ0FBZDtBQU1BLGVBQU8saUJBQUVDLE9BQUYsQ0FBVUgsS0FBVixDQUFQO0FBQ0QsTzs7Ozs7Ozs7Ozs7O2tCQTlCa0JaLGEiLCJmaWxlIjoicHJvZmlsZV9sb2FkZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5pbXBvcnQgZnMgZnJvbSAnbXovZnMnXG5pbXBvcnQgcGF0aCBmcm9tICdwYXRoJ1xuaW1wb3J0IHN0cmluZ0FyZ3YgZnJvbSAnc3RyaW5nLWFyZ3YnXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFByb2ZpbGVMb2FkZXIge1xuICBjb25zdHJ1Y3RvcihkaXJlY3RvcnkpIHtcbiAgICB0aGlzLmRpcmVjdG9yeSA9IGRpcmVjdG9yeVxuICB9XG5cbiAgYXN5bmMgZ2V0RGVmaW5pdGlvbnMoKSB7XG4gICAgY29uc3QgZGVmaW5pdGlvbnNGaWxlUGF0aCA9IHBhdGguam9pbih0aGlzLmRpcmVjdG9yeSwgJ2N1Y3VtYmVyLmpzJylcbiAgICBjb25zdCBleGlzdHMgPSBhd2FpdCBmcy5leGlzdHMoZGVmaW5pdGlvbnNGaWxlUGF0aClcbiAgICBpZiAoIWV4aXN0cykge1xuICAgICAgcmV0dXJuIHt9XG4gICAgfVxuICAgIGNvbnN0IGRlZmluaXRpb25zID0gcmVxdWlyZShkZWZpbml0aW9uc0ZpbGVQYXRoKVxuICAgIGlmICh0eXBlb2YgZGVmaW5pdGlvbnMgIT09ICdvYmplY3QnKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoYCR7ZGVmaW5pdGlvbnNGaWxlUGF0aH0gZG9lcyBub3QgZXhwb3J0IGFuIG9iamVjdGApXG4gICAgfVxuICAgIHJldHVybiBkZWZpbml0aW9uc1xuICB9XG5cbiAgYXN5bmMgZ2V0QXJndihwcm9maWxlcykge1xuICAgIGNvbnN0IGRlZmluaXRpb25zID0gYXdhaXQgdGhpcy5nZXREZWZpbml0aW9ucygpXG4gICAgaWYgKHByb2ZpbGVzLmxlbmd0aCA9PT0gMCAmJiBkZWZpbml0aW9ucy5kZWZhdWx0KSB7XG4gICAgICBwcm9maWxlcyA9IFsnZGVmYXVsdCddXG4gICAgfVxuICAgIGNvbnN0IGFyZ3ZzID0gcHJvZmlsZXMubWFwKHByb2ZpbGUgPT4ge1xuICAgICAgaWYgKCFkZWZpbml0aW9uc1twcm9maWxlXSkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFVuZGVmaW5lZCBwcm9maWxlOiAke3Byb2ZpbGV9YClcbiAgICAgIH1cbiAgICAgIHJldHVybiBzdHJpbmdBcmd2KGRlZmluaXRpb25zW3Byb2ZpbGVdKVxuICAgIH0pXG4gICAgcmV0dXJuIF8uZmxhdHRlbihhcmd2cylcbiAgfVxufVxuIl19

node_modules/cucumber/lib/cli/run.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _bluebird = require('bluebird');
+
+var _ = require('./');
+
+var _2 = _interopRequireDefault(_);
+
+var _verror = require('verror');
+
+var _verror2 = _interopRequireDefault(_verror);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function exitWithError(error) {
+  console.error(_verror2.default.fullStack(error)); // eslint-disable-line no-console
+  process.exit(1);
+}
+
+exports.default = function () {
+  var _ref = (0, _bluebird.coroutine)(function* () {
+    var cwd = process.cwd();
+    var cli = new _2.default({
+      argv: process.argv,
+      cwd: cwd,
+      stdout: process.stdout
+    });
+
+    var result = void 0;
+    try {
+      result = yield cli.run();
+    } catch (error) {
+      exitWithError(error);
+    }
+
+    var exitCode = result.success ? 0 : 1;
+    if (result.shouldExitImmediately) {
+      process.exit(exitCode);
+    } else {
+      process.exitCode = exitCode;
+    }
+  });
+
+  function run() {
+    return _ref.apply(this, arguments);
+  }
+
+  return run;
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGkvcnVuLmpzIl0sIm5hbWVzIjpbImV4aXRXaXRoRXJyb3IiLCJlcnJvciIsImNvbnNvbGUiLCJmdWxsU3RhY2siLCJwcm9jZXNzIiwiZXhpdCIsImN3ZCIsImNsaSIsImFyZ3YiLCJzdGRvdXQiLCJyZXN1bHQiLCJydW4iLCJleGl0Q29kZSIsInN1Y2Nlc3MiLCJzaG91bGRFeGl0SW1tZWRpYXRlbHkiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBQUE7Ozs7QUFDQTs7Ozs7O0FBRUEsU0FBU0EsYUFBVCxDQUF1QkMsS0FBdkIsRUFBOEI7QUFDNUJDLFVBQVFELEtBQVIsQ0FBYyxpQkFBT0UsU0FBUCxDQUFpQkYsS0FBakIsQ0FBZCxFQUQ0QixDQUNXO0FBQ3ZDRyxVQUFRQyxJQUFSLENBQWEsQ0FBYjtBQUNEOzs7c0NBRWMsYUFBcUI7QUFDbEMsUUFBTUMsTUFBTUYsUUFBUUUsR0FBUixFQUFaO0FBQ0EsUUFBTUMsTUFBTSxlQUFRO0FBQ2xCQyxZQUFNSixRQUFRSSxJQURJO0FBRWxCRixjQUZrQjtBQUdsQkcsY0FBUUwsUUFBUUs7QUFIRSxLQUFSLENBQVo7O0FBTUEsUUFBSUMsZUFBSjtBQUNBLFFBQUk7QUFDRkEsZUFBUyxNQUFNSCxJQUFJSSxHQUFKLEVBQWY7QUFDRCxLQUZELENBRUUsT0FBT1YsS0FBUCxFQUFjO0FBQ2RELG9CQUFjQyxLQUFkO0FBQ0Q7O0FBRUQsUUFBTVcsV0FBV0YsT0FBT0csT0FBUCxHQUFpQixDQUFqQixHQUFxQixDQUF0QztBQUNBLFFBQUlILE9BQU9JLHFCQUFYLEVBQWtDO0FBQ2hDVixjQUFRQyxJQUFSLENBQWFPLFFBQWI7QUFDRCxLQUZELE1BRU87QUFDTFIsY0FBUVEsUUFBUixHQUFtQkEsUUFBbkI7QUFDRDtBQUNGLEc7O1dBckI2QkQsRzs7OztTQUFBQSxHIiwiZmlsZSI6InJ1bi5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDbGkgZnJvbSAnLi8nXG5pbXBvcnQgVkVycm9yIGZyb20gJ3ZlcnJvcidcblxuZnVuY3Rpb24gZXhpdFdpdGhFcnJvcihlcnJvcikge1xuICBjb25zb2xlLmVycm9yKFZFcnJvci5mdWxsU3RhY2soZXJyb3IpKSAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIG5vLWNvbnNvbGVcbiAgcHJvY2Vzcy5leGl0KDEpXG59XG5cbmV4cG9ydCBkZWZhdWx0IGFzeW5jIGZ1bmN0aW9uIHJ1bigpIHtcbiAgY29uc3QgY3dkID0gcHJvY2Vzcy5jd2QoKVxuICBjb25zdCBjbGkgPSBuZXcgQ2xpKHtcbiAgICBhcmd2OiBwcm9jZXNzLmFyZ3YsXG4gICAgY3dkLFxuICAgIHN0ZG91dDogcHJvY2Vzcy5zdGRvdXQsXG4gIH0pXG5cbiAgbGV0IHJlc3VsdFxuICB0cnkge1xuICAgIHJlc3VsdCA9IGF3YWl0IGNsaS5ydW4oKVxuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGV4aXRXaXRoRXJyb3IoZXJyb3IpXG4gIH1cblxuICBjb25zdCBleGl0Q29kZSA9IHJlc3VsdC5zdWNjZXNzID8gMCA6IDFcbiAgaWYgKHJlc3VsdC5zaG91bGRFeGl0SW1tZWRpYXRlbHkpIHtcbiAgICBwcm9jZXNzLmV4aXQoZXhpdENvZGUpXG4gIH0gZWxzZSB7XG4gICAgcHJvY2Vzcy5leGl0Q29kZSA9IGV4aXRDb2RlXG4gIH1cbn1cbiJdfQ==

node_modules/cucumber/lib/formatter/event_protocol_formatter.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _escapeStringRegexp = require('escape-string-regexp');
+
+var _escapeStringRegexp2 = _interopRequireDefault(_escapeStringRegexp);
+
+var _ = require('./');
+
+var _2 = _interopRequireDefault(_);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var EVENT_NAMES = ['source', 'attachment', 'gherkin-document', 'pickle', 'pickle-accepted', 'pickle-rejected', 'test-run-started', 'test-case-prepared', 'test-case-started', 'test-step-started', 'test-step-attachment', 'test-step-finished', 'test-case-finished', 'test-run-finished'];
+
+var EventProtocolFormatter = function (_Formatter) {
+  (0, _inherits3.default)(EventProtocolFormatter, _Formatter);
+
+  function EventProtocolFormatter(options) {
+    (0, _classCallCheck3.default)(this, EventProtocolFormatter);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (EventProtocolFormatter.__proto__ || Object.getPrototypeOf(EventProtocolFormatter)).call(this, options));
+
+    EVENT_NAMES.forEach(function (eventName) {
+      options.eventBroadcaster.on(eventName, function (data) {
+        return _this.logEvent(eventName, data);
+      });
+    });
+
+    var pathSepRegexp = new RegExp((0, _escapeStringRegexp2.default)(_path2.default.sep), 'g');
+    var pathToRemove = _this.cwd.replace(pathSepRegexp, _path2.default.posix.sep) + _path2.default.posix.sep;
+    _this.pathRegexp = new RegExp((0, _escapeStringRegexp2.default)(pathToRemove), 'g');
+    return _this;
+  }
+
+  (0, _createClass3.default)(EventProtocolFormatter, [{
+    key: 'logEvent',
+    value: function logEvent(eventName, data) {
+      var text = JSON.stringify((0, _extends3.default)({ type: eventName }, data), this.formatJsonData.bind(this));
+      this.log(text + '\n');
+    }
+  }, {
+    key: 'formatJsonData',
+    value: function formatJsonData(key, value) {
+      if (value instanceof Error) {
+        return value.stack.replace(this.pathRegexp, '');
+      }
+      return value;
+    }
+  }]);
+  return EventProtocolFormatter;
+}(_2.default);
+
+exports.default = EventProtocolFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mb3JtYXR0ZXIvZXZlbnRfcHJvdG9jb2xfZm9ybWF0dGVyLmpzIl0sIm5hbWVzIjpbIkVWRU5UX05BTUVTIiwiRXZlbnRQcm90b2NvbEZvcm1hdHRlciIsIm9wdGlvbnMiLCJmb3JFYWNoIiwiZXZlbnRCcm9hZGNhc3RlciIsIm9uIiwiZXZlbnROYW1lIiwibG9nRXZlbnQiLCJkYXRhIiwicGF0aFNlcFJlZ2V4cCIsIlJlZ0V4cCIsInNlcCIsInBhdGhUb1JlbW92ZSIsImN3ZCIsInJlcGxhY2UiLCJwb3NpeCIsInBhdGhSZWdleHAiLCJ0ZXh0IiwiSlNPTiIsInN0cmluZ2lmeSIsInR5cGUiLCJmb3JtYXRKc29uRGF0YSIsImxvZyIsImtleSIsInZhbHVlIiwiRXJyb3IiLCJzdGFjayJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7OztBQUNBOzs7O0FBQ0E7Ozs7OztBQUVBLElBQU1BLGNBQWMsQ0FDbEIsUUFEa0IsRUFFbEIsWUFGa0IsRUFHbEIsa0JBSGtCLEVBSWxCLFFBSmtCLEVBS2xCLGlCQUxrQixFQU1sQixpQkFOa0IsRUFPbEIsa0JBUGtCLEVBUWxCLG9CQVJrQixFQVNsQixtQkFUa0IsRUFVbEIsbUJBVmtCLEVBV2xCLHNCQVhrQixFQVlsQixvQkFaa0IsRUFhbEIsb0JBYmtCLEVBY2xCLG1CQWRrQixDQUFwQjs7SUFpQnFCQyxzQjs7O0FBQ25CLGtDQUFZQyxPQUFaLEVBQXFCO0FBQUE7O0FBQUEsOEpBQ2JBLE9BRGE7O0FBRW5CRixnQkFBWUcsT0FBWixDQUFvQixxQkFBYTtBQUMvQkQsY0FBUUUsZ0JBQVIsQ0FBeUJDLEVBQXpCLENBQTRCQyxTQUE1QixFQUF1QztBQUFBLGVBQ3JDLE1BQUtDLFFBQUwsQ0FBY0QsU0FBZCxFQUF5QkUsSUFBekIsQ0FEcUM7QUFBQSxPQUF2QztBQUdELEtBSkQ7O0FBTUEsUUFBTUMsZ0JBQWdCLElBQUlDLE1BQUosQ0FBVyxrQ0FBbUIsZUFBS0MsR0FBeEIsQ0FBWCxFQUF5QyxHQUF6QyxDQUF0QjtBQUNBLFFBQU1DLGVBQ0osTUFBS0MsR0FBTCxDQUFTQyxPQUFULENBQWlCTCxhQUFqQixFQUFnQyxlQUFLTSxLQUFMLENBQVdKLEdBQTNDLElBQWtELGVBQUtJLEtBQUwsQ0FBV0osR0FEL0Q7QUFFQSxVQUFLSyxVQUFMLEdBQWtCLElBQUlOLE1BQUosQ0FBVyxrQ0FBbUJFLFlBQW5CLENBQVgsRUFBNkMsR0FBN0MsQ0FBbEI7QUFYbUI7QUFZcEI7Ozs7NkJBRVFOLFMsRUFBV0UsSSxFQUFNO0FBQ3hCLFVBQU1TLE9BQU9DLEtBQUtDLFNBQUwsMEJBQ1RDLE1BQU1kLFNBREcsSUFDV0UsSUFEWCxHQUVULEtBQUthLGNBRkksTUFFVCxJQUZTLEVBQWI7QUFJQSxXQUFLQyxHQUFMLENBQVlMLElBQVo7QUFDRDs7O21DQUVjTSxHLEVBQUtDLEssRUFBTztBQUN6QixVQUFJQSxpQkFBaUJDLEtBQXJCLEVBQTRCO0FBQzFCLGVBQU9ELE1BQU1FLEtBQU4sQ0FBWVosT0FBWixDQUFvQixLQUFLRSxVQUF6QixFQUFxQyxFQUFyQyxDQUFQO0FBQ0Q7QUFDRCxhQUFPUSxLQUFQO0FBQ0Q7Ozs7O2tCQTVCa0J2QixzQiIsImZpbGUiOiJldmVudF9wcm90b2NvbF9mb3JtYXR0ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZXNjYXBlU3RyaW5nUmVnZXhwIGZyb20gJ2VzY2FwZS1zdHJpbmctcmVnZXhwJ1xuaW1wb3J0IEZvcm1hdHRlciBmcm9tICcuLydcbmltcG9ydCBwYXRoIGZyb20gJ3BhdGgnXG5cbmNvbnN0IEVWRU5UX05BTUVTID0gW1xuICAnc291cmNlJyxcbiAgJ2F0dGFjaG1lbnQnLFxuICAnZ2hlcmtpbi1kb2N1bWVudCcsXG4gICdwaWNrbGUnLFxuICAncGlja2xlLWFjY2VwdGVkJyxcbiAgJ3BpY2tsZS1yZWplY3RlZCcsXG4gICd0ZXN0LXJ1bi1zdGFydGVkJyxcbiAgJ3Rlc3QtY2FzZS1wcmVwYXJlZCcsXG4gICd0ZXN0LWNhc2Utc3RhcnRlZCcsXG4gICd0ZXN0LXN0ZXAtc3RhcnRlZCcsXG4gICd0ZXN0LXN0ZXAtYXR0YWNobWVudCcsXG4gICd0ZXN0LXN0ZXAtZmluaXNoZWQnLFxuICAndGVzdC1jYXNlLWZpbmlzaGVkJyxcbiAgJ3Rlc3QtcnVuLWZpbmlzaGVkJyxcbl1cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgRXZlbnRQcm90b2NvbEZvcm1hdHRlciBleHRlbmRzIEZvcm1hdHRlciB7XG4gIGNvbnN0cnVjdG9yKG9wdGlvbnMpIHtcbiAgICBzdXBlcihvcHRpb25zKVxuICAgIEVWRU5UX05BTUVTLmZvckVhY2goZXZlbnROYW1lID0+IHtcbiAgICAgIG9wdGlvbnMuZXZlbnRCcm9hZGNhc3Rlci5vbihldmVudE5hbWUsIGRhdGEgPT5cbiAgICAgICAgdGhpcy5sb2dFdmVudChldmVudE5hbWUsIGRhdGEpXG4gICAgICApXG4gICAgfSlcblxuICAgIGNvbnN0IHBhdGhTZXBSZWdleHAgPSBuZXcgUmVnRXhwKGVzY2FwZVN0cmluZ1JlZ2V4cChwYXRoLnNlcCksICdnJylcbiAgICBjb25zdCBwYXRoVG9SZW1vdmUgPVxuICAgICAgdGhpcy5jd2QucmVwbGFjZShwYXRoU2VwUmVnZXhwLCBwYXRoLnBvc2l4LnNlcCkgKyBwYXRoLnBvc2l4LnNlcFxuICAgIHRoaXMucGF0aFJlZ2V4cCA9IG5ldyBSZWdFeHAoZXNjYXBlU3RyaW5nUmVnZXhwKHBhdGhUb1JlbW92ZSksICdnJylcbiAgfVxuXG4gIGxvZ0V2ZW50KGV2ZW50TmFtZSwgZGF0YSkge1xuICAgIGNvbnN0IHRleHQgPSBKU09OLnN0cmluZ2lmeShcbiAgICAgIHsgdHlwZTogZXZlbnROYW1lLCAuLi5kYXRhIH0sXG4gICAgICA6OnRoaXMuZm9ybWF0SnNvbkRhdGFcbiAgICApXG4gICAgdGhpcy5sb2coYCR7dGV4dH1cXG5gKVxuICB9XG5cbiAgZm9ybWF0SnNvbkRhdGEoa2V5LCB2YWx1ZSkge1xuICAgIGlmICh2YWx1ZSBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgICByZXR1cm4gdmFsdWUuc3RhY2sucmVwbGFjZSh0aGlzLnBhdGhSZWdleHAsICcnKVxuICAgIH1cbiAgICByZXR1cm4gdmFsdWVcbiAgfVxufVxuIl19

node_modules/cucumber/lib/formatter/get_color_fns.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+exports.default = getColorFns;
+
+var _safe = require('colors/safe');
+
+var _safe2 = _interopRequireDefault(_safe);
+
+var _status = require('../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getColorFns(enabled) {
+  var _colors$setTheme;
+
+  _safe2.default.enabled = enabled;
+  _safe2.default.setTheme((_colors$setTheme = {}, (0, _defineProperty3.default)(_colors$setTheme, _status2.default.AMBIGUOUS, 'red'), (0, _defineProperty3.default)(_colors$setTheme, _status2.default.FAILED, 'red'), (0, _defineProperty3.default)(_colors$setTheme, _status2.default.PASSED, 'green'), (0, _defineProperty3.default)(_colors$setTheme, _status2.default.PENDING, 'yellow'), (0, _defineProperty3.default)(_colors$setTheme, _status2.default.SKIPPED, 'cyan'), (0, _defineProperty3.default)(_colors$setTheme, _status2.default.UNDEFINED, 'yellow'), (0, _defineProperty3.default)(_colors$setTheme, 'location', 'grey'), (0, _defineProperty3.default)(_colors$setTheme, 'tag', 'cyan'), _colors$setTheme));
+  return _safe2.default;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mb3JtYXR0ZXIvZ2V0X2NvbG9yX2Zucy5qcyJdLCJuYW1lcyI6WyJnZXRDb2xvckZucyIsImVuYWJsZWQiLCJzZXRUaGVtZSIsIkFNQklHVU9VUyIsIkZBSUxFRCIsIlBBU1NFRCIsIlBFTkRJTkciLCJTS0lQUEVEIiwiVU5ERUZJTkVEIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7O2tCQUd3QkEsVzs7QUFIeEI7Ozs7QUFDQTs7Ozs7O0FBRWUsU0FBU0EsV0FBVCxDQUFxQkMsT0FBckIsRUFBOEI7QUFBQTs7QUFDM0MsaUJBQU9BLE9BQVAsR0FBaUJBLE9BQWpCO0FBQ0EsaUJBQU9DLFFBQVAseUVBQ0csaUJBQU9DLFNBRFYsRUFDc0IsS0FEdEIsbURBRUcsaUJBQU9DLE1BRlYsRUFFbUIsS0FGbkIsbURBR0csaUJBQU9DLE1BSFYsRUFHbUIsT0FIbkIsbURBSUcsaUJBQU9DLE9BSlYsRUFJb0IsUUFKcEIsbURBS0csaUJBQU9DLE9BTFYsRUFLb0IsTUFMcEIsbURBTUcsaUJBQU9DLFNBTlYsRUFNc0IsUUFOdEIsK0RBT1ksTUFQWiwwREFRTyxNQVJQO0FBVUE7QUFDRCIsImZpbGUiOiJnZXRfY29sb3JfZm5zLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGNvbG9ycyBmcm9tICdjb2xvcnMvc2FmZSdcbmltcG9ydCBTdGF0dXMgZnJvbSAnLi4vc3RhdHVzJ1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBnZXRDb2xvckZucyhlbmFibGVkKSB7XG4gIGNvbG9ycy5lbmFibGVkID0gZW5hYmxlZFxuICBjb2xvcnMuc2V0VGhlbWUoe1xuICAgIFtTdGF0dXMuQU1CSUdVT1VTXTogJ3JlZCcsXG4gICAgW1N0YXR1cy5GQUlMRURdOiAncmVkJyxcbiAgICBbU3RhdHVzLlBBU1NFRF06ICdncmVlbicsXG4gICAgW1N0YXR1cy5QRU5ESU5HXTogJ3llbGxvdycsXG4gICAgW1N0YXR1cy5TS0lQUEVEXTogJ2N5YW4nLFxuICAgIFtTdGF0dXMuVU5ERUZJTkVEXTogJ3llbGxvdycsXG4gICAgbG9jYXRpb246ICdncmV5JyxcbiAgICB0YWc6ICdjeWFuJyxcbiAgfSlcbiAgcmV0dXJuIGNvbG9yc1xufVxuIl19

node_modules/cucumber/lib/formatter/helpers/error_helpers.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatError = formatError;
+
+var _assertionErrorFormatter = require('assertion-error-formatter');
+
+function formatError(error, colorFns) {
+  return (0, _assertionErrorFormatter.format)(error, {
+    colorFns: {
+      diffAdded: colorFns.red,
+      diffRemoved: colorFns.green,
+      errorMessage: colorFns.red,
+      errorStack: colorFns.gray
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mb3JtYXR0ZXIvaGVscGVycy9lcnJvcl9oZWxwZXJzLmpzIl0sIm5hbWVzIjpbImZvcm1hdEVycm9yIiwiZXJyb3IiLCJjb2xvckZucyIsImRpZmZBZGRlZCIsInJlZCIsImRpZmZSZW1vdmVkIiwiZ3JlZW4iLCJlcnJvck1lc3NhZ2UiLCJlcnJvclN0YWNrIiwiZ3JheSJdLCJtYXBwaW5ncyI6Ijs7Ozs7UUFFZ0JBLFcsR0FBQUEsVzs7QUFGaEI7O0FBRU8sU0FBU0EsV0FBVCxDQUFxQkMsS0FBckIsRUFBNEJDLFFBQTVCLEVBQXNDO0FBQzNDLFNBQU8scUNBQU9ELEtBQVAsRUFBYztBQUNuQkMsY0FBVTtBQUNSQyxpQkFBV0QsU0FBU0UsR0FEWjtBQUVSQyxtQkFBYUgsU0FBU0ksS0FGZDtBQUdSQyxvQkFBY0wsU0FBU0UsR0FIZjtBQUlSSSxrQkFBWU4sU0FBU087QUFKYjtBQURTLEdBQWQsQ0FBUDtBQVFEIiwiZmlsZSI6ImVycm9yX2hlbHBlcnMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmb3JtYXQgfSBmcm9tICdhc3NlcnRpb24tZXJyb3ItZm9ybWF0dGVyJ1xuXG5leHBvcnQgZnVuY3Rpb24gZm9ybWF0RXJyb3IoZXJyb3IsIGNvbG9yRm5zKSB7XG4gIHJldHVybiBmb3JtYXQoZXJyb3IsIHtcbiAgICBjb2xvckZuczoge1xuICAgICAgZGlmZkFkZGVkOiBjb2xvckZucy5yZWQsXG4gICAgICBkaWZmUmVtb3ZlZDogY29sb3JGbnMuZ3JlZW4sXG4gICAgICBlcnJvck1lc3NhZ2U6IGNvbG9yRm5zLnJlZCxcbiAgICAgIGVycm9yU3RhY2s6IGNvbG9yRm5zLmdyYXksXG4gICAgfSxcbiAgfSlcbn1cbiJdfQ==

node_modules/cucumber/lib/formatter/helpers/gherkin_document_parser.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStepLineToKeywordMap = getStepLineToKeywordMap;
+exports.getScenarioLineToDescriptionMap = getScenarioLineToDescriptionMap;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getStepLineToKeywordMap(gherkinDocument) {
+  return _lodash2.default.chain(gherkinDocument.feature.children).map('steps').flatten().map(function (step) {
+    return [step.location.line, step.keyword];
+  }).fromPairs().value();
+}
+
+function getScenarioLineToDescriptionMap(gherkinDocument) {
+  return _lodash2.default.chain(gherkinDocument.feature.children).map(function (element) {
+    return [element.location.line, element.description];
+  }).fromPairs().value();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mb3JtYXR0ZXIvaGVscGVycy9naGVya2luX2RvY3VtZW50X3BhcnNlci5qcyJdLCJuYW1lcyI6WyJnZXRTdGVwTGluZVRvS2V5d29yZE1hcCIsImdldFNjZW5hcmlvTGluZVRvRGVzY3JpcHRpb25NYXAiLCJnaGVya2luRG9jdW1lbnQiLCJjaGFpbiIsImZlYXR1cmUiLCJjaGlsZHJlbiIsIm1hcCIsImZsYXR0ZW4iLCJzdGVwIiwibG9jYXRpb24iLCJsaW5lIiwia2V5d29yZCIsImZyb21QYWlycyIsInZhbHVlIiwiZWxlbWVudCIsImRlc2NyaXB0aW9uIl0sIm1hcHBpbmdzIjoiOzs7OztRQUVnQkEsdUIsR0FBQUEsdUI7UUFTQUMsK0IsR0FBQUEsK0I7O0FBWGhCOzs7Ozs7QUFFTyxTQUFTRCx1QkFBVCxDQUFpQ0UsZUFBakMsRUFBa0Q7QUFDdkQsU0FBTyxpQkFBRUMsS0FBRixDQUFRRCxnQkFBZ0JFLE9BQWhCLENBQXdCQyxRQUFoQyxFQUNKQyxHQURJLENBQ0EsT0FEQSxFQUVKQyxPQUZJLEdBR0pELEdBSEksQ0FHQTtBQUFBLFdBQVEsQ0FBQ0UsS0FBS0MsUUFBTCxDQUFjQyxJQUFmLEVBQXFCRixLQUFLRyxPQUExQixDQUFSO0FBQUEsR0FIQSxFQUlKQyxTQUpJLEdBS0pDLEtBTEksRUFBUDtBQU1EOztBQUVNLFNBQVNaLCtCQUFULENBQXlDQyxlQUF6QyxFQUEwRDtBQUMvRCxTQUFPLGlCQUFFQyxLQUFGLENBQVFELGdCQUFnQkUsT0FBaEIsQ0FBd0JDLFFBQWhDLEVBQ0pDLEdBREksQ0FDQTtBQUFBLFdBQVcsQ0FBQ1EsUUFBUUwsUUFBUixDQUFpQkMsSUFBbEIsRUFBd0JJLFFBQVFDLFdBQWhDLENBQVg7QUFBQSxHQURBLEVBRUpILFNBRkksR0FHSkMsS0FISSxFQUFQO0FBSUQiLCJmaWxlIjoiZ2hlcmtpbl9kb2N1bWVudF9wYXJzZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdGVwTGluZVRvS2V5d29yZE1hcChnaGVya2luRG9jdW1lbnQpIHtcbiAgcmV0dXJuIF8uY2hhaW4oZ2hlcmtpbkRvY3VtZW50LmZlYXR1cmUuY2hpbGRyZW4pXG4gICAgLm1hcCgnc3RlcHMnKVxuICAgIC5mbGF0dGVuKClcbiAgICAubWFwKHN0ZXAgPT4gW3N0ZXAubG9jYXRpb24ubGluZSwgc3RlcC5rZXl3b3JkXSlcbiAgICAuZnJvbVBhaXJzKClcbiAgICAudmFsdWUoKVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2NlbmFyaW9MaW5lVG9EZXNjcmlwdGlvbk1hcChnaGVya2luRG9jdW1lbnQpIHtcbiAgcmV0dXJuIF8uY2hhaW4oZ2hlcmtpbkRvY3VtZW50LmZlYXR1cmUuY2hpbGRyZW4pXG4gICAgLm1hcChlbGVtZW50ID0+IFtlbGVtZW50LmxvY2F0aW9uLmxpbmUsIGVsZW1lbnQuZGVzY3JpcHRpb25dKVxuICAgIC5mcm9tUGFpcnMoKVxuICAgIC52YWx1ZSgpXG59XG4iXX0=

node_modules/cucumber/lib/formatter/helpers/index.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickleParser = exports.GherkinDocumentParser = exports.getUsage = exports.formatSummary = exports.formatLocation = exports.isIssue = exports.formatIssue = exports.formatError = exports.getStepKeywordType = exports.KeywordType = exports.EventDataCollector = undefined;
+
+var _event_data_collector = require('./event_data_collector');
+
+Object.defineProperty(exports, 'EventDataCollector', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_event_data_collector).default;
+  }
+});
+
+var _keyword_type = require('./keyword_type');
+
+Object.defineProperty(exports, 'KeywordType', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_keyword_type).default;
+  }
+});
+Object.defineProperty(exports, 'getStepKeywordType', {
+  enumerable: true,
+  get: function get() {
+    return _keyword_type.getStepKeywordType;
+  }
+});
+
+var _error_helpers = require('./error_helpers');
+
+Object.defineProperty(exports, 'formatError', {
+  enumerable: true,
+  get: function get() {
+    return _error_helpers.formatError;
+  }
+});
+
+var _issue_helpers = require('./issue_helpers');
+
+Object.defineProperty(exports, 'formatIssue', {
+  enumerable: true,
+  get: function get() {
+    return _issue_helpers.formatIssue;
+  }
+});
+Object.defineProperty(exports, 'isIssue', {
+  enumerable: true,
+  get: function get() {
+    return _issue_helpers.isIssue;
+  }
+});
+
+var _location_helpers = require('./location_helpers');
+
+Object.defineProperty(exports, 'formatLocation', {
+  enumerable: true,
+  get: function get() {
+    return _location_helpers.formatLocation;
+  }
+});
+
+var _summary_helpers = require('./summary_helpers');
+
+Object.defineProperty(exports, 'formatSummary', {
+  enumerable: true,
+  get: function get() {
+    return _summary_helpers.formatSummary;
+  }
+});
+
+var _usage_helpers = require('./usage_helpers');
+
+Object.defineProperty(exports, 'getUsage', {
+  enumerable: true,
+  get: function get() {
+    return _usage_helpers.getUsage;
+  }
+});
+
+var _gherkin_document_parser = require('./gherkin_document_parser');
+
+var GherkinDocumentParser = _interopRequireWildcard(_gherkin_document_parser);
+
+var _pickle_parser = require('./pickle_parser');
+
+var PickleParser = _interopRequireWildcard(_pickle_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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.GherkinDocumentParser = GherkinDocumentParser;
+exports.PickleParser = PickleParser;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mb3JtYXR0ZXIvaGVscGVycy9pbmRleC5qcyJdLCJuYW1lcyI6WyJkZWZhdWx0IiwiZ2V0U3RlcEtleXdvcmRUeXBlIiwiZm9ybWF0RXJyb3IiLCJmb3JtYXRJc3N1ZSIsImlzSXNzdWUiLCJmb3JtYXRMb2NhdGlvbiIsImZvcm1hdFN1bW1hcnkiLCJnZXRVc2FnZSIsIkdoZXJraW5Eb2N1bWVudFBhcnNlciIsIlBpY2tsZVBhcnNlciJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O3lEQUdTQSxPOzs7Ozs7Ozs7aURBQ0FBLE87Ozs7Ozt5QkFBd0JDLGtCOzs7Ozs7Ozs7MEJBQ3hCQyxXOzs7Ozs7Ozs7MEJBQ0FDLFc7Ozs7OzswQkFBYUMsTzs7Ozs7Ozs7OzZCQUNiQyxjOzs7Ozs7Ozs7NEJBQ0FDLGE7Ozs7Ozs7OzswQkFDQUMsUTs7OztBQVRUOztJQUFZQyxxQjs7QUFDWjs7SUFBWUMsWTs7Ozs7O1FBU0hELHFCLEdBQUFBLHFCO1FBQXVCQyxZLEdBQUFBLFkiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBHaGVya2luRG9jdW1lbnRQYXJzZXIgZnJvbSAnLi9naGVya2luX2RvY3VtZW50X3BhcnNlcidcbmltcG9ydCAqIGFzIFBpY2tsZVBhcnNlciBmcm9tICcuL3BpY2tsZV9wYXJzZXInXG5cbmV4cG9ydCB7IGRlZmF1bHQgYXMgRXZlbnREYXRhQ29sbGVjdG9yIH0gZnJvbSAnLi9ldmVudF9kYXRhX2NvbGxlY3RvcidcbmV4cG9ydCB7IGRlZmF1bHQgYXMgS2V5d29yZFR5cGUsIGdldFN0ZXBLZXl3b3JkVHlwZSB9IGZyb20gJy4va2V5d29yZF90eXBlJ1xuZXhwb3J0IHsgZm9ybWF0RXJyb3IgfSBmcm9tICcuL2Vycm9yX2hlbHBlcnMnXG5leHBvcnQgeyBmb3JtYXRJc3N1ZSwgaXNJc3N1ZSB9IGZyb20gJy4vaXNzdWVfaGVscGVycydcbmV4cG9ydCB7IGZvcm1hdExvY2F0aW9uIH0gZnJvbSAnLi9sb2NhdGlvbl9oZWxwZXJzJ1xuZXhwb3J0IHsgZm9ybWF0U3VtbWFyeSB9IGZyb20gJy4vc3VtbWFyeV9oZWxwZXJzJ1xuZXhwb3J0IHsgZ2V0VXNhZ2UgfSBmcm9tICcuL3VzYWdlX2hlbHBlcnMnXG5leHBvcnQgeyBHaGVya2luRG9jdW1lbnRQYXJzZXIsIFBpY2tsZVBhcnNlciB9XG4iXX0=

node_modules/cucumber/lib/formatter/helpers/keyword_type.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStepKeywordType = getStepKeywordType;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _gherkin = require('gherkin');
+
+var _gherkin2 = _interopRequireDefault(_gherkin);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var types = {
+  EVENT: 'event',
+  OUTCOME: 'outcome',
+  PRECONDITION: 'precondition'
+};
+
+exports.default = types;
+function getStepKeywordType(_ref) {
+  var keyword = _ref.keyword,
+      language = _ref.language,
+      previousKeywordType = _ref.previousKeywordType;
+
+  var dialect = _gherkin2.default.DIALECTS[language];
+  var type = _lodash2.default.find(['given', 'when', 'then', 'and', 'but'], function (key) {
+    return _lodash2.default.includes(dialect[key], keyword);
+  });
+  switch (type) {
+    case 'when':
+      return types.EVENT;
+    case 'then':
+      return types.OUTCOME;
+    case 'and':
+    case 'but':
+      if (previousKeywordType) {
+        return previousKeywordType;
+      }
+    // fallthrough
+    default:
+      return types.PRECONDITION;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/helpers/location_helpers.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatLocation = formatLocation;
+function formatLocation(obj) {
+  return obj.uri + ":" + obj.line;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mb3JtYXR0ZXIvaGVscGVycy9sb2NhdGlvbl9oZWxwZXJzLmpzIl0sIm5hbWVzIjpbImZvcm1hdExvY2F0aW9uIiwib2JqIiwidXJpIiwibGluZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7UUFBZ0JBLGMsR0FBQUEsYztBQUFULFNBQVNBLGNBQVQsQ0FBd0JDLEdBQXhCLEVBQTZCO0FBQ2xDLFNBQVVBLElBQUlDLEdBQWQsU0FBcUJELElBQUlFLElBQXpCO0FBQ0QiLCJmaWxlIjoibG9jYXRpb25faGVscGVycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBmb3JtYXRMb2NhdGlvbihvYmopIHtcbiAgcmV0dXJuIGAke29iai51cml9OiR7b2JqLmxpbmV9YFxufVxuIl19

node_modules/cucumber/lib/formatter/helpers/pickle_parser.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getScenarioDescription = getScenarioDescription;
+exports.getStepKeyword = getStepKeyword;
+exports.getStepLineToPickledStepMap = getStepLineToPickledStepMap;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getScenarioDescription(_ref) {
+  var pickle = _ref.pickle,
+      scenarioLineToDescriptionMap = _ref.scenarioLineToDescriptionMap;
+
+  return _lodash2.default.chain(pickle.locations).map(function (_ref2) {
+    var line = _ref2.line;
+    return scenarioLineToDescriptionMap[line];
+  }).compact().first().value();
+}
+
+function getStepKeyword(_ref3) {
+  var pickleStep = _ref3.pickleStep,
+      stepLineToKeywordMap = _ref3.stepLineToKeywordMap;
+
+  return _lodash2.default.chain(pickleStep.locations).map(function (_ref4) {
+    var line = _ref4.line;
+    return stepLineToKeywordMap[line];
+  }).compact().first().value();
+}
+
+function getStepLineToPickledStepMap(pickle) {
+  return _lodash2.default.chain(pickle.steps).map(function (step) {
+    return [_lodash2.default.last(step.locations).line, step];
+  }).fromPairs().value();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/helpers/step_result_helpers.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStepMessage = getStepMessage;
+
+var _error_helpers = require('./error_helpers');
+
+var _status = require('../../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+var _indentString = require('indent-string');
+
+var _indentString2 = _interopRequireDefault(_indentString);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getAmbiguousStepResultMessage(_ref) {
+  var colorFns = _ref.colorFns,
+      testStep = _ref.testStep;
+
+  return colorFns.ambiguous(testStep.result.exception);
+}
+
+function getFailedStepResultMessage(_ref2) {
+  var colorFns = _ref2.colorFns,
+      testStep = _ref2.testStep;
+
+  return (0, _error_helpers.formatError)(testStep.result.exception, colorFns);
+}
+
+function getPendingStepResultMessage(_ref3) {
+  var colorFns = _ref3.colorFns;
+
+  return colorFns.pending('Pending');
+}
+
+function getStepMessage(_ref4) {
+  var colorFns = _ref4.colorFns,
+      keywordType = _ref4.keywordType,
+      snippetBuilder = _ref4.snippetBuilder,
+      testStep = _ref4.testStep,
+      pickleStep = _ref4.pickleStep;
+
+  switch (testStep.result.status) {
+    case _status2.default.AMBIGUOUS:
+      return getAmbiguousStepResultMessage({ colorFns: colorFns, testStep: testStep });
+    case _status2.default.FAILED:
+      return getFailedStepResultMessage({ colorFns: colorFns, testStep: testStep });
+    case _status2.default.UNDEFINED:
+      return getUndefinedStepResultMessage({
+        colorFns: colorFns,
+        keywordType: keywordType,
+        snippetBuilder: snippetBuilder,
+        pickleStep: pickleStep
+      });
+    case _status2.default.PENDING:
+      return getPendingStepResultMessage({ colorFns: colorFns });
+  }
+}
+
+function getUndefinedStepResultMessage(_ref5) {
+  var colorFns = _ref5.colorFns,
+      keywordType = _ref5.keywordType,
+      snippetBuilder = _ref5.snippetBuilder,
+      pickleStep = _ref5.pickleStep;
+
+  var snippet = snippetBuilder.build({ keywordType: keywordType, pickleStep: pickleStep });
+  var message = '' + ('Undefined. Implement with the following snippet:' + '\n\n') + (0, _indentString2.default)(snippet, 2) + '\n';
+  return colorFns.undefined(message);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Formatter = function Formatter(options) {
+  (0, _classCallCheck3.default)(this, Formatter);
+
+  _lodash2.default.assign(this, _lodash2.default.pick(options, ['colorFns', 'cwd', 'eventDataCollector', 'log', 'snippetBuilder', 'stream', 'supportCodeLibrary']));
+};
+
+exports.default = Formatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mb3JtYXR0ZXIvaW5kZXguanMiXSwibmFtZXMiOlsiRm9ybWF0dGVyIiwib3B0aW9ucyIsImFzc2lnbiIsInBpY2siXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFBQTs7Ozs7O0lBRXFCQSxTLEdBQ25CLG1CQUFZQyxPQUFaLEVBQXFCO0FBQUE7O0FBQ25CLG1CQUFFQyxNQUFGLENBQ0UsSUFERixFQUVFLGlCQUFFQyxJQUFGLENBQU9GLE9BQVAsRUFBZ0IsQ0FDZCxVQURjLEVBRWQsS0FGYyxFQUdkLG9CQUhjLEVBSWQsS0FKYyxFQUtkLGdCQUxjLEVBTWQsUUFOYyxFQU9kLG9CQVBjLENBQWhCLENBRkY7QUFZRCxDOztrQkFka0JELFMiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEZvcm1hdHRlciB7XG4gIGNvbnN0cnVjdG9yKG9wdGlvbnMpIHtcbiAgICBfLmFzc2lnbihcbiAgICAgIHRoaXMsXG4gICAgICBfLnBpY2sob3B0aW9ucywgW1xuICAgICAgICAnY29sb3JGbnMnLFxuICAgICAgICAnY3dkJyxcbiAgICAgICAgJ2V2ZW50RGF0YUNvbGxlY3RvcicsXG4gICAgICAgICdsb2cnLFxuICAgICAgICAnc25pcHBldEJ1aWxkZXInLFxuICAgICAgICAnc3RyZWFtJyxcbiAgICAgICAgJ3N1cHBvcnRDb2RlTGlicmFyeScsXG4gICAgICBdKVxuICAgIClcbiAgfVxufVxuIl19

node_modules/cucumber/lib/formatter/progress_formatter.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _STATUS_CHARACTER_MAP;
+
+var _status = require('../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+var _summary_formatter = require('./summary_formatter');
+
+var _summary_formatter2 = _interopRequireDefault(_summary_formatter);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var STATUS_CHARACTER_MAPPING = (_STATUS_CHARACTER_MAP = {}, (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.AMBIGUOUS, 'A'), (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.FAILED, 'F'), (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.PASSED, '.'), (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.PENDING, 'P'), (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.SKIPPED, '-'), (0, _defineProperty3.default)(_STATUS_CHARACTER_MAP, _status2.default.UNDEFINED, 'U'), _STATUS_CHARACTER_MAP);
+
+var ProgressFormatter = function (_SummaryFormatter) {
+  (0, _inherits3.default)(ProgressFormatter, _SummaryFormatter);
+
+  function ProgressFormatter(options) {
+    (0, _classCallCheck3.default)(this, ProgressFormatter);
+
+    options.eventBroadcaster.on('test-run-finished', function () {
+      _this.log('\n\n');
+    });
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (ProgressFormatter.__proto__ || Object.getPrototypeOf(ProgressFormatter)).call(this, options));
+
+    options.eventBroadcaster.on('test-step-finished', _this.logProgress.bind(_this));
+    return _this;
+  }
+
+  (0, _createClass3.default)(ProgressFormatter, [{
+    key: 'logProgress',
+    value: function logProgress(_ref) {
+      var result = _ref.result;
+      var status = result.status;
+
+      var character = this.colorFns[status](STATUS_CHARACTER_MAPPING[status]);
+      this.log(character);
+    }
+  }]);
+  return ProgressFormatter;
+}(_summary_formatter2.default);
+
+exports.default = ProgressFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/rerun_formatter.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _2 = require('./');
+
+var _3 = _interopRequireDefault(_2);
+
+var _status = require('../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var DEFAULT_SEPARATOR = '\n';
+
+var RerunFormatter = function (_Formatter) {
+  (0, _inherits3.default)(RerunFormatter, _Formatter);
+
+  function RerunFormatter(options) {
+    (0, _classCallCheck3.default)(this, RerunFormatter);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (RerunFormatter.__proto__ || Object.getPrototypeOf(RerunFormatter)).call(this, options));
+
+    options.eventBroadcaster.on('test-case-finished', _this.storeFailedTestCases.bind(_this)).on('test-run-finished', _this.logFailedTestCases.bind(_this));
+    _this.mapping = {};
+    _this.separator = _lodash2.default.get(options, 'rerun.separator', DEFAULT_SEPARATOR);
+    return _this;
+  }
+
+  (0, _createClass3.default)(RerunFormatter, [{
+    key: 'storeFailedTestCases',
+    value: function storeFailedTestCases(_ref) {
+      var _ref$sourceLocation = _ref.sourceLocation,
+          line = _ref$sourceLocation.line,
+          uri = _ref$sourceLocation.uri,
+          status = _ref.result.status;
+
+      if (status !== _status2.default.PASSED) {
+        if (!this.mapping[uri]) {
+          this.mapping[uri] = [];
+        }
+        this.mapping[uri].push(line);
+      }
+    }
+  }, {
+    key: 'logFailedTestCases',
+    value: function logFailedTestCases() {
+      var text = _lodash2.default.chain(this.mapping).map(function (lines, uri) {
+        return uri + ':' + lines.join(':');
+      }).join(this.separator).value();
+      this.log(text);
+    }
+  }]);
+  return RerunFormatter;
+}(_3.default);
+
+exports.default = RerunFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/snippets_formatter.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _ = require('./');
+
+var _2 = _interopRequireDefault(_);
+
+var _status = require('../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+var _helpers = require('./helpers');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var SnippetsFormatter = function (_Formatter) {
+  (0, _inherits3.default)(SnippetsFormatter, _Formatter);
+
+  function SnippetsFormatter(options) {
+    (0, _classCallCheck3.default)(this, SnippetsFormatter);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (SnippetsFormatter.__proto__ || Object.getPrototypeOf(SnippetsFormatter)).call(this, options));
+
+    options.eventBroadcaster.on('test-step-finished', _this.logUndefinedTestStepSnippet.bind(_this));
+    return _this;
+  }
+
+  (0, _createClass3.default)(SnippetsFormatter, [{
+    key: 'logUndefinedTestStepSnippet',
+    value: function logUndefinedTestStepSnippet(_ref) {
+      var sourceLocation = _ref.testCase.sourceLocation,
+          index = _ref.index,
+          result = _ref.result;
+
+      if (result.status === _status2.default.UNDEFINED) {
+        var _eventDataCollector$g = this.eventDataCollector.getTestCaseData(sourceLocation),
+            gherkinDocument = _eventDataCollector$g.gherkinDocument,
+            testCase = _eventDataCollector$g.testCase;
+
+        var _eventDataCollector$g2 = this.eventDataCollector.getTestStepData({ testCase: testCase, index: index }),
+            pickleStep = _eventDataCollector$g2.pickleStep,
+            gherkinKeyword = _eventDataCollector$g2.gherkinKeyword;
+
+        var previousKeywordType = this.getPreviousKeywordType({
+          gherkinDocument: gherkinDocument,
+          testCase: testCase,
+          index: index
+        });
+        var keywordType = (0, _helpers.getStepKeywordType)({
+          keyword: gherkinKeyword,
+          language: gherkinDocument.feature.language,
+          previousKeywordType: previousKeywordType
+        });
+        var snippet = this.snippetBuilder.build({ keywordType: keywordType, pickleStep: pickleStep });
+        this.log(snippet + '\n\n');
+      }
+    }
+  }, {
+    key: 'getPreviousKeywordType',
+    value: function getPreviousKeywordType(_ref2) {
+      var gherkinDocument = _ref2.gherkinDocument,
+          testCase = _ref2.testCase,
+          index = _ref2.index;
+
+      var previousKeywordType = _helpers.KeywordType.PRECONDITION;
+      for (var i = 0; i < index; i += 1) {
+        var _eventDataCollector$g3 = this.eventDataCollector.getTestStepData({
+          testCase: testCase,
+          index: i
+        }),
+            gherkinKeyword = _eventDataCollector$g3.gherkinKeyword;
+
+        previousKeywordType = (0, _helpers.getStepKeywordType)({
+          keyword: gherkinKeyword,
+          language: gherkinDocument.feature.language,
+          previousKeywordType: previousKeywordType
+        });
+      }
+      return previousKeywordType;
+    }
+  }]);
+  return SnippetsFormatter;
+}(_2.default);
+
+exports.default = SnippetsFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/step_definition_snippet_builder/index.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _cucumberExpressions = require('cucumber-expressions');
+
+var _helpers = require('../helpers');
+
+var _step_arguments = require('../../step_arguments');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var StepDefinitionSnippetBuilder = function () {
+  function StepDefinitionSnippetBuilder(_ref) {
+    var snippetSyntax = _ref.snippetSyntax,
+        parameterTypeRegistry = _ref.parameterTypeRegistry;
+    (0, _classCallCheck3.default)(this, StepDefinitionSnippetBuilder);
+
+    this.snippetSyntax = snippetSyntax;
+    this.cucumberExpressionGenerator = new _cucumberExpressions.CucumberExpressionGenerator(parameterTypeRegistry);
+  }
+
+  (0, _createClass3.default)(StepDefinitionSnippetBuilder, [{
+    key: 'build',
+    value: function build(_ref2) {
+      var keywordType = _ref2.keywordType,
+          pickleStep = _ref2.pickleStep;
+
+      var comment = 'Write code here that turns the phrase above into concrete actions';
+      var functionName = this.getFunctionName(keywordType);
+      var generatedExpressions = this.cucumberExpressionGenerator.generateExpressions(pickleStep.text, true);
+      var stepParameterNames = this.getStepParameterNames(pickleStep);
+      return this.snippetSyntax.build({
+        comment: comment,
+        functionName: functionName,
+        generatedExpressions: generatedExpressions,
+        stepParameterNames: stepParameterNames
+      });
+    }
+  }, {
+    key: 'getFunctionName',
+    value: function getFunctionName(keywordType) {
+      switch (keywordType) {
+        case _helpers.KeywordType.EVENT:
+          return 'When';
+        case _helpers.KeywordType.OUTCOME:
+          return 'Then';
+        case _helpers.KeywordType.PRECONDITION:
+          return 'Given';
+      }
+    }
+  }, {
+    key: 'getStepParameterNames',
+    value: function getStepParameterNames(step) {
+      var iterator = (0, _step_arguments.buildStepArgumentIterator)({
+        dataTable: function dataTable() {
+          return 'dataTable';
+        },
+        docString: function docString() {
+          return 'docString';
+        }
+      });
+      return step.arguments.map(iterator);
+    }
+  }]);
+  return StepDefinitionSnippetBuilder;
+}();
+
+exports.default = StepDefinitionSnippetBuilder;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/step_definition_snippet_builder/javascript_snippet_syntax.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var CALLBACK_NAME = 'callback';
+
+var JavaScriptSnippetSyntax = function () {
+  function JavaScriptSnippetSyntax(snippetInterface) {
+    (0, _classCallCheck3.default)(this, JavaScriptSnippetSyntax);
+
+    this.snippetInterface = snippetInterface;
+  }
+
+  (0, _createClass3.default)(JavaScriptSnippetSyntax, [{
+    key: 'build',
+    value: function build(_ref) {
+      var _this = this;
+
+      var comment = _ref.comment,
+          generatedExpressions = _ref.generatedExpressions,
+          functionName = _ref.functionName,
+          stepParameterNames = _ref.stepParameterNames;
+
+      var functionKeyword = 'function ';
+      if (this.snippetInterface === 'async-await') {
+        functionKeyword = 'async ' + functionKeyword;
+      } else if (this.snippetInterface === 'generator') {
+        functionKeyword += '*';
+      }
+
+      var implementation = void 0;
+      if (this.snippetInterface === 'callback') {
+        implementation = CALLBACK_NAME + '(null, \'pending\');';
+      } else {
+        implementation = "return 'pending';";
+      }
+
+      var definitionChoices = generatedExpressions.map(function (generatedExpression, index) {
+        var prefix = index === 0 ? '' : '// ';
+        var allParameterNames = generatedExpression.parameterNames.concat(stepParameterNames);
+        if (_this.snippetInterface === 'callback') {
+          allParameterNames.push(CALLBACK_NAME);
+        }
+        return prefix + functionName + '(\'' + generatedExpression.source.replace(/'/g, "\\'") + '\', ' + functionKeyword + '(' + allParameterNames.join(', ') + ') {\n';
+      });
+
+      return definitionChoices.join('') + '  // ' + comment + '\n' + ('  ' + implementation + '\n') + '});';
+    }
+  }]);
+  return JavaScriptSnippetSyntax;
+}();
+
+exports.default = JavaScriptSnippetSyntax;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/formatter/test_helpers.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMock = createMock;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _sinon = require('sinon');
+
+var _sinon2 = _interopRequireDefault(_sinon);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createMock(input) {
+  if (_lodash2.default.isArray(input)) {
+    input = _lodash2.default.zipObject(input);
+  }
+  return _lodash2.default.mapValues(input, function (value) {
+    return _sinon2.default.stub().returns(value);
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mb3JtYXR0ZXIvdGVzdF9oZWxwZXJzLmpzIl0sIm5hbWVzIjpbImNyZWF0ZU1vY2siLCJpbnB1dCIsImlzQXJyYXkiLCJ6aXBPYmplY3QiLCJtYXBWYWx1ZXMiLCJzdHViIiwicmV0dXJucyIsInZhbHVlIl0sIm1hcHBpbmdzIjoiOzs7OztRQUdnQkEsVSxHQUFBQSxVOztBQUhoQjs7OztBQUNBOzs7Ozs7QUFFTyxTQUFTQSxVQUFULENBQW9CQyxLQUFwQixFQUEyQjtBQUNoQyxNQUFJLGlCQUFFQyxPQUFGLENBQVVELEtBQVYsQ0FBSixFQUFzQjtBQUNwQkEsWUFBUSxpQkFBRUUsU0FBRixDQUFZRixLQUFaLENBQVI7QUFDRDtBQUNELFNBQU8saUJBQUVHLFNBQUYsQ0FBWUgsS0FBWixFQUFtQjtBQUFBLFdBQVMsZ0JBQU1JLElBQU4sR0FBYUMsT0FBYixDQUFxQkMsS0FBckIsQ0FBVDtBQUFBLEdBQW5CLENBQVA7QUFDRCIsImZpbGUiOiJ0ZXN0X2hlbHBlcnMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5pbXBvcnQgc2lub24gZnJvbSAnc2lub24nXG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVNb2NrKGlucHV0KSB7XG4gIGlmIChfLmlzQXJyYXkoaW5wdXQpKSB7XG4gICAgaW5wdXQgPSBfLnppcE9iamVjdChpbnB1dClcbiAgfVxuICByZXR1cm4gXy5tYXBWYWx1ZXMoaW5wdXQsIHZhbHVlID0+IHNpbm9uLnN0dWIoKS5yZXR1cm5zKHZhbHVlKSlcbn1cbiJdfQ==

node_modules/cucumber/lib/formatter/usage_json_formatter.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _helpers = require('./helpers');
+
+var _ = require('./');
+
+var _2 = _interopRequireDefault(_);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var UsageJsonFormatter = function (_Formatter) {
+  (0, _inherits3.default)(UsageJsonFormatter, _Formatter);
+
+  function UsageJsonFormatter(options) {
+    (0, _classCallCheck3.default)(this, UsageJsonFormatter);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (UsageJsonFormatter.__proto__ || Object.getPrototypeOf(UsageJsonFormatter)).call(this, options));
+
+    options.eventBroadcaster.on('test-run-finished', _this.logUsage.bind(_this));
+    return _this;
+  }
+
+  (0, _createClass3.default)(UsageJsonFormatter, [{
+    key: 'logUsage',
+    value: function logUsage() {
+      var usage = (0, _helpers.getUsage)({
+        stepDefinitions: this.supportCodeLibrary.stepDefinitions,
+        eventDataCollector: this.eventDataCollector
+      });
+      this.log(JSON.stringify(usage, null, 2));
+    }
+  }]);
+  return UsageJsonFormatter;
+}(_2.default);
+
+exports.default = UsageJsonFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mb3JtYXR0ZXIvdXNhZ2VfanNvbl9mb3JtYXR0ZXIuanMiXSwibmFtZXMiOlsiVXNhZ2VKc29uRm9ybWF0dGVyIiwib3B0aW9ucyIsImV2ZW50QnJvYWRjYXN0ZXIiLCJvbiIsImxvZ1VzYWdlIiwidXNhZ2UiLCJzdGVwRGVmaW5pdGlvbnMiLCJzdXBwb3J0Q29kZUxpYnJhcnkiLCJldmVudERhdGFDb2xsZWN0b3IiLCJsb2ciLCJKU09OIiwic3RyaW5naWZ5Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7O0FBQ0E7Ozs7OztJQUVxQkEsa0I7OztBQUNuQiw4QkFBWUMsT0FBWixFQUFxQjtBQUFBOztBQUFBLHNKQUNiQSxPQURhOztBQUVuQkEsWUFBUUMsZ0JBQVIsQ0FBeUJDLEVBQXpCLENBQTRCLG1CQUE1QixFQUFtRCxNQUFLQyxRQUF4RDtBQUZtQjtBQUdwQjs7OzsrQkFFVTtBQUNULFVBQU1DLFFBQVEsdUJBQVM7QUFDckJDLHlCQUFpQixLQUFLQyxrQkFBTCxDQUF3QkQsZUFEcEI7QUFFckJFLDRCQUFvQixLQUFLQTtBQUZKLE9BQVQsQ0FBZDtBQUlBLFdBQUtDLEdBQUwsQ0FBU0MsS0FBS0MsU0FBTCxDQUFlTixLQUFmLEVBQXNCLElBQXRCLEVBQTRCLENBQTVCLENBQVQ7QUFDRDs7Ozs7a0JBWmtCTCxrQiIsImZpbGUiOiJ1c2FnZV9qc29uX2Zvcm1hdHRlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldFVzYWdlIH0gZnJvbSAnLi9oZWxwZXJzJ1xuaW1wb3J0IEZvcm1hdHRlciBmcm9tICcuLydcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVXNhZ2VKc29uRm9ybWF0dGVyIGV4dGVuZHMgRm9ybWF0dGVyIHtcbiAgY29uc3RydWN0b3Iob3B0aW9ucykge1xuICAgIHN1cGVyKG9wdGlvbnMpXG4gICAgb3B0aW9ucy5ldmVudEJyb2FkY2FzdGVyLm9uKCd0ZXN0LXJ1bi1maW5pc2hlZCcsIDo6dGhpcy5sb2dVc2FnZSlcbiAgfVxuXG4gIGxvZ1VzYWdlKCkge1xuICAgIGNvbnN0IHVzYWdlID0gZ2V0VXNhZ2Uoe1xuICAgICAgc3RlcERlZmluaXRpb25zOiB0aGlzLnN1cHBvcnRDb2RlTGlicmFyeS5zdGVwRGVmaW5pdGlvbnMsXG4gICAgICBldmVudERhdGFDb2xsZWN0b3I6IHRoaXMuZXZlbnREYXRhQ29sbGVjdG9yLFxuICAgIH0pXG4gICAgdGhpcy5sb2coSlNPTi5zdHJpbmdpZnkodXNhZ2UsIG51bGwsIDIpKVxuICB9XG59XG4iXX0=

node_modules/cucumber/lib/index.js

@@ -0,0 +1,183 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.When = exports.Then = exports.setWorldConstructor = exports.setDefinitionFunctionWrapper = exports.setDefaultTimeout = exports.Given = exports.defineSupportCode = exports.defineStep = exports.defineParameterType = exports.BeforeAll = exports.Before = exports.AfterAll = exports.After = exports.formatterHelpers = exports.UsageJsonFormatter = exports.UsageFormatter = exports.SummaryFormatter = exports.SnippetsFormatter = exports.RerunFormatter = exports.ProgressFormatter = exports.JsonFormatter = exports.FormatterBuilder = exports.Formatter = exports.supportCodeLibraryBuilder = exports.Status = exports.Runtime = exports.PickleFilter = exports.orderTestCases = exports.getTestCasesFromFilesystem = exports.getTestCases = exports.Cli = undefined;
+
+var _cli = require('./cli');
+
+Object.defineProperty(exports, 'Cli', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_cli).default;
+  }
+});
+
+var _helpers = require('./cli/helpers');
+
+Object.defineProperty(exports, 'getTestCases', {
+  enumerable: true,
+  get: function get() {
+    return _helpers.getTestCases;
+  }
+});
+Object.defineProperty(exports, 'getTestCasesFromFilesystem', {
+  enumerable: true,
+  get: function get() {
+    return _helpers.getTestCasesFromFilesystem;
+  }
+});
+Object.defineProperty(exports, 'orderTestCases', {
+  enumerable: true,
+  get: function get() {
+    return _helpers.orderTestCases;
+  }
+});
+
+var _pickle_filter = require('./pickle_filter');
+
+Object.defineProperty(exports, 'PickleFilter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_pickle_filter).default;
+  }
+});
+
+var _runtime = require('./runtime');
+
+Object.defineProperty(exports, 'Runtime', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_runtime).default;
+  }
+});
+
+var _status = require('./status');
+
+Object.defineProperty(exports, 'Status', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_status).default;
+  }
+});
+
+var _support_code_library_builder = require('./support_code_library_builder');
+
+Object.defineProperty(exports, 'supportCodeLibraryBuilder', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_support_code_library_builder).default;
+  }
+});
+
+var _formatter = require('./formatter');
+
+Object.defineProperty(exports, 'Formatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_formatter).default;
+  }
+});
+
+var _builder = require('./formatter/builder');
+
+Object.defineProperty(exports, 'FormatterBuilder', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_builder).default;
+  }
+});
+
+var _json_formatter = require('./formatter/json_formatter');
+
+Object.defineProperty(exports, 'JsonFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_json_formatter).default;
+  }
+});
+
+var _progress_formatter = require('./formatter/progress_formatter');
+
+Object.defineProperty(exports, 'ProgressFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_progress_formatter).default;
+  }
+});
+
+var _rerun_formatter = require('./formatter/rerun_formatter');
+
+Object.defineProperty(exports, 'RerunFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_rerun_formatter).default;
+  }
+});
+
+var _snippets_formatter = require('./formatter/snippets_formatter');
+
+Object.defineProperty(exports, 'SnippetsFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_snippets_formatter).default;
+  }
+});
+
+var _summary_formatter = require('./formatter/summary_formatter');
+
+Object.defineProperty(exports, 'SummaryFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_summary_formatter).default;
+  }
+});
+
+var _usage_formatter = require('./formatter/usage_formatter');
+
+Object.defineProperty(exports, 'UsageFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_usage_formatter).default;
+  }
+});
+
+var _usage_json_formatter = require('./formatter/usage_json_formatter');
+
+Object.defineProperty(exports, 'UsageJsonFormatter', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_usage_json_formatter).default;
+  }
+});
+
+var _helpers2 = require('./formatter/helpers');
+
+var formatterHelpers = _interopRequireWildcard(_helpers2);
+
+var _support_code_library_builder2 = _interopRequireDefault(_support_code_library_builder);
+
+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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.formatterHelpers = formatterHelpers;
+
+// Support Code Fuctions
+
+var methods = _support_code_library_builder2.default.methods;
+var After = exports.After = methods.After;
+var AfterAll = exports.AfterAll = methods.AfterAll;
+var Before = exports.Before = methods.Before;
+var BeforeAll = exports.BeforeAll = methods.BeforeAll;
+var defineParameterType = exports.defineParameterType = methods.defineParameterType;
+var defineStep = exports.defineStep = methods.defineStep;
+var defineSupportCode = exports.defineSupportCode = methods.defineSupportCode;
+var Given = exports.Given = methods.Given;
+var setDefaultTimeout = exports.setDefaultTimeout = methods.setDefaultTimeout;
+var setDefinitionFunctionWrapper = exports.setDefinitionFunctionWrapper = methods.setDefinitionFunctionWrapper;
+var setWorldConstructor = exports.setWorldConstructor = methods.setWorldConstructor;
+var Then = exports.Then = methods.Then;
+var When = exports.When = methods.When;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/models/data_table.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var DataTable = function () {
+  function DataTable(gherkinData) {
+    (0, _classCallCheck3.default)(this, DataTable);
+
+    this.rawTable = gherkinData.rows.map(function (row) {
+      return row.cells.map(function (cell) {
+        return cell.value;
+      });
+    });
+  }
+
+  (0, _createClass3.default)(DataTable, [{
+    key: 'hashes',
+    value: function hashes() {
+      var copy = this.raw();
+      var keys = copy[0];
+      var valuesArray = copy.slice(1);
+      return valuesArray.map(function (values) {
+        return _lodash2.default.zipObject(keys, values);
+      });
+    }
+  }, {
+    key: 'raw',
+    value: function raw() {
+      return this.rawTable.slice(0);
+    }
+  }, {
+    key: 'rows',
+    value: function rows() {
+      var copy = this.raw();
+      copy.shift();
+      return copy;
+    }
+  }, {
+    key: 'rowsHash',
+    value: function rowsHash() {
+      var rows = this.raw();
+      var everyRowHasTwoColumns = _lodash2.default.every(rows, function (row) {
+        return row.length === 2;
+      });
+      if (!everyRowHasTwoColumns) {
+        throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns');
+      }
+      return _lodash2.default.fromPairs(rows);
+    }
+  }]);
+  return DataTable;
+}();
+
+exports.default = DataTable;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/models/test_case_hook_definition.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _pickle_filter = require('../pickle_filter');
+
+var _pickle_filter2 = _interopRequireDefault(_pickle_filter);
+
+var _step_definition = require('./step_definition');
+
+var _step_definition2 = _interopRequireDefault(_step_definition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var TestCaseHookDefinition = function (_StepDefinition) {
+  (0, _inherits3.default)(TestCaseHookDefinition, _StepDefinition);
+
+  function TestCaseHookDefinition(data) {
+    (0, _classCallCheck3.default)(this, TestCaseHookDefinition);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (TestCaseHookDefinition.__proto__ || Object.getPrototypeOf(TestCaseHookDefinition)).call(this, data));
+
+    _this.pickleFilter = new _pickle_filter2.default({
+      tagExpression: _this.options.tags
+    });
+    return _this;
+  }
+
+  (0, _createClass3.default)(TestCaseHookDefinition, [{
+    key: 'appliesToTestCase',
+    value: function appliesToTestCase(_ref) {
+      var pickle = _ref.pickle,
+          uri = _ref.uri;
+
+      return this.pickleFilter.matches({ pickle: pickle, uri: uri });
+    }
+  }, {
+    key: 'getInvalidCodeLengthMessage',
+    value: function getInvalidCodeLengthMessage() {
+      return this.buildInvalidCodeLengthMessage('0 or 1', '2');
+    }
+  }, {
+    key: 'getInvocationParameters',
+    value: function getInvocationParameters(_ref2) {
+      var hookParameter = _ref2.hookParameter;
+
+      return [hookParameter];
+    }
+  }, {
+    key: 'getValidCodeLengths',
+    value: function getValidCodeLengths() {
+      return [0, 1, 2];
+    }
+  }]);
+  return TestCaseHookDefinition;
+}(_step_definition2.default);
+
+exports.default = TestCaseHookDefinition;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/models/test_run_hook_definition.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _step_definition = require('./step_definition');
+
+var _step_definition2 = _interopRequireDefault(_step_definition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var TestRunHookDefinition = function (_StepDefinition) {
+  (0, _inherits3.default)(TestRunHookDefinition, _StepDefinition);
+
+  function TestRunHookDefinition() {
+    (0, _classCallCheck3.default)(this, TestRunHookDefinition);
+    return (0, _possibleConstructorReturn3.default)(this, (TestRunHookDefinition.__proto__ || Object.getPrototypeOf(TestRunHookDefinition)).apply(this, arguments));
+  }
+
+  (0, _createClass3.default)(TestRunHookDefinition, [{
+    key: 'getInvalidCodeLengthMessage',
+    value: function getInvalidCodeLengthMessage() {
+      return this.buildInvalidCodeLengthMessage('0', '1');
+    }
+  }, {
+    key: 'getInvocationParameters',
+    value: function getInvocationParameters() {
+      return [];
+    }
+  }, {
+    key: 'getValidCodeLengths',
+    value: function getValidCodeLengths() {
+      return [0, 1];
+    }
+  }]);
+  return TestRunHookDefinition;
+}(_step_definition2.default);
+
+exports.default = TestRunHookDefinition;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tb2RlbHMvdGVzdF9ydW5faG9va19kZWZpbml0aW9uLmpzIl0sIm5hbWVzIjpbIlRlc3RSdW5Ib29rRGVmaW5pdGlvbiIsImJ1aWxkSW52YWxpZENvZGVMZW5ndGhNZXNzYWdlIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7Ozs7OztJQUVxQkEscUI7Ozs7Ozs7Ozs7a0RBQ1c7QUFDNUIsYUFBTyxLQUFLQyw2QkFBTCxDQUFtQyxHQUFuQyxFQUF3QyxHQUF4QyxDQUFQO0FBQ0Q7Ozs4Q0FFeUI7QUFDeEIsYUFBTyxFQUFQO0FBQ0Q7OzswQ0FFcUI7QUFDcEIsYUFBTyxDQUFDLENBQUQsRUFBSSxDQUFKLENBQVA7QUFDRDs7Ozs7a0JBWGtCRCxxQiIsImZpbGUiOiJ0ZXN0X3J1bl9ob29rX2RlZmluaXRpb24uanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgU3RlcERlZmluaXRpb24gZnJvbSAnLi9zdGVwX2RlZmluaXRpb24nXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFRlc3RSdW5Ib29rRGVmaW5pdGlvbiBleHRlbmRzIFN0ZXBEZWZpbml0aW9uIHtcbiAgZ2V0SW52YWxpZENvZGVMZW5ndGhNZXNzYWdlKCkge1xuICAgIHJldHVybiB0aGlzLmJ1aWxkSW52YWxpZENvZGVMZW5ndGhNZXNzYWdlKCcwJywgJzEnKVxuICB9XG5cbiAgZ2V0SW52b2NhdGlvblBhcmFtZXRlcnMoKSB7XG4gICAgcmV0dXJuIFtdXG4gIH1cblxuICBnZXRWYWxpZENvZGVMZW5ndGhzKCkge1xuICAgIHJldHVybiBbMCwgMV1cbiAgfVxufVxuIl19

node_modules/cucumber/lib/runtime/attachment_manager/index.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _isStream = require('is-stream');
+
+var _isStream2 = _interopRequireDefault(_isStream);
+
+var _bluebird = require('bluebird');
+
+var _bluebird2 = _interopRequireDefault(_bluebird);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var AttachmentManager = function () {
+  function AttachmentManager(onAttachment) {
+    (0, _classCallCheck3.default)(this, AttachmentManager);
+
+    this.onAttachment = onAttachment;
+  }
+
+  (0, _createClass3.default)(AttachmentManager, [{
+    key: 'create',
+    value: function create(data, mediaType, callback) {
+      if (Buffer.isBuffer(data)) {
+        if (!mediaType) {
+          throw Error('Buffer attachments must specify a media type');
+        }
+        this.createBufferAttachment(data, mediaType);
+      } else if (_isStream2.default.readable(data)) {
+        if (!mediaType) {
+          throw Error('Stream attachments must specify a media type');
+        }
+        return this.createStreamAttachment(data, mediaType, callback);
+      } else if (typeof data === 'string') {
+        if (!mediaType) {
+          mediaType = 'text/plain';
+        }
+        this.createStringAttachment(data, { type: mediaType });
+      } else {
+        throw Error('Invalid attachment data: must be a buffer, readable stream, or string');
+      }
+    }
+  }, {
+    key: 'createBufferAttachment',
+    value: function createBufferAttachment(data, mediaType) {
+      this.createStringAttachment(data.toString('base64'), {
+        encoding: 'base64',
+        type: mediaType
+      });
+    }
+  }, {
+    key: 'createStreamAttachment',
+    value: function createStreamAttachment(data, mediaType, callback) {
+      var _this = this;
+
+      var promise = new _bluebird2.default(function (resolve, reject) {
+        var buffers = [];
+        data.on('data', function (chunk) {
+          buffers.push(chunk);
+        });
+        data.on('end', function () {
+          _this.createBufferAttachment(Buffer.concat(buffers), mediaType);
+          resolve();
+        });
+        data.on('error', reject);
+      });
+      if (callback) {
+        promise.then(callback, callback);
+      } else {
+        return promise;
+      }
+    }
+  }, {
+    key: 'createStringAttachment',
+    value: function createStringAttachment(data, media) {
+      this.onAttachment({ data: data, media: media });
+    }
+  }]);
+  return AttachmentManager;
+}();
+
+exports.default = AttachmentManager;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/runtime/helpers.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+exports.getAmbiguousStepException = getAmbiguousStepException;
+
+var _location_helpers = require('../formatter/helpers/location_helpers');
+
+var _cliTable = require('cli-table');
+
+var _cliTable2 = _interopRequireDefault(_cliTable);
+
+var _indentString = require('indent-string');
+
+var _indentString2 = _interopRequireDefault(_indentString);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getAmbiguousStepException(stepDefinitions) {
+  var table = new _cliTable2.default({
+    chars: {
+      bottom: '',
+      'bottom-left': '',
+      'bottom-mid': '',
+      'bottom-right': '',
+      left: '',
+      'left-mid': '',
+      mid: '',
+      'mid-mid': '',
+      middle: ' - ',
+      right: '',
+      'right-mid': '',
+      top: '',
+      'top-left': '',
+      'top-mid': '',
+      'top-right': ''
+    },
+    style: {
+      border: [],
+      'padding-left': 0,
+      'padding-right': 0
+    }
+  });
+  table.push.apply(table, (0, _toConsumableArray3.default)(stepDefinitions.map(function (stepDefinition) {
+    var pattern = stepDefinition.pattern.toString();
+    return [pattern, (0, _location_helpers.formatLocation)(stepDefinition)];
+  })));
+  return '' + ('Multiple step definitions match:' + '\n') + (0, _indentString2.default)(table.toString(), 2);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/runtime/parallel/command_types.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var commandTypes = {
+  INITIALIZE: 'initialize',
+  RUN: 'run',
+  READY: 'ready',
+  FINALIZE: 'finalize',
+  EVENT: 'event'
+};
+
+exports.default = commandTypes;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ydW50aW1lL3BhcmFsbGVsL2NvbW1hbmRfdHlwZXMuanMiXSwibmFtZXMiOlsiY29tbWFuZFR5cGVzIiwiSU5JVElBTElaRSIsIlJVTiIsIlJFQURZIiwiRklOQUxJWkUiLCJFVkVOVCJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxJQUFNQSxlQUFlO0FBQ25CQyxjQUFZLFlBRE87QUFFbkJDLE9BQUssS0FGYztBQUduQkMsU0FBTyxPQUhZO0FBSW5CQyxZQUFVLFVBSlM7QUFLbkJDLFNBQU87QUFMWSxDQUFyQjs7a0JBUWVMLFkiLCJmaWxlIjoiY29tbWFuZF90eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImNvbnN0IGNvbW1hbmRUeXBlcyA9IHtcbiAgSU5JVElBTElaRTogJ2luaXRpYWxpemUnLFxuICBSVU46ICdydW4nLFxuICBSRUFEWTogJ3JlYWR5JyxcbiAgRklOQUxJWkU6ICdmaW5hbGl6ZScsXG4gIEVWRU5UOiAnZXZlbnQnLFxufVxuXG5leHBvcnQgZGVmYXVsdCBjb21tYW5kVHlwZXNcbiJdfQ==

node_modules/cucumber/lib/runtime/parallel/run_slave.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _bluebird = require('bluebird');
+
+var _slave = require('./slave');
+
+var _slave2 = _interopRequireDefault(_slave);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function () {
+  var _ref = (0, _bluebird.coroutine)(function* () {
+    var slave = new _slave2.default({
+      stdin: process.stdin,
+      stdout: process.stdout,
+      cwd: process.cwd()
+    });
+    yield slave.run();
+  });
+
+  function run() {
+    return _ref.apply(this, arguments);
+  }
+
+  return run;
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ydW50aW1lL3BhcmFsbGVsL3J1bl9zbGF2ZS5qcyJdLCJuYW1lcyI6WyJzbGF2ZSIsInN0ZGluIiwicHJvY2VzcyIsInN0ZG91dCIsImN3ZCIsInJ1biJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7Ozs7OztzQ0FFZSxhQUFxQjtBQUNsQyxRQUFNQSxRQUFRLG9CQUFVO0FBQ3RCQyxhQUFPQyxRQUFRRCxLQURPO0FBRXRCRSxjQUFRRCxRQUFRQyxNQUZNO0FBR3RCQyxXQUFLRixRQUFRRSxHQUFSO0FBSGlCLEtBQVYsQ0FBZDtBQUtBLFVBQU1KLE1BQU1LLEdBQU4sRUFBTjtBQUNELEc7O1dBUDZCQSxHOzs7O1NBQUFBLEciLCJmaWxlIjoicnVuX3NsYXZlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFNsYXZlIGZyb20gJy4vc2xhdmUnXG5cbmV4cG9ydCBkZWZhdWx0IGFzeW5jIGZ1bmN0aW9uIHJ1bigpIHtcbiAgY29uc3Qgc2xhdmUgPSBuZXcgU2xhdmUoe1xuICAgIHN0ZGluOiBwcm9jZXNzLnN0ZGluLFxuICAgIHN0ZG91dDogcHJvY2Vzcy5zdGRvdXQsXG4gICAgY3dkOiBwcm9jZXNzLmN3ZCgpLFxuICB9KVxuICBhd2FpdCBzbGF2ZS5ydW4oKVxufVxuIl19

node_modules/cucumber/lib/runtime/stack_trace_filter.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _stackChain = require('stack-chain');
+
+var _stackChain2 = _interopRequireDefault(_stackChain);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var StackTraceFilter = function () {
+  function StackTraceFilter() {
+    (0, _classCallCheck3.default)(this, StackTraceFilter);
+
+    this.cucumberPath = _path2.default.join(__dirname, '..', '..');
+  }
+
+  (0, _createClass3.default)(StackTraceFilter, [{
+    key: 'filter',
+    value: function filter() {
+      var _this = this;
+
+      this.currentFilter = _stackChain2.default.filter.attach(function (_err, frames) {
+        if (_this.isErrorInCucumber(frames)) {
+          return frames;
+        }
+        var index = _lodash2.default.findIndex(frames, _this.isFrameInCucumber.bind(_this));
+        if (index === -1) {
+          return frames;
+        }
+        return frames.slice(0, index);
+      });
+    }
+  }, {
+    key: 'isErrorInCucumber',
+    value: function isErrorInCucumber(frames) {
+      var filteredFrames = _lodash2.default.reject(frames, this.isFrameInNode.bind(this));
+      return filteredFrames.length > 0 && this.isFrameInCucumber(filteredFrames[0]);
+    }
+  }, {
+    key: 'isFrameInCucumber',
+    value: function isFrameInCucumber(frame) {
+      var fileName = frame.getFileName() || '';
+      return _lodash2.default.startsWith(fileName, this.cucumberPath);
+    }
+  }, {
+    key: 'isFrameInNode',
+    value: function isFrameInNode(frame) {
+      var fileName = frame.getFileName() || '';
+      return !_lodash2.default.includes(fileName, _path2.default.sep);
+    }
+  }, {
+    key: 'unfilter',
+    value: function unfilter() {
+      _stackChain2.default.filter.deattach(this.currentFilter);
+    }
+  }]);
+  return StackTraceFilter;
+}();
+
+exports.default = StackTraceFilter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/runtime/step_runner.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _bluebird = require('bluebird');
+
+var _bluebird2 = _interopRequireDefault(_bluebird);
+
+var run = function () {
+  var _ref2 = (0, _bluebird.coroutine)(function* (_ref) {
+    var defaultTimeout = _ref.defaultTimeout,
+        hookParameter = _ref.hookParameter,
+        parameterTypeRegistry = _ref.parameterTypeRegistry,
+        step = _ref.step,
+        stepDefinition = _ref.stepDefinition,
+        world = _ref.world;
+
+    beginTiming();
+    var error = void 0,
+        result = void 0,
+        parameters = void 0;
+
+    try {
+      parameters = yield _bluebird2.default.all(stepDefinition.getInvocationParameters({
+        hookParameter: hookParameter,
+        parameterTypeRegistry: parameterTypeRegistry,
+        step: step,
+        world: world
+      }));
+    } catch (err) {
+      error = err;
+    }
+
+    if (!error) {
+      var timeoutInMilliseconds = stepDefinition.options.timeout || defaultTimeout;
+
+      var validCodeLengths = stepDefinition.getValidCodeLengths(parameters);
+      if (_lodash2.default.includes(validCodeLengths, stepDefinition.code.length)) {
+        var data = yield _user_code_runner2.default.run({
+          argsArray: parameters,
+          fn: stepDefinition.code,
+          thisArg: world,
+          timeoutInMilliseconds: timeoutInMilliseconds
+        });
+        error = data.error;
+        result = data.result;
+      } else {
+        error = stepDefinition.getInvalidCodeLengthMessage(parameters);
+      }
+    }
+
+    var testStepResult = { duration: endTiming() };
+
+    if (result === 'skipped') {
+      testStepResult.status = _status2.default.SKIPPED;
+    } else if (result === 'pending') {
+      testStepResult.status = _status2.default.PENDING;
+    } else if (error) {
+      testStepResult.exception = error;
+      testStepResult.status = _status2.default.FAILED;
+    } else {
+      testStepResult.status = _status2.default.PASSED;
+    }
+
+    return testStepResult;
+  });
+
+  return function run(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _status = require('../status');
+
+var _status2 = _interopRequireDefault(_status);
+
+var _time = require('../time');
+
+var _time2 = _interopRequireDefault(_time);
+
+var _user_code_runner = require('../user_code_runner');
+
+var _user_code_runner2 = _interopRequireDefault(_user_code_runner);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var beginTiming = _time2.default.beginTiming,
+    endTiming = _time2.default.endTiming;
+exports.default = { run: run };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL3N0ZXBfcnVubmVyLmpzIl0sIm5hbWVzIjpbImRlZmF1bHRUaW1lb3V0IiwiaG9va1BhcmFtZXRlciIsInBhcmFtZXRlclR5cGVSZWdpc3RyeSIsInN0ZXAiLCJzdGVwRGVmaW5pdGlvbiIsIndvcmxkIiwiYmVnaW5UaW1pbmciLCJlcnJvciIsInJlc3VsdCIsInBhcmFtZXRlcnMiLCJhbGwiLCJnZXRJbnZvY2F0aW9uUGFyYW1ldGVycyIsImVyciIsInRpbWVvdXRJbk1pbGxpc2Vjb25kcyIsIm9wdGlvbnMiLCJ0aW1lb3V0IiwidmFsaWRDb2RlTGVuZ3RocyIsImdldFZhbGlkQ29kZUxlbmd0aHMiLCJpbmNsdWRlcyIsImNvZGUiLCJsZW5ndGgiLCJkYXRhIiwicnVuIiwiYXJnc0FycmF5IiwiZm4iLCJ0aGlzQXJnIiwiZ2V0SW52YWxpZENvZGVMZW5ndGhNZXNzYWdlIiwidGVzdFN0ZXBSZXN1bHQiLCJkdXJhdGlvbiIsImVuZFRpbWluZyIsInN0YXR1cyIsIlNLSVBQRUQiLCJQRU5ESU5HIiwiZXhjZXB0aW9uIiwiRkFJTEVEIiwiUEFTU0VEIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozt1Q0FRQSxpQkFPRztBQUFBLFFBTkRBLGNBTUMsUUFOREEsY0FNQztBQUFBLFFBTERDLGFBS0MsUUFMREEsYUFLQztBQUFBLFFBSkRDLHFCQUlDLFFBSkRBLHFCQUlDO0FBQUEsUUFIREMsSUFHQyxRQUhEQSxJQUdDO0FBQUEsUUFGREMsY0FFQyxRQUZEQSxjQUVDO0FBQUEsUUFEREMsS0FDQyxRQUREQSxLQUNDOztBQUNEQztBQUNBLFFBQUlDLGNBQUo7QUFBQSxRQUFXQyxlQUFYO0FBQUEsUUFBbUJDLG1CQUFuQjs7QUFFQSxRQUFJO0FBQ0ZBLG1CQUFhLE1BQU0sbUJBQVFDLEdBQVIsQ0FDakJOLGVBQWVPLHVCQUFmLENBQXVDO0FBQ3JDVixvQ0FEcUM7QUFFckNDLG9EQUZxQztBQUdyQ0Msa0JBSHFDO0FBSXJDRTtBQUpxQyxPQUF2QyxDQURpQixDQUFuQjtBQVFELEtBVEQsQ0FTRSxPQUFPTyxHQUFQLEVBQVk7QUFDWkwsY0FBUUssR0FBUjtBQUNEOztBQUVELFFBQUksQ0FBQ0wsS0FBTCxFQUFZO0FBQ1YsVUFBTU0sd0JBQ0pULGVBQWVVLE9BQWYsQ0FBdUJDLE9BQXZCLElBQWtDZixjQURwQzs7QUFHQSxVQUFNZ0IsbUJBQW1CWixlQUFlYSxtQkFBZixDQUFtQ1IsVUFBbkMsQ0FBekI7QUFDQSxVQUFJLGlCQUFFUyxRQUFGLENBQVdGLGdCQUFYLEVBQTZCWixlQUFlZSxJQUFmLENBQW9CQyxNQUFqRCxDQUFKLEVBQThEO0FBQzVELFlBQU1DLE9BQU8sTUFBTSwyQkFBZUMsR0FBZixDQUFtQjtBQUNwQ0MscUJBQVdkLFVBRHlCO0FBRXBDZSxjQUFJcEIsZUFBZWUsSUFGaUI7QUFHcENNLG1CQUFTcEIsS0FIMkI7QUFJcENRO0FBSm9DLFNBQW5CLENBQW5CO0FBTUFOLGdCQUFRYyxLQUFLZCxLQUFiO0FBQ0FDLGlCQUFTYSxLQUFLYixNQUFkO0FBQ0QsT0FURCxNQVNPO0FBQ0xELGdCQUFRSCxlQUFlc0IsMkJBQWYsQ0FBMkNqQixVQUEzQyxDQUFSO0FBQ0Q7QUFDRjs7QUFFRCxRQUFNa0IsaUJBQWlCLEVBQUVDLFVBQVVDLFdBQVosRUFBdkI7O0FBRUEsUUFBSXJCLFdBQVcsU0FBZixFQUEwQjtBQUN4Qm1CLHFCQUFlRyxNQUFmLEdBQXdCLGlCQUFPQyxPQUEvQjtBQUNELEtBRkQsTUFFTyxJQUFJdkIsV0FBVyxTQUFmLEVBQTBCO0FBQy9CbUIscUJBQWVHLE1BQWYsR0FBd0IsaUJBQU9FLE9BQS9CO0FBQ0QsS0FGTSxNQUVBLElBQUl6QixLQUFKLEVBQVc7QUFDaEJvQixxQkFBZU0sU0FBZixHQUEyQjFCLEtBQTNCO0FBQ0FvQixxQkFBZUcsTUFBZixHQUF3QixpQkFBT0ksTUFBL0I7QUFDRCxLQUhNLE1BR0E7QUFDTFAscUJBQWVHLE1BQWYsR0FBd0IsaUJBQU9LLE1BQS9CO0FBQ0Q7O0FBRUQsV0FBT1IsY0FBUDtBQUNELEc7O2tCQXpEY0wsRzs7Ozs7QUFSZjs7OztBQUNBOzs7O0FBQ0E7Ozs7QUFDQTs7Ozs7O0lBR1FoQixXLGtCQUFBQSxXO0lBQWF1QixTLGtCQUFBQSxTO2tCQTZETixFQUFFUCxRQUFGLEUiLCJmaWxlIjoic3RlcF9ydW5uZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5pbXBvcnQgU3RhdHVzIGZyb20gJy4uL3N0YXR1cydcbmltcG9ydCBUaW1lIGZyb20gJy4uL3RpbWUnXG5pbXBvcnQgVXNlckNvZGVSdW5uZXIgZnJvbSAnLi4vdXNlcl9jb2RlX3J1bm5lcidcbmltcG9ydCBQcm9taXNlIGZyb20gJ2JsdWViaXJkJ1xuXG5jb25zdCB7IGJlZ2luVGltaW5nLCBlbmRUaW1pbmcgfSA9IFRpbWVcblxuYXN5bmMgZnVuY3Rpb24gcnVuKHtcbiAgZGVmYXVsdFRpbWVvdXQsXG4gIGhvb2tQYXJhbWV0ZXIsXG4gIHBhcmFtZXRlclR5cGVSZWdpc3RyeSxcbiAgc3RlcCxcbiAgc3RlcERlZmluaXRpb24sXG4gIHdvcmxkLFxufSkge1xuICBiZWdpblRpbWluZygpXG4gIGxldCBlcnJvciwgcmVzdWx0LCBwYXJhbWV0ZXJzXG5cbiAgdHJ5IHtcbiAgICBwYXJhbWV0ZXJzID0gYXdhaXQgUHJvbWlzZS5hbGwoXG4gICAgICBzdGVwRGVmaW5pdGlvbi5nZXRJbnZvY2F0aW9uUGFyYW1ldGVycyh7XG4gICAgICAgIGhvb2tQYXJhbWV0ZXIsXG4gICAgICAgIHBhcmFtZXRlclR5cGVSZWdpc3RyeSxcbiAgICAgICAgc3RlcCxcbiAgICAgICAgd29ybGQsXG4gICAgICB9KVxuICAgIClcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgZXJyb3IgPSBlcnJcbiAgfVxuXG4gIGlmICghZXJyb3IpIHtcbiAgICBjb25zdCB0aW1lb3V0SW5NaWxsaXNlY29uZHMgPVxuICAgICAgc3RlcERlZmluaXRpb24ub3B0aW9ucy50aW1lb3V0IHx8IGRlZmF1bHRUaW1lb3V0XG5cbiAgICBjb25zdCB2YWxpZENvZGVMZW5ndGhzID0gc3RlcERlZmluaXRpb24uZ2V0VmFsaWRDb2RlTGVuZ3RocyhwYXJhbWV0ZXJzKVxuICAgIGlmIChfLmluY2x1ZGVzKHZhbGlkQ29kZUxlbmd0aHMsIHN0ZXBEZWZpbml0aW9uLmNvZGUubGVuZ3RoKSkge1xuICAgICAgY29uc3QgZGF0YSA9IGF3YWl0IFVzZXJDb2RlUnVubmVyLnJ1bih7XG4gICAgICAgIGFyZ3NBcnJheTogcGFyYW1ldGVycyxcbiAgICAgICAgZm46IHN0ZXBEZWZpbml0aW9uLmNvZGUsXG4gICAgICAgIHRoaXNBcmc6IHdvcmxkLFxuICAgICAgICB0aW1lb3V0SW5NaWxsaXNlY29uZHMsXG4gICAgICB9KVxuICAgICAgZXJyb3IgPSBkYXRhLmVycm9yXG4gICAgICByZXN1bHQgPSBkYXRhLnJlc3VsdFxuICAgIH0gZWxzZSB7XG4gICAgICBlcnJvciA9IHN0ZXBEZWZpbml0aW9uLmdldEludmFsaWRDb2RlTGVuZ3RoTWVzc2FnZShwYXJhbWV0ZXJzKVxuICAgIH1cbiAgfVxuXG4gIGNvbnN0IHRlc3RTdGVwUmVzdWx0ID0geyBkdXJhdGlvbjogZW5kVGltaW5nKCkgfVxuXG4gIGlmIChyZXN1bHQgPT09ICdza2lwcGVkJykge1xuICAgIHRlc3RTdGVwUmVzdWx0LnN0YXR1cyA9IFN0YXR1cy5TS0lQUEVEXG4gIH0gZWxzZSBpZiAocmVzdWx0ID09PSAncGVuZGluZycpIHtcbiAgICB0ZXN0U3RlcFJlc3VsdC5zdGF0dXMgPSBTdGF0dXMuUEVORElOR1xuICB9IGVsc2UgaWYgKGVycm9yKSB7XG4gICAgdGVzdFN0ZXBSZXN1bHQuZXhjZXB0aW9uID0gZXJyb3JcbiAgICB0ZXN0U3RlcFJlc3VsdC5zdGF0dXMgPSBTdGF0dXMuRkFJTEVEXG4gIH0gZWxzZSB7XG4gICAgdGVzdFN0ZXBSZXN1bHQuc3RhdHVzID0gU3RhdHVzLlBBU1NFRFxuICB9XG5cbiAgcmV0dXJuIHRlc3RTdGVwUmVzdWx0XG59XG5cbmV4cG9ydCBkZWZhdWx0IHsgcnVuIH1cbiJdfQ==

node_modules/cucumber/lib/status.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStatusMapping = getStatusMapping;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var statuses = {
+  AMBIGUOUS: 'ambiguous',
+  FAILED: 'failed',
+  PASSED: 'passed',
+  PENDING: 'pending',
+  SKIPPED: 'skipped',
+  UNDEFINED: 'undefined'
+};
+
+exports.default = statuses;
+function getStatusMapping(initialValue) {
+  return _lodash2.default.chain(statuses).map(function (status) {
+    return [status, initialValue];
+  }).fromPairs().value();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9zdGF0dXMuanMiXSwibmFtZXMiOlsiZ2V0U3RhdHVzTWFwcGluZyIsInN0YXR1c2VzIiwiQU1CSUdVT1VTIiwiRkFJTEVEIiwiUEFTU0VEIiwiUEVORElORyIsIlNLSVBQRUQiLCJVTkRFRklORUQiLCJpbml0aWFsVmFsdWUiLCJjaGFpbiIsIm1hcCIsInN0YXR1cyIsImZyb21QYWlycyIsInZhbHVlIl0sIm1hcHBpbmdzIjoiOzs7OztRQWFnQkEsZ0IsR0FBQUEsZ0I7O0FBYmhCOzs7Ozs7QUFFQSxJQUFNQyxXQUFXO0FBQ2ZDLGFBQVcsV0FESTtBQUVmQyxVQUFRLFFBRk87QUFHZkMsVUFBUSxRQUhPO0FBSWZDLFdBQVMsU0FKTTtBQUtmQyxXQUFTLFNBTE07QUFNZkMsYUFBVztBQU5JLENBQWpCOztrQkFTZU4sUTtBQUVSLFNBQVNELGdCQUFULENBQTBCUSxZQUExQixFQUF3QztBQUM3QyxTQUFPLGlCQUFFQyxLQUFGLENBQVFSLFFBQVIsRUFDSlMsR0FESSxDQUNBO0FBQUEsV0FBVSxDQUFDQyxNQUFELEVBQVNILFlBQVQsQ0FBVjtBQUFBLEdBREEsRUFFSkksU0FGSSxHQUdKQyxLQUhJLEVBQVA7QUFJRCIsImZpbGUiOiJzdGF0dXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgXyBmcm9tICdsb2Rhc2gnXG5cbmNvbnN0IHN0YXR1c2VzID0ge1xuICBBTUJJR1VPVVM6ICdhbWJpZ3VvdXMnLFxuICBGQUlMRUQ6ICdmYWlsZWQnLFxuICBQQVNTRUQ6ICdwYXNzZWQnLFxuICBQRU5ESU5HOiAncGVuZGluZycsXG4gIFNLSVBQRUQ6ICdza2lwcGVkJyxcbiAgVU5ERUZJTkVEOiAndW5kZWZpbmVkJyxcbn1cblxuZXhwb3J0IGRlZmF1bHQgc3RhdHVzZXNcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFN0YXR1c01hcHBpbmcoaW5pdGlhbFZhbHVlKSB7XG4gIHJldHVybiBfLmNoYWluKHN0YXR1c2VzKVxuICAgIC5tYXAoc3RhdHVzID0+IFtzdGF0dXMsIGluaXRpYWxWYWx1ZV0pXG4gICAgLmZyb21QYWlycygpXG4gICAgLnZhbHVlKClcbn1cbiJdfQ==

node_modules/cucumber/lib/step_arguments.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildStepArgumentIterator = buildStepArgumentIterator;
+
+var _util = require('util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function buildStepArgumentIterator(mapping) {
+  return function (arg) {
+    if (arg.hasOwnProperty('rows')) {
+      return mapping.dataTable(arg);
+    } else if (arg.hasOwnProperty('content')) {
+      return mapping.docString(arg);
+    }
+    throw new Error('Unknown argument type:' + _util2.default.inspect(arg));
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9zdGVwX2FyZ3VtZW50cy5qcyJdLCJuYW1lcyI6WyJidWlsZFN0ZXBBcmd1bWVudEl0ZXJhdG9yIiwibWFwcGluZyIsImFyZyIsImhhc093blByb3BlcnR5IiwiZGF0YVRhYmxlIiwiZG9jU3RyaW5nIiwiRXJyb3IiLCJpbnNwZWN0Il0sIm1hcHBpbmdzIjoiOzs7OztRQUVnQkEseUIsR0FBQUEseUI7O0FBRmhCOzs7Ozs7QUFFTyxTQUFTQSx5QkFBVCxDQUFtQ0MsT0FBbkMsRUFBNEM7QUFDakQsU0FBTyxVQUFTQyxHQUFULEVBQWM7QUFDbkIsUUFBSUEsSUFBSUMsY0FBSixDQUFtQixNQUFuQixDQUFKLEVBQWdDO0FBQzlCLGFBQU9GLFFBQVFHLFNBQVIsQ0FBa0JGLEdBQWxCLENBQVA7QUFDRCxLQUZELE1BRU8sSUFBSUEsSUFBSUMsY0FBSixDQUFtQixTQUFuQixDQUFKLEVBQW1DO0FBQ3hDLGFBQU9GLFFBQVFJLFNBQVIsQ0FBa0JILEdBQWxCLENBQVA7QUFDRDtBQUNELFVBQU0sSUFBSUksS0FBSiw0QkFBbUMsZUFBS0MsT0FBTCxDQUFhTCxHQUFiLENBQW5DLENBQU47QUFDRCxHQVBEO0FBUUQiLCJmaWxlIjoic3RlcF9hcmd1bWVudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdXRpbCBmcm9tICd1dGlsJ1xuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRTdGVwQXJndW1lbnRJdGVyYXRvcihtYXBwaW5nKSB7XG4gIHJldHVybiBmdW5jdGlvbihhcmcpIHtcbiAgICBpZiAoYXJnLmhhc093blByb3BlcnR5KCdyb3dzJykpIHtcbiAgICAgIHJldHVybiBtYXBwaW5nLmRhdGFUYWJsZShhcmcpXG4gICAgfSBlbHNlIGlmIChhcmcuaGFzT3duUHJvcGVydHkoJ2NvbnRlbnQnKSkge1xuICAgICAgcmV0dXJuIG1hcHBpbmcuZG9jU3RyaW5nKGFyZylcbiAgICB9XG4gICAgdGhyb3cgbmV3IEVycm9yKGBVbmtub3duIGFyZ3VtZW50IHR5cGU6JHt1dGlsLmluc3BlY3QoYXJnKX1gKVxuICB9XG59XG4iXX0=

node_modules/cucumber/lib/support_code_library_builder/finalize_helpers.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapDefinitions = wrapDefinitions;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilArity = require('util-arity');
+
+var _utilArity2 = _interopRequireDefault(_utilArity);
+
+var _isGenerator = require('is-generator');
+
+var _isGenerator2 = _interopRequireDefault(_isGenerator);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function wrapDefinitions(_ref) {
+  var cwd = _ref.cwd,
+      definitionFunctionWrapper = _ref.definitionFunctionWrapper,
+      definitions = _ref.definitions;
+
+  if (definitionFunctionWrapper) {
+    definitions.forEach(function (definition) {
+      var codeLength = definition.code.length;
+      var wrappedFn = definitionFunctionWrapper(definition.code, definition.options.wrapperOptions);
+      if (wrappedFn !== definition.code) {
+        definition.code = (0, _utilArity2.default)(codeLength, wrappedFn);
+      }
+    });
+  } else {
+    var generatorDefinitions = _lodash2.default.filter(definitions, function (definition) {
+      return _isGenerator2.default.fn(definition.code);
+    });
+    if (generatorDefinitions.length > 0) {
+      var references = generatorDefinitions.map(function (definition) {
+        return _path2.default.relative(cwd, definition.uri) + ':' + definition.line;
+      }).join('\n  ');
+      var message = '\n        The following hook/step definitions use generator functions:\n\n          ' + references + '\n\n        Use \'this.setDefinitionFunctionWrapper(fn)\' to wrap then in a function that returns a promise.\n        ';
+      throw new Error(message);
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

node_modules/cucumber/lib/support_code_library_builder/parameter_type_registry_builder.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _cucumberExpressions = require('cucumber-expressions');
+
+function build() {
+  return new _cucumberExpressions.ParameterTypeRegistry();
+}
+
+exports.default = { build: build };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdXBwb3J0X2NvZGVfbGlicmFyeV9idWlsZGVyL3BhcmFtZXRlcl90eXBlX3JlZ2lzdHJ5X2J1aWxkZXIuanMiXSwibmFtZXMiOlsiYnVpbGQiXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBOztBQUVBLFNBQVNBLEtBQVQsR0FBaUI7QUFDZixTQUFPLGdEQUFQO0FBQ0Q7O2tCQUVjLEVBQUVBLFlBQUYsRSIsImZpbGUiOiJwYXJhbWV0ZXJfdHlwZV9yZWdpc3RyeV9idWlsZGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFyYW1ldGVyVHlwZVJlZ2lzdHJ5IH0gZnJvbSAnY3VjdW1iZXItZXhwcmVzc2lvbnMnXG5cbmZ1bmN0aW9uIGJ1aWxkKCkge1xuICByZXR1cm4gbmV3IFBhcmFtZXRlclR5cGVSZWdpc3RyeSgpXG59XG5cbmV4cG9ydCBkZWZhdWx0IHsgYnVpbGQgfVxuIl19

node_modules/cucumber/lib/time.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var previousTimestamp = void 0;
+
+var methods = {
+  beginTiming: function beginTiming() {
+    previousTimestamp = getTimestamp();
+  },
+
+  clearInterval: clearInterval.bind(global),
+  clearTimeout: clearTimeout.bind(global),
+  Date: Date,
+  endTiming: function endTiming() {
+    return getTimestamp() - previousTimestamp;
+  },
+
+  setInterval: setInterval.bind(global),
+  setTimeout: setTimeout.bind(global)
+};
+
+if (typeof setImmediate !== 'undefined') {
+  methods.setImmediate = setImmediate.bind(global);
+  methods.clearImmediate = clearImmediate.bind(global);
+}
+
+function getTimestamp() {
+  return new methods.Date().getTime();
+}
+
+exports.default = methods;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90aW1lLmpzIl0sIm5hbWVzIjpbInByZXZpb3VzVGltZXN0YW1wIiwibWV0aG9kcyIsImJlZ2luVGltaW5nIiwiZ2V0VGltZXN0YW1wIiwiY2xlYXJJbnRlcnZhbCIsImJpbmQiLCJnbG9iYWwiLCJjbGVhclRpbWVvdXQiLCJEYXRlIiwiZW5kVGltaW5nIiwic2V0SW50ZXJ2YWwiLCJzZXRUaW1lb3V0Iiwic2V0SW1tZWRpYXRlIiwiY2xlYXJJbW1lZGlhdGUiLCJnZXRUaW1lIl0sIm1hcHBpbmdzIjoiOzs7OztBQUFBLElBQUlBLDBCQUFKOztBQUVBLElBQU1DLFVBQVU7QUFDZEMsYUFEYyx5QkFDQTtBQUNaRix3QkFBb0JHLGNBQXBCO0FBQ0QsR0FIYTs7QUFJZEMsaUJBQWVBLGNBQWNDLElBQWQsQ0FBbUJDLE1BQW5CLENBSkQ7QUFLZEMsZ0JBQWNBLGFBQWFGLElBQWIsQ0FBa0JDLE1BQWxCLENBTEE7QUFNZEUsWUFOYztBQU9kQyxXQVBjLHVCQU9GO0FBQ1YsV0FBT04saUJBQWlCSCxpQkFBeEI7QUFDRCxHQVRhOztBQVVkVSxlQUFhQSxZQUFZTCxJQUFaLENBQWlCQyxNQUFqQixDQVZDO0FBV2RLLGNBQVlBLFdBQVdOLElBQVgsQ0FBZ0JDLE1BQWhCO0FBWEUsQ0FBaEI7O0FBY0EsSUFBSSxPQUFPTSxZQUFQLEtBQXdCLFdBQTVCLEVBQXlDO0FBQ3ZDWCxVQUFRVyxZQUFSLEdBQXVCQSxhQUFhUCxJQUFiLENBQWtCQyxNQUFsQixDQUF2QjtBQUNBTCxVQUFRWSxjQUFSLEdBQXlCQSxlQUFlUixJQUFmLENBQW9CQyxNQUFwQixDQUF6QjtBQUNEOztBQUVELFNBQVNILFlBQVQsR0FBd0I7QUFDdEIsU0FBTyxJQUFJRixRQUFRTyxJQUFaLEdBQW1CTSxPQUFuQixFQUFQO0FBQ0Q7O2tCQUVjYixPIiwiZmlsZSI6InRpbWUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJsZXQgcHJldmlvdXNUaW1lc3RhbXBcblxuY29uc3QgbWV0aG9kcyA9IHtcbiAgYmVnaW5UaW1pbmcoKSB7XG4gICAgcHJldmlvdXNUaW1lc3RhbXAgPSBnZXRUaW1lc3RhbXAoKVxuICB9LFxuICBjbGVhckludGVydmFsOiBjbGVhckludGVydmFsLmJpbmQoZ2xvYmFsKSxcbiAgY2xlYXJUaW1lb3V0OiBjbGVhclRpbWVvdXQuYmluZChnbG9iYWwpLFxuICBEYXRlLFxuICBlbmRUaW1pbmcoKSB7XG4gICAgcmV0dXJuIGdldFRpbWVzdGFtcCgpIC0gcHJldmlvdXNUaW1lc3RhbXBcbiAgfSxcbiAgc2V0SW50ZXJ2YWw6IHNldEludGVydmFsLmJpbmQoZ2xvYmFsKSxcbiAgc2V0VGltZW91dDogc2V0VGltZW91dC5iaW5kKGdsb2JhbCksXG59XG5cbmlmICh0eXBlb2Ygc2V0SW1tZWRpYXRlICE9PSAndW5kZWZpbmVkJykge1xuICBtZXRob2RzLnNldEltbWVkaWF0ZSA9IHNldEltbWVkaWF0ZS5iaW5kKGdsb2JhbClcbiAgbWV0aG9kcy5jbGVhckltbWVkaWF0ZSA9IGNsZWFySW1tZWRpYXRlLmJpbmQoZ2xvYmFsKVxufVxuXG5mdW5jdGlvbiBnZXRUaW1lc3RhbXAoKSB7XG4gIHJldHVybiBuZXcgbWV0aG9kcy5EYXRlKCkuZ2V0VGltZSgpXG59XG5cbmV4cG9ydCBkZWZhdWx0IG1ldGhvZHNcbiJdfQ==

node_modules/cucumber/lib/uncaught_exception_manager.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var UncaughtExceptionManager = function () {
+  function UncaughtExceptionManager() {
+    (0, _classCallCheck3.default)(this, UncaughtExceptionManager);
+  }
+
+  (0, _createClass3.default)(UncaughtExceptionManager, null, [{
+    key: 'registerHandler',
+    value: function registerHandler(handler) {
+      if (typeof window === 'undefined') {
+        process.addListener('uncaughtException', handler);
+      } else {
+        window.onerror = handler;
+      }
+    }
+  }, {
+    key: 'unregisterHandler',
+    value: function unregisterHandler(handler) {
+      if (typeof window === 'undefined') {
+        process.removeListener('uncaughtException', handler);
+      } else {
+        window.onerror = void 0;
+      }
+    }
+  }]);
+  return UncaughtExceptionManager;
+}();
+
+exports.default = UncaughtExceptionManager;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy91bmNhdWdodF9leGNlcHRpb25fbWFuYWdlci5qcyJdLCJuYW1lcyI6WyJVbmNhdWdodEV4Y2VwdGlvbk1hbmFnZXIiLCJoYW5kbGVyIiwid2luZG93IiwicHJvY2VzcyIsImFkZExpc3RlbmVyIiwib25lcnJvciIsInJlbW92ZUxpc3RlbmVyIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0lBQXFCQSx3Qjs7Ozs7OztvQ0FDSUMsTyxFQUFTO0FBQzlCLFVBQUksT0FBT0MsTUFBUCxLQUFrQixXQUF0QixFQUFtQztBQUNqQ0MsZ0JBQVFDLFdBQVIsQ0FBb0IsbUJBQXBCLEVBQXlDSCxPQUF6QztBQUNELE9BRkQsTUFFTztBQUNMQyxlQUFPRyxPQUFQLEdBQWlCSixPQUFqQjtBQUNEO0FBQ0Y7OztzQ0FFd0JBLE8sRUFBUztBQUNoQyxVQUFJLE9BQU9DLE1BQVAsS0FBa0IsV0FBdEIsRUFBbUM7QUFDakNDLGdCQUFRRyxjQUFSLENBQXVCLG1CQUF2QixFQUE0Q0wsT0FBNUM7QUFDRCxPQUZELE1BRU87QUFDTEMsZUFBT0csT0FBUCxHQUFpQixLQUFLLENBQXRCO0FBQ0Q7QUFDRjs7Ozs7a0JBZmtCTCx3QiIsImZpbGUiOiJ1bmNhdWdodF9leGNlcHRpb25fbWFuYWdlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGNsYXNzIFVuY2F1Z2h0RXhjZXB0aW9uTWFuYWdlciB7XG4gIHN0YXRpYyByZWdpc3RlckhhbmRsZXIoaGFuZGxlcikge1xuICAgIGlmICh0eXBlb2Ygd2luZG93ID09PSAndW5kZWZpbmVkJykge1xuICAgICAgcHJvY2Vzcy5hZGRMaXN0ZW5lcigndW5jYXVnaHRFeGNlcHRpb24nLCBoYW5kbGVyKVxuICAgIH0gZWxzZSB7XG4gICAgICB3aW5kb3cub25lcnJvciA9IGhhbmRsZXJcbiAgICB9XG4gIH1cblxuICBzdGF0aWMgdW5yZWdpc3RlckhhbmRsZXIoaGFuZGxlcikge1xuICAgIGlmICh0eXBlb2Ygd2luZG93ID09PSAndW5kZWZpbmVkJykge1xuICAgICAgcHJvY2Vzcy5yZW1vdmVMaXN0ZW5lcigndW5jYXVnaHRFeGNlcHRpb24nLCBoYW5kbGVyKVxuICAgIH0gZWxzZSB7XG4gICAgICB3aW5kb3cub25lcnJvciA9IHZvaWQgMFxuICAgIH1cbiAgfVxufVxuIl19

node_modules/cucumber/node_modules/commander/CHANGELOG.md

@@ -0,0 +1,419 @@
+2.20.3 / 2019-10-11
+==================
+
+  * Support Node.js 0.10 (Revert #1059)
+  * Ran "npm unpublish commander@2.20.2". There is no 2.20.2.
+
+2.20.1 / 2019-09-29
+==================
+
+  * Improve executable subcommand tracking
+  * Update dev dependencies
+
+2.20.0 / 2019-04-02
+==================
+
+  * fix: resolve symbolic links completely when hunting for subcommands (#935)
+  * Update index.d.ts (#930)
+  * Update Readme.md (#924)
+  * Remove --save option as it isn't required anymore (#918)
+  * Add link to the license file (#900)
+  * Added example of receiving args from options (#858)
+  * Added missing semicolon (#882)
+  * Add extension to .eslintrc (#876)
+
+2.19.0 / 2018-10-02
+==================
+
+  * Removed newline after Options and Commands headers (#864)
+  * Bugfix - Error output (#862)
+  * Fix to change default value to string (#856)
+
+2.18.0 / 2018-09-07
+==================
+
+  * Standardize help output (#853)
+  * chmod 644 travis.yml (#851)
+  * add support for execute typescript subcommand via ts-node (#849)
+
+2.17.1 / 2018-08-07
+==================
+
+  * Fix bug in command emit (#844)
+
+2.17.0 / 2018-08-03
+==================
+
+  * fixed newline output after help information (#833)
+  * Fix to emit the action even without command (#778)
+  * npm update (#823)
+
+2.16.0 / 2018-06-29
+==================
+
+  * Remove Makefile and `test/run` (#821)
+  * Make 'npm test' run on Windows (#820)
+  * Add badge to display install size (#807)
+  * chore: cache node_modules (#814)
+  * chore: remove Node.js 4 (EOL), add Node.js 10 (#813)
+  * fixed typo in readme (#812)
+  * Fix types (#804)
+  * Update eslint to resolve vulnerabilities in lodash (#799)
+  * updated readme with custom event listeners. (#791)
+  * fix tests (#794)
+
+2.15.0 / 2018-03-07
+==================
+
+  * Update downloads badge to point to graph of downloads over time instead of duplicating link to npm
+  * Arguments description
+
+2.14.1 / 2018-02-07
+==================
+
+  * Fix typing of help function
+
+2.14.0 / 2018-02-05
+==================
+
+  * only register the option:version event once
+  * Fixes issue #727: Passing empty string for option on command is set to undefined
+  * enable eqeqeq rule
+  * resolves #754 add linter configuration to project
+  * resolves #560 respect custom name for version option
+  * document how to override the version flag
+  * document using options per command
+
+2.13.0 / 2018-01-09
+==================
+
+  * Do not print default for --no-
+  * remove trailing spaces in command help
+  * Update CI's Node.js to LTS and latest version
+  * typedefs: Command and Option types added to commander namespace
+
+2.12.2 / 2017-11-28
+==================
+
+  * fix: typings are not shipped
+
+2.12.1 / 2017-11-23
+==================
+
+  * Move @types/node to dev dependency
+
+2.12.0 / 2017-11-22
+==================
+
+  * add attributeName() method to Option objects
+  * Documentation updated for options with --no prefix
+  * typings: `outputHelp` takes a string as the first parameter
+  * typings: use overloads
+  * feat(typings): update to match js api
+  * Print default value in option help
+  * Fix translation error
+  * Fail when using same command and alias (#491)
+  * feat(typings): add help callback
+  * fix bug when description is add after command with options (#662)
+  * Format js code
+  * Rename History.md to CHANGELOG.md (#668)
+  * feat(typings): add typings to support TypeScript (#646)
+  * use current node
+
+2.11.0 / 2017-07-03
+==================
+
+  * Fix help section order and padding (#652)
+  * feature: support for signals to subcommands (#632)
+  * Fixed #37, --help should not display first (#447)
+  * Fix translation errors. (#570)
+  * Add package-lock.json
+  * Remove engines
+  * Upgrade package version
+  * Prefix events to prevent conflicts between commands and options (#494)
+  * Removing dependency on graceful-readlink
+  * Support setting name in #name function and make it chainable
+  * Add .vscode directory to .gitignore (Visual Studio Code metadata)
+  * Updated link to ruby commander in readme files
+
+2.10.0 / 2017-06-19
+==================
+
+  * Update .travis.yml. drop support for older node.js versions.
+  * Fix require arguments in README.md
+  * On SemVer you do not start from 0.0.1
+  * Add missing semi colon in readme
+  * Add save param to npm install
+  * node v6 travis test
+  * Update Readme_zh-CN.md
+  * Allow literal '--' to be passed-through as an argument
+  * Test subcommand alias help
+  * link build badge to master branch
+  * Support the alias of Git style sub-command
+  * added keyword commander for better search result on npm
+  * Fix Sub-Subcommands
+  * test node.js stable
+  * Fixes TypeError when a command has an option called `--description`
+  * Update README.md to make it beginner friendly and elaborate on the difference between angled and square brackets.
+  * Add chinese Readme file
+
+2.9.0 / 2015-10-13
+==================
+
+  * Add option `isDefault` to set default subcommand #415 @Qix-
+  * Add callback to allow filtering or post-processing of help text #434 @djulien
+  * Fix `undefined` text in help information close #414 #416 @zhiyelee
+
+2.8.1 / 2015-04-22
+==================
+
+ * Back out `support multiline description` Close #396 #397
+
+2.8.0 / 2015-04-07
+==================
+
+  * Add `process.execArg` support, execution args like `--harmony` will be passed to sub-commands #387 @DigitalIO @zhiyelee
+  * Fix bug in Git-style sub-commands #372 @zhiyelee
+  * Allow commands to be hidden from help #383 @tonylukasavage
+  * When git-style sub-commands are in use, yet none are called, display help #382 @claylo
+  * Add ability to specify arguments syntax for top-level command #258 @rrthomas
+  * Support multiline descriptions #208 @zxqfox
+
+2.7.1 / 2015-03-11
+==================
+
+ * Revert #347 (fix collisions when option and first arg have same name) which causes a bug in #367.
+
+2.7.0 / 2015-03-09
+==================
+
+ * Fix git-style bug when installed globally. Close #335 #349 @zhiyelee
+ * Fix collisions when option and first arg have same name. Close #346 #347 @tonylukasavage
+ * Add support for camelCase on `opts()`. Close #353  @nkzawa
+ * Add node.js 0.12 and io.js to travis.yml
+ * Allow RegEx options. #337 @palanik
+ * Fixes exit code when sub-command failing.  Close #260 #332 @pirelenito
+ * git-style `bin` files in $PATH make sense. Close #196 #327  @zhiyelee
+
+2.6.0 / 2014-12-30
+==================
+
+  * added `Command#allowUnknownOption` method. Close #138 #318 @doozr @zhiyelee
+  * Add application description to the help msg. Close #112 @dalssoft
+
+2.5.1 / 2014-12-15
+==================
+
+  * fixed two bugs incurred by variadic arguments. Close #291 @Quentin01 #302 @zhiyelee
+
+2.5.0 / 2014-10-24
+==================
+
+ * add support for variadic arguments. Closes #277 @whitlockjc
+
+2.4.0 / 2014-10-17
+==================
+
+ * fixed a bug on executing the coercion function of subcommands option. Closes #270
+ * added `Command.prototype.name` to retrieve command name. Closes #264 #266 @tonylukasavage
+ * added `Command.prototype.opts` to retrieve all the options as a simple object of key-value pairs. Closes #262 @tonylukasavage
+ * fixed a bug on subcommand name. Closes #248 @jonathandelgado
+ * fixed function normalize doesn’t honor option terminator. Closes #216 @abbr
+
+2.3.0 / 2014-07-16
+==================
+
+ * add command alias'. Closes PR #210
+ * fix: Typos. Closes #99
+ * fix: Unused fs module. Closes #217
+
+2.2.0 / 2014-03-29
+==================
+
+ * add passing of previous option value
+ * fix: support subcommands on windows. Closes #142
+ * Now the defaultValue passed as the second argument of the coercion function.
+
+2.1.0 / 2013-11-21
+==================
+
+ * add: allow cflag style option params, unit test, fixes #174
+
+2.0.0 / 2013-07-18
+==================
+
+ * remove input methods (.prompt, .confirm, etc)
+
+1.3.2 / 2013-07-18
+==================
+
+ * add support for sub-commands to co-exist with the original command
+
+1.3.1 / 2013-07-18
+==================
+
+ * add quick .runningCommand hack so you can opt-out of other logic when running a sub command
+
+1.3.0 / 2013-07-09
+==================
+
+ * add EACCES error handling
+ * fix sub-command --help
+
+1.2.0 / 2013-06-13
+==================
+
+ * allow "-" hyphen as an option argument
+ * support for RegExp coercion
+
+1.1.1 / 2012-11-20
+==================
+
+  * add more sub-command padding
+  * fix .usage() when args are present. Closes #106
+
+1.1.0 / 2012-11-16
+==================
+
+  * add git-style executable subcommand support. Closes #94
+
+1.0.5 / 2012-10-09
+==================
+
+  * fix `--name` clobbering. Closes #92
+  * fix examples/help. Closes #89
+
+1.0.4 / 2012-09-03
+==================
+
+  * add `outputHelp()` method.
+
+1.0.3 / 2012-08-30
+==================
+
+  * remove invalid .version() defaulting
+
+1.0.2 / 2012-08-24
+==================
+
+  * add `--foo=bar` support [arv]
+  * fix password on node 0.8.8. Make backward compatible with 0.6 [focusaurus]
+
+1.0.1 / 2012-08-03
+==================
+
+  * fix issue #56
+  * fix tty.setRawMode(mode) was moved to tty.ReadStream#setRawMode() (i.e. process.stdin.setRawMode())
+
+1.0.0 / 2012-07-05
+==================
+
+  * add support for optional option descriptions
+  * add defaulting of `.version()` to package.json's version
+
+0.6.1 / 2012-06-01
+==================
+
+  * Added: append (yes or no) on confirmation
+  * Added: allow node.js v0.7.x
+
+0.6.0 / 2012-04-10
+==================
+
+  * Added `.prompt(obj, callback)` support. Closes #49
+  * Added default support to .choose(). Closes #41
+  * Fixed the choice example
+
+0.5.1 / 2011-12-20
+==================
+
+  * Fixed `password()` for recent nodes. Closes #36
+
+0.5.0 / 2011-12-04
+==================
+
+  * Added sub-command option support [itay]
+
+0.4.3 / 2011-12-04
+==================
+
+  * Fixed custom help ordering. Closes #32
+
+0.4.2 / 2011-11-24
+==================
+
+  * Added travis support
+  * Fixed: line-buffered input automatically trimmed. Closes #31
+
+0.4.1 / 2011-11-18
+==================
+
+  * Removed listening for "close" on --help
+
+0.4.0 / 2011-11-15
+==================
+
+  * Added support for `--`. Closes #24
+
+0.3.3 / 2011-11-14
+==================
+
+  * Fixed: wait for close event when writing help info [Jerry Hamlet]
+
+0.3.2 / 2011-11-01
+==================
+
+  * Fixed long flag definitions with values [felixge]
+
+0.3.1 / 2011-10-31
+==================
+
+  * Changed `--version` short flag to `-V` from `-v`
+  * Changed `.version()` so it's configurable [felixge]
+
+0.3.0 / 2011-10-31
+==================
+
+  * Added support for long flags only. Closes #18
+
+0.2.1 / 2011-10-24
+==================
+
+  * "node": ">= 0.4.x < 0.7.0". Closes #20
+
+0.2.0 / 2011-09-26
+==================
+
+  * Allow for defaults that are not just boolean. Default peassignment only occurs for --no-*, optional, and required arguments. [Jim Isaacs]
+
+0.1.0 / 2011-08-24
+==================
+
+  * Added support for custom `--help` output
+
+0.0.5 / 2011-08-18
+==================
+
+  * Changed: when the user enters nothing prompt for password again
+  * Fixed issue with passwords beginning with numbers [NuckChorris]
+
+0.0.4 / 2011-08-15
+==================
+
+  * Fixed `Commander#args`
+
+0.0.3 / 2011-08-15
+==================
+
+  * Added default option value support
+
+0.0.2 / 2011-08-15
+==================
+
+  * Added mask support to `Command#password(str[, mask], fn)`
+  * Added `Command#password(str, fn)`
+
+0.0.1 / 2010-01-03
+==================
+
+  * Initial release

node_modules/cucumber/node_modules/commander/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/cucumber/node_modules/commander/Readme.md

@@ -0,0 +1,428 @@
+# Commander.js
+
+
+[![Build Status](https://api.travis-ci.org/tj/commander.js.svg?branch=master)](http://travis-ci.org/tj/commander.js)
+[![NPM Version](http://img.shields.io/npm/v/commander.svg?style=flat)](https://www.npmjs.org/package/commander)
+[![NPM Downloads](https://img.shields.io/npm/dm/commander.svg?style=flat)](https://npmcharts.com/compare/commander?minimal=true)
+[![Install Size](https://packagephobia.now.sh/badge?p=commander)](https://packagephobia.now.sh/result?p=commander)
+[![Join the chat at https://gitter.im/tj/commander.js](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/tj/commander.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+  The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/commander-rb/commander).  
+  [API documentation](http://tj.github.com/commander.js/)
+
+
+## Installation
+
+    $ npm install commander
+
+## Option parsing
+
+Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .option('-p, --peppers', 'Add peppers')
+  .option('-P, --pineapple', 'Add pineapple')
+  .option('-b, --bbq-sauce', 'Add bbq sauce')
+  .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble')
+  .parse(process.argv);
+
+console.log('you ordered a pizza with:');
+if (program.peppers) console.log('  - peppers');
+if (program.pineapple) console.log('  - pineapple');
+if (program.bbqSauce) console.log('  - bbq');
+console.log('  - %s cheese', program.cheese);
+```
+
+Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as "--template-engine" are camel-cased, becoming `program.templateEngine` etc.
+
+Note that multi-word options starting with `--no` prefix negate the boolean value of the following word. For example, `--no-sauce` sets the value of `program.sauce` to false.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+  .option('--no-sauce', 'Remove sauce')
+  .parse(process.argv);
+
+console.log('you ordered a pizza');
+if (program.sauce) console.log('  with sauce');
+else console.log(' without sauce');
+```
+
+To get string arguments from options you will need to use angle brackets <> for required inputs or square brackets [] for optional inputs. 
+
+e.g. ```.option('-m --myarg [myVar]', 'my super cool description')```
+
+Then to access the input if it was passed in.
+
+e.g. ```var myInput = program.myarg```
+
+**NOTE**: If you pass a argument without using brackets the example above will return true and not the value passed in.
+
+
+## Version option
+
+Calling the `version` implicitly adds the `-V` and `--version` options to the command.
+When either of these options is present, the command prints the version number and exits.
+
+    $ ./examples/pizza -V
+    0.0.1
+
+If you want your program to respond to the `-v` option instead of the `-V` option, simply pass custom flags to the `version` method using the same syntax as the `option` method.
+
+```js
+program
+  .version('0.0.1', '-v, --version')
+```
+
+The version flags can be named anything, but the long option is required.
+
+## Command-specific options
+
+You can attach options to a command.
+
+```js
+#!/usr/bin/env node
+
+var program = require('commander');
+
+program
+  .command('rm <dir>')
+  .option('-r, --recursive', 'Remove recursively')
+  .action(function (dir, cmd) {
+    console.log('remove ' + dir + (cmd.recursive ? ' recursively' : ''))
+  })
+
+program.parse(process.argv)
+```
+
+A command's options are validated when the command is used. Any unknown options will be reported as an error. However, if an action-based command does not define an action, then the options are not validated.
+
+## Coercion
+
+```js
+function range(val) {
+  return val.split('..').map(Number);
+}
+
+function list(val) {
+  return val.split(',');
+}
+
+function collect(val, memo) {
+  memo.push(val);
+  return memo;
+}
+
+function increaseVerbosity(v, total) {
+  return total + 1;
+}
+
+program
+  .version('0.1.0')
+  .usage('[options] <file ...>')
+  .option('-i, --integer <n>', 'An integer argument', parseInt)
+  .option('-f, --float <n>', 'A float argument', parseFloat)
+  .option('-r, --range <a>..<b>', 'A range', range)
+  .option('-l, --list <items>', 'A list', list)
+  .option('-o, --optional [value]', 'An optional value')
+  .option('-c, --collect [value]', 'A repeatable value', collect, [])
+  .option('-v, --verbose', 'A value that can be increased', increaseVerbosity, 0)
+  .parse(process.argv);
+
+console.log(' int: %j', program.integer);
+console.log(' float: %j', program.float);
+console.log(' optional: %j', program.optional);
+program.range = program.range || [];
+console.log(' range: %j..%j', program.range[0], program.range[1]);
+console.log(' list: %j', program.list);
+console.log(' collect: %j', program.collect);
+console.log(' verbosity: %j', program.verbose);
+console.log(' args: %j', program.args);
+```
+
+## Regular Expression
+```js
+program
+  .version('0.1.0')
+  .option('-s --size <size>', 'Pizza size', /^(large|medium|small)$/i, 'medium')
+  .option('-d --drink [drink]', 'Drink', /^(coke|pepsi|izze)$/i)
+  .parse(process.argv);
+
+console.log(' size: %j', program.size);
+console.log(' drink: %j', program.drink);
+```
+
+## Variadic arguments
+
+ The last argument of a command can be variadic, and only the last argument.  To make an argument variadic you have to
+ append `...` to the argument name.  Here is an example:
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .command('rmdir <dir> [otherDirs...]')
+  .action(function (dir, otherDirs) {
+    console.log('rmdir %s', dir);
+    if (otherDirs) {
+      otherDirs.forEach(function (oDir) {
+        console.log('rmdir %s', oDir);
+      });
+    }
+  });
+
+program.parse(process.argv);
+```
+
+ An `Array` is used for the value of a variadic argument.  This applies to `program.args` as well as the argument passed
+ to your action as demonstrated above.
+
+## Specify the argument syntax
+
+```js
+#!/usr/bin/env node
+
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .arguments('<cmd> [env]')
+  .action(function (cmd, env) {
+     cmdValue = cmd;
+     envValue = env;
+  });
+
+program.parse(process.argv);
+
+if (typeof cmdValue === 'undefined') {
+   console.error('no command given!');
+   process.exit(1);
+}
+console.log('command:', cmdValue);
+console.log('environment:', envValue || "no environment given");
+```
+Angled brackets (e.g. `<cmd>`) indicate required input. Square brackets (e.g. `[env]`) indicate optional input.
+
+## Git-style sub-commands
+
+```js
+// file: ./examples/pm
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .command('install [name]', 'install one or more packages')
+  .command('search [query]', 'search with optional query')
+  .command('list', 'list packages installed', {isDefault: true})
+  .parse(process.argv);
+```
+
+When `.command()` is invoked with a description argument, no `.action(callback)` should be called to handle sub-commands, otherwise there will be an error. This tells commander that you're going to use separate executables for sub-commands, much like `git(1)` and other popular tools.  
+The commander will try to search the executables in the directory of the entry script (like `./examples/pm`) with the name `program-command`, like `pm-install`, `pm-search`.
+
+Options can be passed with the call to `.command()`. Specifying `true` for `opts.noHelp` will remove the subcommand from the generated help output. Specifying `true` for `opts.isDefault` will run the subcommand if no other subcommand is specified.
+
+If the program is designed to be installed globally, make sure the executables have proper modes, like `755`.
+
+### `--harmony`
+
+You can enable `--harmony` option in two ways:
+* Use `#! /usr/bin/env node --harmony` in the sub-commands scripts. Note some os version don’t support this pattern.
+* Use the `--harmony` option when call the command, like `node --harmony examples/pm publish`. The `--harmony` option will be preserved when spawning sub-command process.
+
+## Automated --help
+
+ The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free:
+
+```  
+$ ./examples/pizza --help
+Usage: pizza [options]
+
+An application for pizzas ordering
+
+Options:
+  -h, --help           output usage information
+  -V, --version        output the version number
+  -p, --peppers        Add peppers
+  -P, --pineapple      Add pineapple
+  -b, --bbq            Add bbq sauce
+  -c, --cheese <type>  Add the specified type of cheese [marble]
+  -C, --no-cheese      You do not want any cheese
+```
+
+## Custom help
+
+ You can display arbitrary `-h, --help` information
+ by listening for "--help". Commander will automatically
+ exit once you are done so that the remainder of your program
+ does not execute causing undesired behaviors, for example
+ in the following executable "stuff" will not output when
+ `--help` is used.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .option('-f, --foo', 'enable some foo')
+  .option('-b, --bar', 'enable some bar')
+  .option('-B, --baz', 'enable some baz');
+
+// must be before .parse() since
+// node's emit() is immediate
+
+program.on('--help', function(){
+  console.log('')
+  console.log('Examples:');
+  console.log('  $ custom-help --help');
+  console.log('  $ custom-help -h');
+});
+
+program.parse(process.argv);
+
+console.log('stuff');
+```
+
+Yields the following help output when `node script-name.js -h` or `node script-name.js --help` are run:
+
+```
+Usage: custom-help [options]
+
+Options:
+  -h, --help     output usage information
+  -V, --version  output the version number
+  -f, --foo      enable some foo
+  -b, --bar      enable some bar
+  -B, --baz      enable some baz
+
+Examples:
+  $ custom-help --help
+  $ custom-help -h
+```
+
+## .outputHelp(cb)
+
+Output help information without exiting.
+Optional callback cb allows post-processing of help text before it is displayed.
+
+If you want to display help by default (e.g. if no command was provided), you can use something like:
+
+```js
+var program = require('commander');
+var colors = require('colors');
+
+program
+  .version('0.1.0')
+  .command('getstream [url]', 'get stream URL')
+  .parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp(make_red);
+}
+
+function make_red(txt) {
+  return colors.red(txt); //display the help text in red on the console
+}
+```
+
+## .help(cb)
+
+  Output help information and exit immediately.
+  Optional callback cb allows post-processing of help text before it is displayed.
+
+
+## Custom event listeners
+ You can execute custom actions by listening to command and option events.
+
+```js
+program.on('option:verbose', function () {
+  process.env.VERBOSE = this.verbose;
+});
+
+// error on unknown commands
+program.on('command:*', function () {
+  console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
+  process.exit(1);
+});
+```
+
+## Examples
+
+```js
+var program = require('commander');
+
+program
+  .version('0.1.0')
+  .option('-C, --chdir <path>', 'change the working directory')
+  .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
+  .option('-T, --no-tests', 'ignore test hook');
+
+program
+  .command('setup [env]')
+  .description('run setup commands for all envs')
+  .option("-s, --setup_mode [mode]", "Which setup mode to use")
+  .action(function(env, options){
+    var mode = options.setup_mode || "normal";
+    env = env || 'all';
+    console.log('setup for %s env(s) with %s mode', env, mode);
+  });
+
+program
+  .command('exec <cmd>')
+  .alias('ex')
+  .description('execute the given remote cmd')
+  .option("-e, --exec_mode <mode>", "Which exec mode to use")
+  .action(function(cmd, options){
+    console.log('exec "%s" using %s mode', cmd, options.exec_mode);
+  }).on('--help', function() {
+    console.log('');
+    console.log('Examples:');
+    console.log('');
+    console.log('  $ deploy exec sequential');
+    console.log('  $ deploy exec async');
+  });
+
+program
+  .command('*')
+  .action(function(env){
+    console.log('deploying "%s"', env);
+  });
+
+program.parse(process.argv);
+```
+
+More Demos can be found in the [examples](https://github.com/tj/commander.js/tree/master/examples) directory.
+
+## License
+
+[MIT](https://github.com/tj/commander.js/blob/master/LICENSE)

node_modules/cucumber/node_modules/commander/package.json

@@ -0,0 +1,70 @@
+{
+  "_from": "commander@^2.9.0",
+  "_id": "commander@2.20.3",
+  "_inBundle": false,
+  "_integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+  "_location": "/cucumber/commander",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "commander@^2.9.0",
+    "name": "commander",
+    "escapedName": "commander",
+    "rawSpec": "^2.9.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.9.0"
+  },
+  "_requiredBy": [
+    "/cucumber"
+  ],
+  "_resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+  "_shasum": "fd485e84c03eb4881c20722ba48035e8531aeb33",
+  "_spec": "commander@^2.9.0",
+  "_where": "/home/simon/Documents/lifen-autotest/node_modules/cucumber",
+  "author": {
+    "name": "TJ Holowaychuk",
+    "email": "tj@vision-media.ca"
+  },
+  "bugs": {
+    "url": "https://github.com/tj/commander.js/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "the complete solution for node.js command-line programs",
+  "devDependencies": {
+    "@types/node": "^12.7.8",
+    "eslint": "^6.4.0",
+    "should": "^13.2.3",
+    "sinon": "^7.5.0",
+    "standard": "^14.3.1",
+    "ts-node": "^8.4.1",
+    "typescript": "^3.6.3"
+  },
+  "files": [
+    "index.js",
+    "typings/index.d.ts"
+  ],
+  "homepage": "https://github.com/tj/commander.js#readme",
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser"
+  ],
+  "license": "MIT",
+  "main": "index",
+  "name": "commander",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "lint": "eslint index.js",
+    "test": "node test/run.js && npm run test-typings",
+    "test-typings": "tsc -p tsconfig.json"
+  },
+  "typings": "typings/index.d.ts",
+  "version": "2.20.3"
+}

node_modules/cucumber/node_modules/commander/typings/index.d.ts

@@ -0,0 +1,310 @@
+// Type definitions for commander 2.11
+// Project: https://github.com/visionmedia/commander.js
+// Definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace local {
+
+  class Option {
+    flags: string;
+    required: boolean;
+    optional: boolean;
+    bool: boolean;
+    short?: string;
+    long: string;
+    description: string;
+
+    /**
+     * Initialize a new `Option` with the given `flags` and `description`.
+     *
+     * @param {string} flags
+     * @param {string} [description]
+     */
+    constructor(flags: string, description?: string);
+  }
+
+  class Command extends NodeJS.EventEmitter {
+    [key: string]: any;
+
+    args: string[];
+
+    /**
+     * Initialize a new `Command`.
+     *
+     * @param {string} [name]
+     */
+    constructor(name?: string);
+
+    /**
+     * Set the program version to `str`.
+     *
+     * This method auto-registers the "-V, --version" flag
+     * which will print the version number when passed.
+     *
+     * @param {string} str
+     * @param {string} [flags]
+     * @returns {Command} for chaining
+     */
+    version(str: string, flags?: string): Command;
+
+    /**
+     * Add command `name`.
+     *
+     * The `.action()` callback is invoked when the
+     * command `name` is specified via __ARGV__,
+     * and the remaining arguments are applied to the
+     * function for access.
+     *
+     * When the `name` is "*" an un-matched command
+     * will be passed as the first arg, followed by
+     * the rest of __ARGV__ remaining.
+     *
+     * @example
+     *      program
+     *        .version('0.0.1')
+     *        .option('-C, --chdir <path>', 'change the working directory')
+     *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
+     *        .option('-T, --no-tests', 'ignore test hook')
+     *
+     *      program
+     *        .command('setup')
+     *        .description('run remote setup commands')
+     *        .action(function() {
+     *          console.log('setup');
+     *        });
+     *
+     *      program
+     *        .command('exec <cmd>')
+     *        .description('run the given remote command')
+     *        .action(function(cmd) {
+     *          console.log('exec "%s"', cmd);
+     *        });
+     *
+     *      program
+     *        .command('teardown <dir> [otherDirs...]')
+     *        .description('run teardown commands')
+     *        .action(function(dir, otherDirs) {
+     *          console.log('dir "%s"', dir);
+     *          if (otherDirs) {
+     *            otherDirs.forEach(function (oDir) {
+     *              console.log('dir "%s"', oDir);
+     *            });
+     *          }
+     *        });
+     *
+     *      program
+     *        .command('*')
+     *        .description('deploy the given env')
+     *        .action(function(env) {
+     *          console.log('deploying "%s"', env);
+     *        });
+     *
+     *      program.parse(process.argv);
+     *
+     * @param {string} name
+     * @param {string} [desc] for git-style sub-commands
+     * @param {CommandOptions} [opts] command options
+     * @returns {Command} the new command
+     */
+    command(name: string, desc?: string, opts?: commander.CommandOptions): Command;
+
+    /**
+     * Define argument syntax for the top-level command.
+     *
+     * @param {string} desc
+     * @returns {Command} for chaining
+     */
+    arguments(desc: string): Command;
+
+    /**
+     * Parse expected `args`.
+     *
+     * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+     *
+     * @param {string[]} args
+     * @returns {Command} for chaining
+     */
+    parseExpectedArgs(args: string[]): Command;
+
+    /**
+     * Register callback `fn` for the command.
+     *
+     * @example
+     *      program
+     *        .command('help')
+     *        .description('display verbose help')
+     *        .action(function() {
+     *           // output help here
+     *        });
+     *
+     * @param {(...args: any[]) => void} fn
+     * @returns {Command} for chaining
+     */
+    action(fn: (...args: any[]) => void): Command;
+
+    /**
+     * Define option with `flags`, `description` and optional
+     * coercion `fn`.
+     *
+     * The `flags` string should contain both the short and long flags,
+     * separated by comma, a pipe or space. The following are all valid
+     * all will output this way when `--help` is used.
+     *
+     *    "-p, --pepper"
+     *    "-p|--pepper"
+     *    "-p --pepper"
+     *
+     * @example
+     *     // simple boolean defaulting to false
+     *     program.option('-p, --pepper', 'add pepper');
+     *
+     *     --pepper
+     *     program.pepper
+     *     // => Boolean
+     *
+     *     // simple boolean defaulting to true
+     *     program.option('-C, --no-cheese', 'remove cheese');
+     *
+     *     program.cheese
+     *     // => true
+     *
+     *     --no-cheese
+     *     program.cheese
+     *     // => false
+     *
+     *     // required argument
+     *     program.option('-C, --chdir <path>', 'change the working directory');
+     *
+     *     --chdir /tmp
+     *     program.chdir
+     *     // => "/tmp"
+     *
+     *     // optional argument
+     *     program.option('-c, --cheese [type]', 'add cheese [marble]');
+     *
+     * @param {string} flags
+     * @param {string} [description]
+     * @param {((arg1: any, arg2: any) => void) | RegExp} [fn] function or default
+     * @param {*} [defaultValue]
+     * @returns {Command} for chaining
+     */
+    option(flags: string, description?: string, fn?: ((arg1: any, arg2: any) => void) | RegExp, defaultValue?: any): Command;
+    option(flags: string, description?: string, defaultValue?: any): Command;
+
+    /**
+     * Allow unknown options on the command line.
+     *
+     * @param {boolean} [arg] if `true` or omitted, no error will be thrown for unknown options.
+     * @returns {Command} for chaining
+     */
+    allowUnknownOption(arg?: boolean): Command;
+
+    /**
+     * Parse `argv`, settings options and invoking commands when defined.
+     *
+     * @param {string[]} argv
+     * @returns {Command} for chaining
+     */
+    parse(argv: string[]): Command;
+
+    /**
+     * Parse options from `argv` returning `argv` void of these options.
+     *
+     * @param {string[]} argv
+     * @returns {ParseOptionsResult}
+     */
+    parseOptions(argv: string[]): commander.ParseOptionsResult;
+
+    /**
+     * Return an object containing options as key-value pairs
+     *
+     * @returns {{[key: string]: any}}
+     */
+    opts(): { [key: string]: any };
+
+    /**
+     * Set the description to `str`.
+     *
+     * @param {string} str
+     * @param {{[argName: string]: string}} argsDescription
+     * @return {(Command | string)}
+     */
+    description(str: string, argsDescription?: {[argName: string]: string}): Command;
+    description(): string;
+
+    /**
+     * Set an alias for the command.
+     *
+     * @param {string} alias
+     * @return {(Command | string)}
+     */
+    alias(alias: string): Command;
+    alias(): string;
+
+    /**
+     * Set or get the command usage.
+     *
+     * @param {string} str
+     * @return {(Command | string)}
+     */
+    usage(str: string): Command;
+    usage(): string;
+
+    /**
+     * Set the name of the command.
+     *
+     * @param {string} str
+     * @return {Command}
+     */
+    name(str: string): Command;
+
+    /**
+     * Get the name of the command.
+     *
+     * @return {string}
+     */
+    name(): string;
+
+    /**
+     * Output help information for this command.
+     *
+     * @param {(str: string) => string} [cb]
+     */
+    outputHelp(cb?: (str: string) => string): void;
+
+    /** Output help information and exit.
+     *
+     * @param {(str: string) => string} [cb]
+     */
+    help(cb?: (str: string) => string): never;
+  }
+
+}
+
+declare namespace commander {
+
+    type Command = local.Command
+
+    type Option = local.Option
+
+    interface CommandOptions {
+        noHelp?: boolean;
+        isDefault?: boolean;
+    }
+
+    interface ParseOptionsResult {
+        args: string[];
+        unknown: string[];
+    }
+
+    interface CommanderStatic extends Command {
+        Command: typeof local.Command;
+        Option: typeof local.Option;
+        CommandOptions: CommandOptions;
+        ParseOptionsResult: ParseOptionsResult;
+    }
+
+}
+
+declare const commander: commander.CommanderStatic;
+export = commander;

node_modules/cucumber/node_modules/cucumber-expressions/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["env"]
+}

node_modules/cucumber/node_modules/cucumber-expressions/.eslintrc

@@ -0,0 +1,21 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 8
+  },
+  "plugins": [
+    "prettier"
+  ],
+  "rules": {
+    "prettier/prettier": [
+      "error", {"trailingComma": "es5", "singleQuote": true, "semi": false}
+    ]
+  },
+  "env": {
+    "node": true,
+    "es6": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "prettier"
+  ]
+}

node_modules/cucumber/node_modules/cucumber-expressions/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,5 @@
+PLEASE DO NOT CREATE ISSUES IN THIS REPO.
+THIS REPO IS A READ-ONLY MIRROR.
+
+Create your issue in the Cucumber monorepo instead:
+https://github.com/cucumber/cucumber/issues

node_modules/cucumber/node_modules/cucumber-expressions/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+PLEASE DO NOT CREATE PULL REAUESTS IN THIS REPO.
+THIS REPO IS A READ-ONLY MIRROR.
+
+Create your pull request in the Cucumber monorepo instead:
+https://github.com/cucumber/cucumber/pulls

node_modules/cucumber/node_modules/cucumber-expressions/.npmignore

@@ -0,0 +1,9 @@
+.idea/
+.nyc_output/
+coverage/
+dist/
+node_modules/
+yarn.lock
+npm-debug.log
+build/
+package-lock.json

node_modules/cucumber/node_modules/cucumber-expressions/.rsync

@@ -0,0 +1,5 @@
+../../LICENSE LICENSE
+../../.templates/github/ .github/
+../../.templates/javascript/.travis.yml .travis.yml
+../../scripts/prettier-all scripts/prettier-all
+../examples.txt examples.txt

node_modules/cucumber/node_modules/cucumber-expressions/.subrepo

@@ -0,0 +1 @@
+cucumber/cucumber-expressions-javascript.git

node_modules/cucumber/node_modules/cucumber-expressions/.travis.yml

@@ -0,0 +1,15 @@
+# Please update /.templates/javascript/.travis.yml in the cucumber/cucumber monorepo
+# and sync:
+#
+#     source scripts/functions.sh && rsync_files
+#
+sudo: false
+language: node_js
+node_js:
+  - "10"
+  - "9"
+  - "8"
+  - "6"
+  - "4"
+
+script: make default

node_modules/cucumber/node_modules/cucumber-expressions/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Cucumber Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/cucumber/node_modules/cucumber-expressions/Makefile

@@ -0,0 +1,26 @@
+ASYNC_SUPPORTED := $(shell node --eval "function async foo(){}" 2> /dev/null)
+ifdef ASYNC_SUPPORTED
+	TEST_TARGET=test
+else
+	TEST_TARGET=babel-test
+endif
+
+default: $(TEST_TARGET)
+.PHONY: default
+
+test: yarn.lock
+	yarn test
+.PHONY: test
+
+babel-test: yarn.lock
+	yarn build-test
+	yarn mocha-built
+.PHONY: test
+
+yarn.lock: package.json
+	yarn install --network-concurrency 1
+	yarn link
+
+clean:
+	rm -rf node_modules coverage dist
+.PHONY: clean

node_modules/cucumber/node_modules/cucumber-expressions/README.md

@@ -0,0 +1,5 @@
+# Cucumber Expressions for JavaScript
+
+[![Build Status](https://travis-ci.org/cucumber/cucumber-expressions-javascript.svg?branch=master)](https://travis-ci.org/cucumber/cucumber-expressions-javascript)
+
+[The docs are here](http://docs.cucumber.io/cucumber-expressions/).

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/argument.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _require = require('./errors'),
+    CucumberExpressionError = _require.CucumberExpressionError;
+
+var Argument = function () {
+  _createClass(Argument, null, [{
+    key: 'build',
+    value: function build(treeRegexp, text, parameterTypes) {
+      var group = treeRegexp.match(text);
+      if (!group) return null;
+
+      var argGroups = group.children;
+
+      if (argGroups.length !== parameterTypes.length) {
+        throw new CucumberExpressionError('Expression ' + treeRegexp.regexp + ' has ' + argGroups.length + ' capture groups (' + argGroups.map(function (g) {
+          return g.value;
+        }) + '), but there were ' + parameterTypes.length + ' parameter types (' + parameterTypes.map(function (p) {
+          return p.name;
+        }) + ')');
+      }
+
+      return parameterTypes.map(function (parameterType, i) {
+        return new Argument(argGroups[i], parameterType);
+      });
+    }
+  }]);
+
+  function Argument(group, parameterType) {
+    _classCallCheck(this, Argument);
+
+    this._group = group;
+    this._parameterType = parameterType;
+  }
+
+  _createClass(Argument, [{
+    key: 'getValue',
+
+
+    /**
+     * Get the value returned by the parameter type's transformer function.
+     *
+     * @param thisObj the object in which the transformer function is applied.
+     */
+    value: function getValue(thisObj) {
+      var groupValues = this._group ? this._group.values : null;
+      return this._parameterType.transform(thisObj, groupValues);
+    }
+  }, {
+    key: 'group',
+    get: function get() {
+      return this._group;
+    }
+  }]);
+
+  return Argument;
+}();
+
+module.exports = Argument;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/combinatorial_generated_expression_factory.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var GeneratedExpression = require('./generated_expression');
+
+var CombinatorialGeneratedExpressionFactory = function () {
+  function CombinatorialGeneratedExpressionFactory(expressionTemplate, parameterTypeCombinations) {
+    _classCallCheck(this, CombinatorialGeneratedExpressionFactory);
+
+    this._expressionTemplate = expressionTemplate;
+    this._parameterTypeCombinations = parameterTypeCombinations;
+  }
+
+  _createClass(CombinatorialGeneratedExpressionFactory, [{
+    key: 'generateExpressions',
+    value: function generateExpressions() {
+      var generatedExpressions = [];
+      this._generatePermutations(generatedExpressions, 0, []);
+      return generatedExpressions;
+    }
+  }, {
+    key: '_generatePermutations',
+    value: function _generatePermutations(generatedExpressions, depth, currentParameterTypes) {
+      if (depth === this._parameterTypeCombinations.length) {
+        generatedExpressions.push(new GeneratedExpression(this._expressionTemplate, currentParameterTypes));
+        return;
+      }
+
+      for (var i = 0; i < this._parameterTypeCombinations[depth].length; ++i) {
+        var newCurrentParameterTypes = currentParameterTypes.slice(); // clone
+        newCurrentParameterTypes.push(this._parameterTypeCombinations[depth][i]);
+        this._generatePermutations(generatedExpressions, depth + 1, newCurrentParameterTypes);
+      }
+    }
+  }]);
+
+  return CombinatorialGeneratedExpressionFactory;
+}();
+
+module.exports = CombinatorialGeneratedExpressionFactory;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/cucumber_expression.js

@@ -0,0 +1,111 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Argument = require('./argument');
+var TreeRegexp = require('./tree_regexp');
+
+var _require = require('./errors'),
+    UndefinedParameterTypeError = _require.UndefinedParameterTypeError;
+
+// Does not include (){} characters because they have special meaning
+
+
+var ESCAPE_REGEXP = /([\\^[$.|?*+])/g;
+var PARAMETER_REGEXP = /(\\\\)?{([^}]+)}/g;
+var OPTIONAL_REGEXP = /(\\\\)?\(([^)]+)\)/g;
+var ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP = /([^\s^/]+)((\/[^\s^/]+)+)/g;
+var DOUBLE_ESCAPE = '\\\\';
+
+var CucumberExpression = function () {
+  /**
+   * @param expression
+   * @param parameterTypeRegistry
+   */
+  function CucumberExpression(expression, parameterTypeRegistry) {
+    _classCallCheck(this, CucumberExpression);
+
+    this._expression = expression;
+    this._parameterTypes = [];
+
+    expression = this.processEscapes(expression);
+    expression = this.processOptional(expression);
+    expression = this.processAlternation(expression);
+    expression = this.processParameters(expression, parameterTypeRegistry);
+    expression = '^' + expression + '$';
+
+    this._treeRegexp = new TreeRegexp(expression);
+  }
+
+  _createClass(CucumberExpression, [{
+    key: 'processEscapes',
+    value: function processEscapes(expression) {
+      return expression.replace(ESCAPE_REGEXP, '\\$1');
+    }
+  }, {
+    key: 'processOptional',
+    value: function processOptional(expression) {
+      return expression.replace(OPTIONAL_REGEXP, function (match, p1, p2) {
+        return p1 === DOUBLE_ESCAPE ? '\\(' + p2 + '\\)' : '(?:' + p2 + ')?';
+      });
+    }
+  }, {
+    key: 'processAlternation',
+    value: function processAlternation(expression) {
+      return expression.replace(ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP, function (match) {
+        // replace \/ with /
+        // replace / with |
+        var replacement = match.replace(/\//g, '|').replace(/\\\|/g, '/');
+        return '(?:' + replacement + ')';
+      });
+    }
+  }, {
+    key: 'processParameters',
+    value: function processParameters(expression, parameterTypeRegistry) {
+      var _this = this;
+
+      return expression.replace(PARAMETER_REGEXP, function (match, p1, p2) {
+        if (p1 === DOUBLE_ESCAPE) return '\\{' + p2 + '\\}';
+
+        var typeName = p2;
+        var parameterType = parameterTypeRegistry.lookupByTypeName(typeName);
+        if (!parameterType) throw new UndefinedParameterTypeError(typeName);
+        _this._parameterTypes.push(parameterType);
+        return buildCaptureRegexp(parameterType.regexps);
+      });
+    }
+  }, {
+    key: 'match',
+    value: function match(text) {
+      return Argument.build(this._treeRegexp, text, this._parameterTypes);
+    }
+  }, {
+    key: 'regexp',
+    get: function get() {
+      return this._treeRegexp.regexp;
+    }
+  }, {
+    key: 'source',
+    get: function get() {
+      return this._expression;
+    }
+  }]);
+
+  return CucumberExpression;
+}();
+
+function buildCaptureRegexp(regexps) {
+  if (regexps.length === 1) {
+    return '(' + regexps[0] + ')';
+  }
+
+  var captureGroups = regexps.map(function (group) {
+    return '(?:' + group + ')';
+  });
+
+  return '(' + captureGroups.join('|') + ')';
+}
+
+module.exports = CucumberExpression;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/cucumber_expression_generator.js

@@ -0,0 +1,213 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var util = require('util');
+var ParameterTypeMatcher = require('./parameter_type_matcher');
+var ParameterType = require('./parameter_type');
+var CombinatorialGeneratedExpressionFactory = require('./combinatorial_generated_expression_factory');
+
+var CucumberExpressionGenerator = function () {
+  function CucumberExpressionGenerator(parameterTypeRegistry) {
+    _classCallCheck(this, CucumberExpressionGenerator);
+
+    this._parameterTypeRegistry = parameterTypeRegistry;
+  }
+
+  _createClass(CucumberExpressionGenerator, [{
+    key: 'generateExpressions',
+    value: function generateExpressions(text) {
+      var parameterTypeCombinations = [];
+      var parameterTypeMatchers = this._createParameterTypeMatchers(text);
+      var expressionTemplate = '';
+      var pos = 0;
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        var matchingParameterTypeMatchers = [];
+
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = parameterTypeMatchers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var parameterTypeMatcher = _step.value;
+
+            var advancedParameterTypeMatcher = parameterTypeMatcher.advanceTo(pos);
+            if (advancedParameterTypeMatcher.find) {
+              matchingParameterTypeMatchers.push(advancedParameterTypeMatcher);
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        if (matchingParameterTypeMatchers.length > 0) {
+          (function () {
+            matchingParameterTypeMatchers = matchingParameterTypeMatchers.sort(ParameterTypeMatcher.compare);
+
+            // Find all the best parameter type matchers, they are all candidates.
+            var bestParameterTypeMatcher = matchingParameterTypeMatchers[0];
+            var bestParameterTypeMatchers = matchingParameterTypeMatchers.filter(function (m) {
+              return ParameterTypeMatcher.compare(m, bestParameterTypeMatcher) === 0;
+            });
+
+            // Build a list of parameter types without duplicates. The reason there
+            // might be duplicates is that some parameter types have more than one regexp,
+            // which means multiple ParameterTypeMatcher objects will have a reference to the
+            // same ParameterType.
+            // We're sorting the list so preferential parameter types are listed first.
+            // Users are most likely to want these, so they should be listed at the top.
+            var parameterTypes = [];
+            var _iteratorNormalCompletion2 = true;
+            var _didIteratorError2 = false;
+            var _iteratorError2 = undefined;
+
+            try {
+              for (var _iterator2 = bestParameterTypeMatchers[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                var _parameterTypeMatcher = _step2.value;
+
+                if (parameterTypes.indexOf(_parameterTypeMatcher.parameterType) === -1) {
+                  parameterTypes.push(_parameterTypeMatcher.parameterType);
+                }
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+
+            parameterTypes = parameterTypes.sort(ParameterType.compare);
+
+            parameterTypeCombinations.push(parameterTypes);
+
+            expressionTemplate += escape(text.slice(pos, bestParameterTypeMatcher.start));
+            expressionTemplate += '{%s}';
+
+            pos = bestParameterTypeMatcher.start + bestParameterTypeMatcher.group.length;
+          })();
+        } else {
+          break;
+        }
+
+        if (pos >= text.length) {
+          break;
+        }
+      }
+
+      expressionTemplate += escape(text.slice(pos));
+      return new CombinatorialGeneratedExpressionFactory(expressionTemplate, parameterTypeCombinations).generateExpressions();
+    }
+
+    /**
+     * @deprecated
+     */
+
+  }, {
+    key: 'generateExpression',
+    value: function generateExpression(text) {
+      var _this = this;
+
+      return util.deprecate(function () {
+        return _this.generateExpressions(text)[0];
+      }, 'CucumberExpressionGenerator.generateExpression: Use CucumberExpressionGenerator.generateExpressions instead')();
+    }
+  }, {
+    key: '_createParameterTypeMatchers',
+    value: function _createParameterTypeMatchers(text) {
+      var parameterMatchers = [];
+      var _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = this._parameterTypeRegistry.parameterTypes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var parameterType = _step3.value;
+
+          if (parameterType.useForSnippets) {
+            parameterMatchers = parameterMatchers.concat(this._createParameterTypeMatchers2(parameterType, text));
+          }
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+
+      return parameterMatchers;
+    }
+  }, {
+    key: '_createParameterTypeMatchers2',
+    value: function _createParameterTypeMatchers2(parameterType, text) {
+      // TODO: [].map
+      var result = [];
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = parameterType.regexps[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var regexp = _step4.value;
+
+          result.push(new ParameterTypeMatcher(parameterType, regexp, text));
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+
+      return result;
+    }
+  }]);
+
+  return CucumberExpressionGenerator;
+}();
+
+function escape(s) {
+  return s.replace(/%/g, '%%') // for util.format
+  .replace(/\(/g, '\\(').replace(/{/g, '\\{').replace(/\//g, '\\/');
+}
+
+module.exports = CucumberExpressionGenerator;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/errors.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var CucumberExpressionError = function (_Error) {
+  _inherits(CucumberExpressionError, _Error);
+
+  function CucumberExpressionError() {
+    _classCallCheck(this, CucumberExpressionError);
+
+    return _possibleConstructorReturn(this, (CucumberExpressionError.__proto__ || Object.getPrototypeOf(CucumberExpressionError)).apply(this, arguments));
+  }
+
+  return CucumberExpressionError;
+}(Error);
+
+var AmbiguousParameterTypeError = function (_CucumberExpressionEr) {
+  _inherits(AmbiguousParameterTypeError, _CucumberExpressionEr);
+
+  function AmbiguousParameterTypeError() {
+    _classCallCheck(this, AmbiguousParameterTypeError);
+
+    return _possibleConstructorReturn(this, (AmbiguousParameterTypeError.__proto__ || Object.getPrototypeOf(AmbiguousParameterTypeError)).apply(this, arguments));
+  }
+
+  _createClass(AmbiguousParameterTypeError, null, [{
+    key: 'forConstructor',
+    value: function forConstructor(keyName, keyValue, parameterTypes, generatedExpressions) {
+      return new this('parameter type with ' + keyName + '=' + keyValue + ' is used by several parameter types: ' + parameterTypes + ', ' + generatedExpressions);
+    }
+  }, {
+    key: 'forRegExp',
+    value: function forRegExp(parameterTypeRegexp, expressionRegexp, parameterTypes, generatedExpressions) {
+      return new this('Your Regular Expression ' + expressionRegexp + '\nmatches multiple parameter types with regexp ' + parameterTypeRegexp + ':\n   ' + this._parameterTypeNames(parameterTypes) + '\n\nI couldn\'t decide which one to use. You have two options:\n\n1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n   ' + this._expressions(generatedExpressions) + '\n\n2) Make one of the parameter types preferential and continue to use a Regular Expression.\n');
+    }
+  }, {
+    key: '_parameterTypeNames',
+    value: function _parameterTypeNames(parameterTypes) {
+      return parameterTypes.map(function (p) {
+        return '{' + p.name + '}';
+      }).join('\n   ');
+    }
+  }, {
+    key: '_expressions',
+    value: function _expressions(generatedExpressions) {
+      return generatedExpressions.map(function (e) {
+        return e.source;
+      }).join('\n   ');
+    }
+  }]);
+
+  return AmbiguousParameterTypeError;
+}(CucumberExpressionError);
+
+var UndefinedParameterTypeError = function (_CucumberExpressionEr2) {
+  _inherits(UndefinedParameterTypeError, _CucumberExpressionEr2);
+
+  function UndefinedParameterTypeError(typeName) {
+    _classCallCheck(this, UndefinedParameterTypeError);
+
+    return _possibleConstructorReturn(this, (UndefinedParameterTypeError.__proto__ || Object.getPrototypeOf(UndefinedParameterTypeError)).call(this, 'Undefined parameter type {' + typeName + '}'));
+  }
+
+  return UndefinedParameterTypeError;
+}(CucumberExpressionError);
+
+module.exports = {
+  AmbiguousParameterTypeError: AmbiguousParameterTypeError,
+  UndefinedParameterTypeError: UndefinedParameterTypeError,
+  CucumberExpressionError: CucumberExpressionError
+};

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/generated_expression.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var util = require('util');
+
+var GeneratedExpression = function () {
+  function GeneratedExpression(expressionTemplate, parameterTypes) {
+    _classCallCheck(this, GeneratedExpression);
+
+    this._expressionTemplate = expressionTemplate;
+    this._parameterTypes = parameterTypes;
+  }
+
+  _createClass(GeneratedExpression, [{
+    key: 'source',
+    get: function get() {
+      return util.format.apply(util, [this._expressionTemplate].concat(_toConsumableArray(this._parameterTypes.map(function (t) {
+        return t.name;
+      }))));
+    }
+
+    /**
+     * Returns an array of parameter names to use in generated function/method signatures
+     *
+     * @returns {Array.<String>}
+     */
+
+  }, {
+    key: 'parameterNames',
+    get: function get() {
+      var usageByTypeName = {};
+      return this._parameterTypes.map(function (t) {
+        return getParameterName(t.name, usageByTypeName);
+      });
+    }
+
+    /**
+     * @returns {Array.<ParameterType>}
+     */
+
+  }, {
+    key: 'parameterTypes',
+    get: function get() {
+      return this._parameterTypes;
+    }
+  }]);
+
+  return GeneratedExpression;
+}();
+
+function getParameterName(typeName, usageByTypeName) {
+  var count = usageByTypeName[typeName];
+  count = count ? count + 1 : 1;
+  usageByTypeName[typeName] = count;
+
+  return count === 1 ? typeName : '' + typeName + count;
+}
+
+module.exports = GeneratedExpression;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/group.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Group = function () {
+  function Group(value, start, end, children) {
+    _classCallCheck(this, Group);
+
+    this._value = value;
+    this._start = start;
+    this._end = end;
+    this._children = children;
+  }
+
+  _createClass(Group, [{
+    key: "value",
+    get: function get() {
+      return this._value;
+    }
+  }, {
+    key: "start",
+    get: function get() {
+      return this._start;
+    }
+  }, {
+    key: "end",
+    get: function get() {
+      return this._end;
+    }
+  }, {
+    key: "children",
+    get: function get() {
+      return this._children;
+    }
+  }, {
+    key: "values",
+    get: function get() {
+      return (this.children.length === 0 ? [this] : this.children).map(function (g) {
+        return g.value;
+      }).filter(function (v) {
+        return v !== undefined;
+      });
+    }
+  }]);
+
+  return Group;
+}();
+
+module.exports = Group;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/group_builder.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Group = require('./group');
+
+var GroupBuilder = function () {
+  function GroupBuilder() {
+    _classCallCheck(this, GroupBuilder);
+
+    this._groupBuilders = [];
+    this._capturing = true;
+  }
+
+  _createClass(GroupBuilder, [{
+    key: 'add',
+    value: function add(groupBuilder) {
+      this._groupBuilders.push(groupBuilder);
+    }
+  }, {
+    key: 'build',
+    value: function build(match, nextGroupIndex) {
+      var groupIndex = nextGroupIndex();
+      var children = this._groupBuilders.map(function (gb) {
+        return gb.build(match, nextGroupIndex);
+      });
+      return new Group(match[groupIndex], match.index[groupIndex], match.index[groupIndex] + (match[groupIndex] || '').length, children);
+    }
+  }, {
+    key: 'setNonCapturing',
+    value: function setNonCapturing() {
+      this._capturing = false;
+    }
+  }, {
+    key: 'moveChildrenTo',
+    value: function moveChildrenTo(groupBuilder) {
+      this._groupBuilders.forEach(function (child) {
+        return groupBuilder.add(child);
+      });
+    }
+  }, {
+    key: 'capturing',
+    get: function get() {
+      return this._capturing;
+    }
+  }, {
+    key: 'children',
+    get: function get() {
+      return this._groupBuilders;
+    }
+  }]);
+
+  return GroupBuilder;
+}();
+
+module.exports = GroupBuilder;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var CucumberExpression = require('./cucumber_expression');
+var RegularExpression = require('./regular_expression');
+var CucumberExpressionGenerator = require('./cucumber_expression_generator');
+var ParameterTypeRegistry = require('./parameter_type_registry');
+var ParameterType = require('./parameter_type');
+
+module.exports = {
+  CucumberExpression: CucumberExpression,
+  RegularExpression: RegularExpression,
+  CucumberExpressionGenerator: CucumberExpressionGenerator,
+  ParameterTypeRegistry: ParameterTypeRegistry,
+  ParameterType: ParameterType
+};

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/parameter_type.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _require = require('./errors'),
+    CucumberExpressionError = _require.CucumberExpressionError;
+
+var ParameterType = function () {
+  _createClass(ParameterType, null, [{
+    key: 'compare',
+    value: function compare(pt1, pt2) {
+      if (pt1.preferForRegexpMatch && !pt2.preferForRegexpMatch) return -1;
+      if (pt2.preferForRegexpMatch && !pt1.preferForRegexpMatch) return 1;
+      return pt1.name.localeCompare(pt2.name);
+    }
+
+    /**
+     * @param name {String} the name of the type
+     * @param regexps {Array.<RegExp>,RegExp,Array.<String>,String} that matches the type
+     * @param type {Function} the prototype (constructor) of the type. May be null.
+     * @param transform {Function} function transforming string to another type. May be null.
+     * @param useForSnippets {boolean} true if this should be used for snippets. Defaults to true.
+     * @param preferForRegexpMatch {boolean} true if this is a preferential type. Defaults to false.
+     */
+
+  }]);
+
+  function ParameterType(name, regexps, type, transform, useForSnippets, preferForRegexpMatch) {
+    _classCallCheck(this, ParameterType);
+
+    if (transform === undefined) transform = function transform(s) {
+      return s;
+    };
+    if (useForSnippets === undefined) useForSnippets = true;
+    if (preferForRegexpMatch === undefined) preferForRegexpMatch = false;
+    this._name = name;
+    this._regexps = stringArray(regexps);
+    this._type = type;
+    this._transform = transform;
+    this._useForSnippets = useForSnippets;
+    this._preferForRegexpMatch = preferForRegexpMatch;
+  }
+
+  _createClass(ParameterType, [{
+    key: 'transform',
+    value: function transform(thisObj, groupValues) {
+      return this._transform.apply(thisObj, groupValues);
+    }
+  }, {
+    key: 'name',
+    get: function get() {
+      return this._name;
+    }
+  }, {
+    key: 'regexps',
+    get: function get() {
+      return this._regexps;
+    }
+  }, {
+    key: 'type',
+    get: function get() {
+      return this._type;
+    }
+  }, {
+    key: 'preferForRegexpMatch',
+    get: function get() {
+      return this._preferForRegexpMatch;
+    }
+  }, {
+    key: 'useForSnippets',
+    get: function get() {
+      return this._useForSnippets;
+    }
+  }]);
+
+  return ParameterType;
+}();
+
+function stringArray(regexps) {
+  var array = Array.isArray(regexps) ? regexps : [regexps];
+  return array.map(function (r) {
+    return typeof r === 'string' ? r : regexpSource(r);
+  });
+}
+
+function regexpSource(regexp) {
+  var flags = regexpFlags(regexp);
+
+  var _arr = ['g', 'i', 'm', 'y'];
+  for (var _i = 0; _i < _arr.length; _i++) {
+    var flag = _arr[_i];
+    if (flags.indexOf(flag) !== -1) throw new CucumberExpressionError('ParameterType Regexps can\'t use flag \'' + flag + '\'');
+  }
+  return regexp.source;
+}
+
+// Backport RegExp.flags for Node 4.x
+// https://github.com/nodejs/node/issues/8390
+//
+// For some strange reason this is not needed for
+// `./mocha dist/test`, but it is needed for
+// `./mocha dist/test/parameter_type_test.js`
+function regexpFlags(regexp) {
+  var flags = regexp.flags;
+  if (flags === undefined) {
+    flags = '';
+    if (regexp.ignoreCase) flags += 'i';
+    if (regexp.global) flags += 'g';
+    if (regexp.multiline) flags += 'm';
+  }
+  return flags;
+}
+
+module.exports = ParameterType;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/parameter_type_matcher.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var ParameterTypeMatcher = function () {
+  function ParameterTypeMatcher(parameter, regexp, text, matchPosition) {
+    _classCallCheck(this, ParameterTypeMatcher);
+
+    this._parameterType = parameter;
+    this._treeRegexp = regexp;
+    this._text = text;
+    this._matchPosition = matchPosition || 0;
+
+    var captureGroupRegexp = new RegExp('(' + regexp + ')');
+    this._match = captureGroupRegexp.exec(text.slice(this._matchPosition));
+  }
+
+  _createClass(ParameterTypeMatcher, [{
+    key: 'advanceTo',
+    value: function advanceTo(newMatchPosition) {
+      return new ParameterTypeMatcher(this._parameterType, this._treeRegexp, this._text, newMatchPosition);
+    }
+  }, {
+    key: 'parameterType',
+    get: function get() {
+      return this._parameterType;
+    }
+  }, {
+    key: 'find',
+    get: function get() {
+      return this._match && this.group !== '';
+    }
+  }, {
+    key: 'start',
+    get: function get() {
+      return this._matchPosition + this._match.index;
+    }
+  }, {
+    key: 'group',
+    get: function get() {
+      return this._match[0];
+    }
+  }], [{
+    key: 'compare',
+    value: function compare(a, b) {
+      var posComparison = a.start - b.start;
+      if (posComparison !== 0) return posComparison;
+      var lengthComparison = b.group.length - a.group.length;
+      if (lengthComparison !== 0) return lengthComparison;
+      return 0;
+    }
+  }]);
+
+  return ParameterTypeMatcher;
+}();
+
+module.exports = ParameterTypeMatcher;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/parameter_type_registry.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var ParameterType = require('./parameter_type');
+var CucumberExpressionGenerator = require('./cucumber_expression_generator.js');
+
+var _require = require('./errors'),
+    CucumberExpressionError = _require.CucumberExpressionError,
+    AmbiguousParameterTypeError = _require.AmbiguousParameterTypeError;
+
+var INTEGER_REGEXPS = [/-?\d+/, /\d+/];
+var FLOAT_REGEXP = /-?\d*\.\d+/;
+var WORD_REGEXP = /\w+/;
+var STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/;
+
+var ParameterTypeRegistry = function () {
+  function ParameterTypeRegistry() {
+    _classCallCheck(this, ParameterTypeRegistry);
+
+    this._parameterTypeByName = new Map();
+    this._parameterTypesByRegexp = new Map();
+
+    this.defineParameterType(new ParameterType('int', INTEGER_REGEXPS, Number, parseInt, true, true));
+    this.defineParameterType(new ParameterType('float', FLOAT_REGEXP, Number, parseFloat, true, false));
+    this.defineParameterType(new ParameterType('word', WORD_REGEXP, String, function (s) {
+      return s;
+    }, false, false));
+    this.defineParameterType(new ParameterType('string', STRING_REGEXP, String, function (s) {
+      return s.replace(/\\"/g, '"').replace(/\\'/g, "'");
+    }, true, false));
+  }
+
+  _createClass(ParameterTypeRegistry, [{
+    key: 'lookupByTypeName',
+    value: function lookupByTypeName(typeName) {
+      return this._parameterTypeByName.get(typeName);
+    }
+  }, {
+    key: 'lookupByRegexp',
+    value: function lookupByRegexp(parameterTypeRegexp, expressionRegexp, text) {
+      var parameterTypes = this._parameterTypesByRegexp.get(parameterTypeRegexp);
+      if (!parameterTypes) return null;
+      if (parameterTypes.length > 1 && !parameterTypes[0].preferForRegexpMatch) {
+        // We don't do this check on insertion because we only want to restrict
+        // ambiguiuty when we look up by Regexp. Users of CucumberExpression should
+        // not be restricted.
+        var generatedExpressions = new CucumberExpressionGenerator(this).generateExpressions(text);
+        throw new AmbiguousParameterTypeError.forRegExp(parameterTypeRegexp, expressionRegexp, parameterTypes, generatedExpressions);
+      }
+      return parameterTypes[0];
+    }
+  }, {
+    key: 'defineParameterType',
+    value: function defineParameterType(parameterType) {
+      if (this._parameterTypeByName.has(parameterType.name)) throw new Error('There is already a parameter type with name ' + parameterType.name);
+      this._parameterTypeByName.set(parameterType.name, parameterType);
+
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = parameterType.regexps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var parameterTypeRegexp = _step.value;
+
+          if (!this._parameterTypesByRegexp.has(parameterTypeRegexp)) {
+            this._parameterTypesByRegexp.set(parameterTypeRegexp, []);
+          }
+          var parameterTypes = this._parameterTypesByRegexp.get(parameterTypeRegexp);
+          var existingParameterType = parameterTypes[0];
+          if (parameterTypes.length > 0 && existingParameterType.preferForRegexpMatch && parameterType.preferForRegexpMatch) {
+            throw new CucumberExpressionError('There can only be one preferential parameter type per regexp. ' + ('The regexp /' + parameterTypeRegexp + '/ is used for two preferential parameter types, {' + existingParameterType.name + '} and {' + parameterType.name + '}'));
+          }
+          if (parameterTypes.indexOf(parameterType) === -1) {
+            parameterTypes.push(parameterType);
+            this._parameterTypesByRegexp.set(parameterTypeRegexp, parameterTypes.sort(ParameterType.compare));
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+  }, {
+    key: 'parameterTypes',
+    get: function get() {
+      return this._parameterTypeByName.values();
+    }
+  }]);
+
+  return ParameterTypeRegistry;
+}();
+
+module.exports = ParameterTypeRegistry;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/regular_expression.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Argument = require('./argument');
+var TreeRegexp = require('./tree_regexp');
+var ParameterType = require('./parameter_type');
+
+var RegularExpression = function () {
+  function RegularExpression(expressionRegexp, parameterTypeRegistry) {
+    _classCallCheck(this, RegularExpression);
+
+    this._expressionRegexp = expressionRegexp;
+    this._parameterTypeRegistry = parameterTypeRegistry;
+    this._treeRegexp = new TreeRegexp(expressionRegexp);
+  }
+
+  _createClass(RegularExpression, [{
+    key: 'match',
+    value: function match(text) {
+      var _this = this;
+
+      var parameterTypes = this._treeRegexp.groupBuilder.children.map(function (groupBuilder) {
+        var parameterTypeRegexp = groupBuilder.source;
+
+        return _this._parameterTypeRegistry.lookupByRegexp(parameterTypeRegexp, _this._treeRegexp, text) || new ParameterType(parameterTypeRegexp, parameterTypeRegexp, String, function (s) {
+          return s;
+        }, false, false);
+      });
+
+      return Argument.build(this._treeRegexp, text, parameterTypes);
+    }
+  }, {
+    key: 'regexp',
+    get: function get() {
+      return this._expressionRegexp;
+    }
+  }, {
+    key: 'source',
+    get: function get() {
+      return this._expressionRegexp.source;
+    }
+  }]);
+
+  return RegularExpression;
+}();
+
+module.exports = RegularExpression;

node_modules/cucumber/node_modules/cucumber-expressions/dist/src/tree_regexp.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Regex = require('becke-ch--regex--s0-0-v1--base--pl--lib');
+var GroupBuilder = require('./group_builder');
+
+var TreeRegexp = function () {
+  function TreeRegexp(regexp) {
+    var _this = this;
+
+    _classCallCheck(this, TreeRegexp);
+
+    this._re = 'string' === typeof regexp ? new RegExp(regexp) : regexp;
+    this._regex = new Regex(this._re.source, this._re.flags);
+
+    var stack = [new GroupBuilder()];
+    var groupStartStack = [];
+    var last = null;
+    var escaping = false;
+    var nonCapturingMaybe = false;
+    this._re.source.split('').forEach(function (c, n) {
+      if (c === '(' && !escaping) {
+        stack.push(new GroupBuilder());
+        groupStartStack.push(n + 1);
+        nonCapturingMaybe = false;
+      } else if (c === ')' && !escaping) {
+        var gb = stack.pop();
+        var groupStart = groupStartStack.pop();
+        if (gb.capturing) {
+          gb.source = _this._re.source.substring(groupStart, n);
+          stack[stack.length - 1].add(gb);
+        } else {
+          gb.moveChildrenTo(stack[stack.length - 1]);
+        }
+        nonCapturingMaybe = false;
+      } else if (c === '?' && last === '(') {
+        nonCapturingMaybe = true;
+      } else if (c === ':' && nonCapturingMaybe) {
+        stack[stack.length - 1].setNonCapturing();
+        nonCapturingMaybe = false;
+      }
+      escaping = c === '\\' && !escaping;
+      last = c;
+    });
+    this._groupBuilder = stack.pop();
+  }
+
+  _createClass(TreeRegexp, [{
+    key: 'match',
+    value: function match(s) {
+      var match = this._regex.exec(s);
+      if (!match) return null;
+      var groupIndex = 0;
+      var nextGroupIndex = function nextGroupIndex() {
+        return groupIndex++;
+      };
+      return this._groupBuilder.build(match, nextGroupIndex);
+    }
+  }, {
+    key: 'regexp',
+    get: function get() {
+      return this._re;
+    }
+  }, {
+    key: 'groupBuilder',
+    get: function get() {
+      return this._groupBuilder;
+    }
+  }]);
+
+  return TreeRegexp;
+}();
+
+module.exports = TreeRegexp;

node_modules/cucumber/node_modules/cucumber-expressions/examples.txt

@@ -0,0 +1,19 @@
+I have {int} cuke(s)
+I have 22 cukes
+[22]
+---
+I have {int} cuke(s) and some \[]^$.|?*+
+I have 1 cuke and some \[]^$.|?*+
+[1]
+---
+/I have (\d+) cukes? in my (\w+) now/
+I have 22 cukes in my belly now
+[22,"belly"]
+---
+/I have (-?\d+) cukes? in my (.*) now/
+I have 1 cuke in my belly now
+[1,"belly"]
+---
+/^Something( with an optional argument)?$/
+Something
+[null]

node_modules/cucumber/node_modules/cucumber-expressions/mocha

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+node_modules/.bin/mocha "$@"

node_modules/cucumber/node_modules/cucumber-expressions/package.json

@@ -0,0 +1,80 @@
+{
+  "_from": "cucumber-expressions@^5.0.13",
+  "_id": "cucumber-expressions@5.0.18",
+  "_inBundle": false,
+  "_integrity": "sha1-bHB3nv0668Xp54U5OLERAyJClZY=",
+  "_location": "/cucumber/cucumber-expressions",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "cucumber-expressions@^5.0.13",
+    "name": "cucumber-expressions",
+    "escapedName": "cucumber-expressions",
+    "rawSpec": "^5.0.13",
+    "saveSpec": null,
+    "fetchSpec": "^5.0.13"
+  },
+  "_requiredBy": [
+    "/cucumber"
+  ],
+  "_resolved": "https://registry.npmjs.org/cucumber-expressions/-/cucumber-expressions-5.0.18.tgz",
+  "_shasum": "6c70779efd3aebc5e9e7853938b1110322429596",
+  "_spec": "cucumber-expressions@^5.0.13",
+  "_where": "/home/simon/Documents/lifen-autotest/node_modules/cucumber",
+  "author": {
+    "name": "Cucumber Limited",
+    "email": "cukes@googlegroups.com"
+  },
+  "bugs": {
+    "url": "https://github.com/cucumber/cucumber-expressions-javascript/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "becke-ch--regex--s0-0-v1--base--pl--lib": "^1.2.0"
+  },
+  "deprecated": false,
+  "description": "Cucumber Expressions - a simpler alternative to Regular Expressions",
+  "devDependencies": {
+    "babel-cli": "^6.23.0",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.6.1",
+    "eslint": "^4.19.1",
+    "eslint-config-eslint": "^4.0.0",
+    "eslint-config-prettier": "^2.9.0",
+    "eslint-plugin-prettier": "^2.6.0",
+    "mocha": "^5.0.5",
+    "nyc": "^11.6.0",
+    "prettier": "^1.11.1"
+  },
+  "files": [
+    "*"
+  ],
+  "homepage": "https://github.com/cucumber/cucumber-expressions-javascript#readme",
+  "keywords": [
+    "cucumber",
+    "steps",
+    "regexp",
+    "regex"
+  ],
+  "license": "MIT",
+  "main": "dist/src/index.js",
+  "name": "cucumber-expressions",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cucumber/cucumber-expressions-javascript.git"
+  },
+  "scripts": {
+    "build": "babel src --out-dir dist/src",
+    "build-test": "babel test --out-dir dist/test",
+    "coverage": "nyc --reporter=html --reporter=text mocha",
+    "eslint": "eslint src test",
+    "eslint-fix": "eslint --fix src test",
+    "mocha": "mocha",
+    "mocha-built": "mocha dist/test",
+    "postinstall": "node scripts/postinstall.js",
+    "prepare": "yarn build",
+    "test": "npm run eslint && npm run coverage"
+  },
+  "version": "5.0.18"
+}

node_modules/cucumber/node_modules/cucumber-expressions/scripts/postinstall.js

@@ -0,0 +1,10 @@
+var path = require('path')
+var fs = require('fs')
+var exec = require('child_process').exec
+
+fs.access(path.join(__dirname, '..', 'dist'), function(err) {
+  if (!err) return
+  exec('yarn build', { cwd: path.join(__dirname, '..') }, function(err) {
+    if (err) throw err
+  })
+})

node_modules/cucumber/node_modules/cucumber-expressions/scripts/prettier-all

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+#
+# Reformat and lint all JavaScript with prettier/eslint
+#
+set -euf -o pipefail
+
+git ls-files . | \
+grep "\.jsx\?$" | \
+xargs ./node_modules/.bin/eslint --ext=js --ext=jsx --fix

node_modules/cucumber/node_modules/cucumber-expressions/scripts/test

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+
+if [[ $(node --version) =~ ^v6 ]]; then
+  yarn build
+  yarn build-test
+  yarn mocha-built
+else
+  yarn test
+fi

node_modules/cucumber/node_modules/cucumber-expressions/src/argument.js

@@ -0,0 +1,45 @@
+const { CucumberExpressionError } = require('./errors')
+
+class Argument {
+  static build(treeRegexp, text, parameterTypes) {
+    const group = treeRegexp.match(text)
+    if (!group) return null
+
+    const argGroups = group.children
+
+    if (argGroups.length !== parameterTypes.length) {
+      throw new CucumberExpressionError(
+        `Expression ${treeRegexp.regexp} has ${
+          argGroups.length
+        } capture groups (${argGroups.map(g => g.value)}), but there were ${
+          parameterTypes.length
+        } parameter types (${parameterTypes.map(p => p.name)})`
+      )
+    }
+
+    return parameterTypes.map(
+      (parameterType, i) => new Argument(argGroups[i], parameterType)
+    )
+  }
+
+  constructor(group, parameterType) {
+    this._group = group
+    this._parameterType = parameterType
+  }
+
+  get group() {
+    return this._group
+  }
+
+  /**
+   * Get the value returned by the parameter type's transformer function.
+   *
+   * @param thisObj the object in which the transformer function is applied.
+   */
+  getValue(thisObj) {
+    let groupValues = this._group ? this._group.values : null
+    return this._parameterType.transform(thisObj, groupValues)
+  }
+}
+
+module.exports = Argument

node_modules/cucumber/node_modules/cucumber-expressions/src/combinatorial_generated_expression_factory.js

@@ -0,0 +1,35 @@
+const GeneratedExpression = require('./generated_expression')
+
+class CombinatorialGeneratedExpressionFactory {
+  constructor(expressionTemplate, parameterTypeCombinations) {
+    this._expressionTemplate = expressionTemplate
+    this._parameterTypeCombinations = parameterTypeCombinations
+  }
+
+  generateExpressions() {
+    const generatedExpressions = []
+    this._generatePermutations(generatedExpressions, 0, [])
+    return generatedExpressions
+  }
+
+  _generatePermutations(generatedExpressions, depth, currentParameterTypes) {
+    if (depth === this._parameterTypeCombinations.length) {
+      generatedExpressions.push(
+        new GeneratedExpression(this._expressionTemplate, currentParameterTypes)
+      )
+      return
+    }
+
+    for (let i = 0; i < this._parameterTypeCombinations[depth].length; ++i) {
+      const newCurrentParameterTypes = currentParameterTypes.slice() // clone
+      newCurrentParameterTypes.push(this._parameterTypeCombinations[depth][i])
+      this._generatePermutations(
+        generatedExpressions,
+        depth + 1,
+        newCurrentParameterTypes
+      )
+    }
+  }
+}
+
+module.exports = CombinatorialGeneratedExpressionFactory

node_modules/cucumber/node_modules/cucumber-expressions/src/cucumber_expression.js

@@ -0,0 +1,87 @@
+const Argument = require('./argument')
+const TreeRegexp = require('./tree_regexp')
+const { UndefinedParameterTypeError } = require('./errors')
+
+// Does not include (){} characters because they have special meaning
+const ESCAPE_REGEXP = /([\\^[$.|?*+])/g
+const PARAMETER_REGEXP = /(\\\\)?{([^}]+)}/g
+const OPTIONAL_REGEXP = /(\\\\)?\(([^)]+)\)/g
+const ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP = /([^\s^/]+)((\/[^\s^/]+)+)/g
+const DOUBLE_ESCAPE = '\\\\'
+
+class CucumberExpression {
+  /**
+   * @param expression
+   * @param parameterTypeRegistry
+   */
+  constructor(expression, parameterTypeRegistry) {
+    this._expression = expression
+    this._parameterTypes = []
+
+    expression = this.processEscapes(expression)
+    expression = this.processOptional(expression)
+    expression = this.processAlternation(expression)
+    expression = this.processParameters(expression, parameterTypeRegistry)
+    expression = `^${expression}$`
+
+    this._treeRegexp = new TreeRegexp(expression)
+  }
+
+  processEscapes(expression) {
+    return expression.replace(ESCAPE_REGEXP, '\\$1')
+  }
+
+  processOptional(expression) {
+    return expression.replace(
+      OPTIONAL_REGEXP,
+      (match, p1, p2) => (p1 === DOUBLE_ESCAPE ? `\\(${p2}\\)` : `(?:${p2})?`)
+    )
+  }
+
+  processAlternation(expression) {
+    return expression.replace(ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP, match => {
+      // replace \/ with /
+      // replace / with |
+      const replacement = match.replace(/\//g, '|').replace(/\\\|/g, '/')
+      return `(?:${replacement})`
+    })
+  }
+
+  processParameters(expression, parameterTypeRegistry) {
+    return expression.replace(PARAMETER_REGEXP, (match, p1, p2) => {
+      if (p1 === DOUBLE_ESCAPE) return `\\{${p2}\\}`
+
+      const typeName = p2
+      const parameterType = parameterTypeRegistry.lookupByTypeName(typeName)
+      if (!parameterType) throw new UndefinedParameterTypeError(typeName)
+      this._parameterTypes.push(parameterType)
+      return buildCaptureRegexp(parameterType.regexps)
+    })
+  }
+
+  match(text) {
+    return Argument.build(this._treeRegexp, text, this._parameterTypes)
+  }
+
+  get regexp() {
+    return this._treeRegexp.regexp
+  }
+
+  get source() {
+    return this._expression
+  }
+}
+
+function buildCaptureRegexp(regexps) {
+  if (regexps.length === 1) {
+    return `(${regexps[0]})`
+  }
+
+  const captureGroups = regexps.map(group => {
+    return `(?:${group})`
+  })
+
+  return `(${captureGroups.join('|')})`
+}
+
+module.exports = CucumberExpression