refactor(Cypress): Moved Cypress to the main folder of the project, as I don't need a sub project for now.

node_modules/cypress/README.md

@@ -0,0 +1,25 @@
+# Cypress
+
+Fast, easy and reliable testing for anything that runs in a browser.
+
+## What is this?
+
+[Cypress](https://www.cypress.io/) comes packaged as an `npm` module, which is all you need to get started testing.
+
+After installing you'll be able to:
+
+- Open Cypress from the CLI
+- Run Cypress from the CLI
+- `require` Cypress as a module
+
+## Install
+
+Please check our [system requirements](https://on.cypress.io/installing-cypress).
+
+```sh
+npm install --save-dev cypress
+```
+
+## Documentation
+
+Please [visit our documentation](https://on.cypress.io/cli) for a full list of commands and examples.

node_modules/cypress/bin/cypress

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../lib/cli').init()

node_modules/cypress/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const minimist = require('minimist');
+
+const debug = require('debug')('cypress:cli');
+
+const args = minimist(process.argv.slice(2));
+
+const util = require('./lib/util'); // we're being used from the command line
+
+
+switch (args.exec) {
+  case 'install':
+    debug('installing Cypress from NPM');
+
+    require('./lib/tasks/install').start({
+      force: args.force
+    }).catch(util.logErrorExit1);
+
+    break;
+
+  case 'verify':
+    // for simple testing in the monorepo
+    debug('verifying Cypress');
+
+    require('./lib/tasks/verify').start({
+      force: true
+    }) // always force verification
+    .catch(util.logErrorExit1);
+
+    break;
+
+  default:
+    debug('exporting Cypress module interface');
+    module.exports = require('./lib/cypress');
+}

node_modules/cypress/lib/VerboseRenderer.js

@@ -0,0 +1,72 @@
+"use strict";
+
+// Vendored from @cypress/listr-verbose-renderer
+const figures = require('figures');
+
+const cliCursor = require('cli-cursor');
+
+const chalk = require('chalk');
+
+const dayjs = require('dayjs');
+
+const formattedLog = (options, output) => {
+  const timestamp = dayjs().format(options.dateFormat); // eslint-disable-next-line no-console
+
+  console.log(`${chalk.dim(`[${timestamp}]`)} ${output}`);
+};
+
+const renderHelper = (task, event, options) => {
+  const log = formattedLog.bind(undefined, options);
+
+  if (event.type === 'STATE') {
+    const message = task.isPending() ? 'started' : task.state;
+    log(`${task.title} [${message}]`);
+
+    if (task.isSkipped() && task.output) {
+      log(`${figures.arrowRight} ${task.output}`);
+    }
+  } else if (event.type === 'TITLE') {
+    log(`${task.title} [title changed]`);
+  }
+};
+
+const render = (tasks, options) => {
+  for (const task of tasks) {
+    task.subscribe(event => {
+      if (event.type === 'SUBTASKS') {
+        render(task.subtasks, options);
+        return;
+      }
+
+      renderHelper(task, event, options);
+    }, err => {
+      // eslint-disable-next-line no-console
+      console.log(err);
+    });
+  }
+};
+
+class VerboseRenderer {
+  constructor(tasks, options) {
+    this._tasks = tasks;
+    this._options = Object.assign({
+      dateFormat: 'HH:mm:ss'
+    }, options);
+  }
+
+  static get nonTTY() {
+    return true;
+  }
+
+  render() {
+    cliCursor.hide();
+    render(this._tasks, this._options);
+  }
+
+  end() {
+    cliCursor.show();
+  }
+
+}
+
+module.exports = VerboseRenderer;

node_modules/cypress/lib/cli.js

@@ -0,0 +1,426 @@
+"use strict";
+
+// @ts-check
+const _ = require('lodash');
+
+const R = require('ramda');
+
+const commander = require('commander');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const logSymbols = require('log-symbols');
+
+const debug = require('debug')('cypress:cli:cli');
+
+const util = require('./util');
+
+const logger = require('./logger');
+
+const errors = require('./errors');
+
+const cache = require('./tasks/cache'); // patch "commander" method called when a user passed an unknown option
+// we want to print help for the current command and exit with an error
+
+
+function unknownOption(flag, type = 'option') {
+  if (this._allowUnknownOption) return;
+  logger.error();
+  logger.error(`  error: unknown ${type}:`, flag);
+  logger.error();
+  this.outputHelp();
+  util.exit(1);
+}
+
+commander.Command.prototype.unknownOption = unknownOption;
+
+const coerceFalseOrString = arg => {
+  return arg !== 'false' ? arg : false;
+};
+
+const coerceFalse = arg => {
+  return arg !== 'false';
+};
+
+const coerceAnyStringToInt = arg => {
+  return typeof arg === 'string' ? parseInt(arg) : arg;
+};
+
+const spaceDelimitedArgsMsg = (flag, args) => {
+  let msg = `
+    ${logSymbols.warning} Warning: It looks like you're passing --${flag} a space-separated list of arguments:
+
+    "${args.join(' ')}"
+
+    This will work, but it's not recommended.
+
+    If you are trying to pass multiple arguments, separate them with commas instead:
+      cypress run --${flag} arg1,arg2,arg3
+  `;
+
+  if (flag === 'spec') {
+    msg += `
+    The most common cause of this warning is using an unescaped glob pattern. If you are
+    trying to pass a glob pattern, escape it using quotes:
+      cypress run --spec "**/*.spec.js"
+    `;
+  }
+
+  logger.log();
+  logger.warn(stripIndent(msg));
+  logger.log();
+};
+
+const parseVariableOpts = (fnArgs, args) => {
+  const [opts, unknownArgs] = fnArgs;
+
+  if (unknownArgs && unknownArgs.length && (opts.spec || opts.tag)) {
+    // this will capture space-delimited args after
+    // flags that could have possible multiple args
+    // but before the next option
+    // --spec spec1 spec2 or --tag foo bar
+    const multiArgFlags = _.compact([opts.spec ? 'spec' : opts.spec, opts.tag ? 'tag' : opts.tag]);
+
+    _.forEach(multiArgFlags, flag => {
+      const argIndex = _.indexOf(args, `--${flag}`) + 2;
+
+      const nextOptOffset = _.findIndex(_.slice(args, argIndex), arg => {
+        return _.startsWith(arg, '--');
+      });
+
+      const endIndex = nextOptOffset !== -1 ? argIndex + nextOptOffset : args.length;
+
+      const maybeArgs = _.slice(args, argIndex, endIndex);
+
+      const extraArgs = _.intersection(maybeArgs, unknownArgs);
+
+      if (extraArgs.length) {
+        opts[flag] = [opts[flag]].concat(extraArgs);
+        spaceDelimitedArgsMsg(flag, opts[flag]);
+        opts[flag] = opts[flag].join(',');
+      }
+    });
+  }
+
+  debug('variable-length opts parsed %o', {
+    args,
+    opts
+  });
+  return util.parseOpts(opts);
+};
+
+const descriptions = {
+  browserOpenMode: 'path to a custom browser to be added to the list of available browsers in Cypress',
+  browserRunMode: 'runs Cypress in the browser with the given name. if a filesystem path is supplied, Cypress will attempt to use the browser at that path.',
+  cacheClear: 'delete all cached binaries',
+  cachePrune: 'deletes all cached binaries except for the version currently in use',
+  cacheList: 'list cached binary versions',
+  cachePath: 'print the path to the binary cache',
+  cacheSize: 'Used with the list command to show the sizes of the cached folders',
+  ciBuildId: 'the unique identifier for a run on your CI provider. typically a "BUILD_ID" env var. this value is automatically detected for most CI providers',
+  config: 'sets configuration values. separate multiple values with a comma. overrides any value in cypress.json.',
+  configFile: 'path to JSON file where configuration values are set. defaults to "cypress.json". pass "false" to disable.',
+  detached: 'runs Cypress application in detached mode',
+  dev: 'runs cypress in development and bypasses binary check',
+  env: 'sets environment variables. separate multiple values with a comma. overrides any value in cypress.json or cypress.env.json',
+  exit: 'keep the browser open after tests finish',
+  forceInstall: 'force install the Cypress binary',
+  global: 'force Cypress into global mode as if its globally installed',
+  group: 'a named group for recorded runs in the Cypress Dashboard',
+  headed: 'displays the browser instead of running headlessly',
+  headless: 'hide the browser instead of running headed (default for cypress run)',
+  key: 'your secret Record Key. you can omit this if you set a CYPRESS_RECORD_KEY environment variable.',
+  parallel: 'enables concurrent runs and automatic load balancing of specs across multiple machines or processes',
+  port: 'runs Cypress on a specific port. overrides any value in cypress.json.',
+  project: 'path to the project',
+  quiet: 'run quietly, using only the configured reporter',
+  record: 'records the run. sends test results, screenshots and videos to your Cypress Dashboard.',
+  reporter: 'runs a specific mocha reporter. pass a path to use a custom reporter. defaults to "spec"',
+  reporterOptions: 'options for the mocha reporter. defaults to "null"',
+  spec: 'runs specific spec file(s). defaults to "all"',
+  tag: 'named tag(s) for recorded runs in the Cypress Dashboard',
+  version: 'prints Cypress version'
+};
+const knownCommands = ['cache', 'help', '-h', '--help', 'install', 'open', 'run', 'open-ct', 'run-ct', 'verify', '-v', '--version', 'version', 'info'];
+
+const text = description => {
+  if (!descriptions[description]) {
+    throw new Error(`Could not find description for: ${description}`);
+  }
+
+  return descriptions[description];
+};
+
+function includesVersion(args) {
+  return _.includes(args, 'version') || _.includes(args, '--version') || _.includes(args, '-v');
+}
+
+function showVersions(args) {
+  debug('printing Cypress version');
+  debug('additional arguments %o', args);
+  const versionParser = commander.option('--component <package|binary|electron|node>', 'component to report version for').allowUnknownOption(true);
+  const parsed = versionParser.parse(args);
+  const parsedOptions = {
+    component: parsed.component
+  };
+  debug('parsed version arguments %o', parsedOptions);
+
+  const reportAllVersions = versions => {
+    logger.always('Cypress package version:', versions.package);
+    logger.always('Cypress binary version:', versions.binary);
+    logger.always('Electron version:', versions.electronVersion);
+    logger.always('Bundled Node version:', versions.electronNodeVersion);
+  };
+
+  const reportComponentVersion = (componentName, versions) => {
+    const names = {
+      package: 'package',
+      binary: 'binary',
+      electron: 'electronVersion',
+      node: 'electronNodeVersion'
+    };
+
+    if (!names[componentName]) {
+      throw new Error(`Unknown component name "${componentName}"`);
+    }
+
+    const name = names[componentName];
+
+    if (!versions[name]) {
+      throw new Error(`Cannot find version for component "${componentName}" under property "${name}"`);
+    }
+
+    const version = versions[name];
+    logger.always(version);
+  };
+
+  const defaultVersions = {
+    package: undefined,
+    binary: undefined,
+    electronVersion: undefined,
+    electronNodeVersion: undefined
+  };
+  return require('./exec/versions').getVersions().then((versions = defaultVersions) => {
+    if (parsedOptions.component) {
+      reportComponentVersion(parsedOptions.component, versions);
+    } else {
+      reportAllVersions(versions);
+    }
+
+    process.exit(0);
+  }).catch(util.logErrorExit1);
+}
+
+const createProgram = () => {
+  const program = new commander.Command(); // bug in commander not printing name
+  // in usage help docs
+
+  program._name = 'cypress';
+  program.usage('<command> [options]');
+  return program;
+};
+
+const addCypressRunCommand = program => {
+  return program.command('run').usage('[options]').description('Runs Cypress tests from the CLI without the GUI').option('-b, --browser <browser-name-or-path>', text('browserRunMode')).option('--ci-build-id <id>', text('ciBuildId')).option('-c, --config <config>', text('config')).option('-C, --config-file <config-file>', text('configFile')).option('-e, --env <env>', text('env')).option('--group <name>', text('group')).option('-k, --key <record-key>', text('key')).option('--headed', text('headed')).option('--headless', text('headless')).option('--no-exit', text('exit')).option('--parallel', text('parallel')).option('-p, --port <port>', text('port')).option('-P, --project <project-path>', text('project')).option('-q, --quiet', text('quiet')).option('--record [bool]', text('record'), coerceFalse).option('-r, --reporter <reporter>', text('reporter')).option('-o, --reporter-options <reporter-options>', text('reporterOptions')).option('-s, --spec <spec>', text('spec')).option('-t, --tag <tag>', text('tag')).option('--dev', text('dev'), coerceFalse);
+};
+/**
+ * Casts known command line options for "cypress run" to their intended type.
+ * For example if the user passes "--port 5005" the ".port" property should be
+ * a number 5005 and not a string "5005".
+ *
+ * Returns a clone of the original object.
+ */
+
+
+const castCypressRunOptions = opts => {
+  // only properties that have type "string | false" in our TS definition
+  // require special handling, because CLI parsing takes care of purely
+  // boolean arguments
+  const result = R.evolve({
+    port: coerceAnyStringToInt,
+    configFile: coerceFalseOrString
+  })(opts);
+  return result;
+};
+
+module.exports = {
+  /**
+   * Parses `cypress run` command line option array into an object
+   * with options that you can feed into a `cypress.run()` module API call.
+   * @example
+   *  const options = parseRunCommand(['cypress', 'run', '--browser', 'chrome'])
+   *  // options is {browser: 'chrome'}
+   */
+  parseRunCommand(args) {
+    return new Promise((resolve, reject) => {
+      if (!Array.isArray(args)) {
+        return reject(new Error('Expected array of arguments'));
+      } // make a copy of the input arguments array
+      // and add placeholders where "node ..." would usually be
+      // also remove "cypress" keyword at the start if present
+
+
+      const cliArgs = args[0] === 'cypress' ? [...args.slice(1)] : [...args];
+      cliArgs.unshift(null, null);
+      debug('creating program parser');
+      const program = createProgram();
+      addCypressRunCommand(program).action((...fnArgs) => {
+        debug('parsed Cypress run %o', fnArgs);
+        const options = parseVariableOpts(fnArgs, cliArgs);
+        debug('parsed options %o', options);
+        const casted = castCypressRunOptions(options);
+        debug('casted options %o', casted);
+        resolve(casted);
+      });
+      debug('parsing args: %o', cliArgs);
+      program.parse(cliArgs);
+    });
+  },
+
+  /**
+   * Parses the command line and kicks off Cypress process.
+   */
+  init(args) {
+    if (!args) {
+      args = process.argv;
+    }
+
+    const {
+      CYPRESS_INTERNAL_ENV
+    } = process.env;
+
+    if (!util.isValidCypressInternalEnvValue(CYPRESS_INTERNAL_ENV)) {
+      debug('invalid CYPRESS_INTERNAL_ENV value', CYPRESS_INTERNAL_ENV);
+      return errors.exitWithError(errors.errors.invalidCypressEnv)(`CYPRESS_INTERNAL_ENV=${CYPRESS_INTERNAL_ENV}`);
+    }
+
+    if (util.isNonProductionCypressInternalEnvValue(CYPRESS_INTERNAL_ENV)) {
+      debug('non-production CYPRESS_INTERNAL_ENV value', CYPRESS_INTERNAL_ENV);
+      let msg = `
+        ${logSymbols.warning} Warning: It looks like you're passing CYPRESS_INTERNAL_ENV=${CYPRESS_INTERNAL_ENV}
+
+        The environment variable "CYPRESS_INTERNAL_ENV" is reserved and should only be used internally.
+
+        Unset the "CYPRESS_INTERNAL_ENV" environment variable and run Cypress again.
+      `;
+      logger.log();
+      logger.warn(stripIndent(msg));
+      logger.log();
+    }
+
+    const program = createProgram();
+    program.command('help').description('Shows CLI help and exits').action(() => {
+      program.help();
+    });
+    program.option('-v, --version', text('version')).command('version').description(text('version')).action(() => {
+      showVersions(args);
+    });
+    program.command('open').usage('[options]').description('Opens Cypress in the interactive GUI.').option('-b, --browser <browser-path>', text('browserOpenMode')).option('-c, --config <config>', text('config')).option('-C, --config-file <config-file>', text('configFile')).option('-d, --detached [bool]', text('detached'), coerceFalse).option('-e, --env <env>', text('env')).option('--global', text('global')).option('-p, --port <port>', text('port')).option('-P, --project <project-path>', text('project')).option('--dev', text('dev'), coerceFalse).action(opts => {
+      debug('opening Cypress');
+
+      require('./exec/open').start(util.parseOpts(opts)).catch(util.logErrorExit1);
+    });
+    addCypressRunCommand(program).action((...fnArgs) => {
+      debug('running Cypress with args %o', fnArgs);
+
+      require('./exec/run').start(parseVariableOpts(fnArgs, args)).then(util.exit).catch(util.logErrorExit1);
+    });
+    program.command('open-ct').usage('[options]').description('Opens Cypress component testing interactive mode.').option('-b, --browser <browser-path>', text('browserOpenMode')).option('-c, --config <config>', text('config')).option('-C, --config-file <config-file>', text('configFile')).option('-d, --detached [bool]', text('detached'), coerceFalse).option('-e, --env <env>', text('env')).option('--global', text('global')).option('-p, --port <port>', text('port')).option('-P, --project <project-path>', text('project')).option('--dev', text('dev'), coerceFalse).action(opts => {
+      debug('opening Cypress');
+
+      require('./exec/open').start({ ...util.parseOpts(opts),
+        testingType: 'component'
+      }).catch(util.logErrorExit1);
+    });
+    program.command('run-ct').usage('[options]').description('Runs all Cypress Component Testing suites').option('-b, --browser <browser-name-or-path>', text('browserRunMode')).option('--ci-build-id <id>', text('ciBuildId')).option('-c, --config <config>', text('config')).option('-C, --config-file <config-file>', text('configFile')).option('-e, --env <env>', text('env')).option('--group <name>', text('group')).option('-k, --key <record-key>', text('key')).option('--headed', text('headed')).option('--headless', text('headless')).option('--no-exit', text('exit')).option('--parallel', text('parallel')).option('-p, --port <port>', text('port')).option('-P, --project <project-path>', text('project')).option('-q, --quiet', text('quiet')).option('--record [bool]', text('record'), coerceFalse).option('-r, --reporter <reporter>', text('reporter')).option('-o, --reporter-options <reporter-options>', text('reporterOptions')).option('-s, --spec <spec>', text('spec')).option('-t, --tag <tag>', text('tag')).option('--dev', text('dev'), coerceFalse).action(opts => {
+      debug('running Cypress run-ct');
+
+      require('./exec/run').start({ ...util.parseOpts(opts),
+        testingType: 'component'
+      }).then(util.exit).catch(util.logErrorExit1);
+    });
+    program.command('install').usage('[options]').description('Installs the Cypress executable matching this package\'s version').option('-f, --force', text('forceInstall')).action(opts => {
+      require('./tasks/install').start(util.parseOpts(opts)).catch(util.logErrorExit1);
+    });
+    program.command('verify').usage('[options]').description('Verifies that Cypress is installed correctly and executable').option('--dev', text('dev'), coerceFalse).action(opts => {
+      const defaultOpts = {
+        force: true,
+        welcomeMessage: false
+      };
+      const parsedOpts = util.parseOpts(opts);
+
+      const options = _.extend(parsedOpts, defaultOpts);
+
+      require('./tasks/verify').start(options).catch(util.logErrorExit1);
+    });
+    program.command('cache').usage('[command]').description('Manages the Cypress binary cache').option('list', text('cacheList')).option('path', text('cachePath')).option('clear', text('cacheClear')).option('prune', text('cachePrune')).option('--size', text('cacheSize')).action(function (opts, args) {
+      if (!args || !args.length) {
+        this.outputHelp();
+        util.exit(1);
+      }
+
+      const [command] = args;
+
+      if (!_.includes(['list', 'path', 'clear', 'prune'], command)) {
+        unknownOption.call(this, `cache ${command}`, 'command');
+      }
+
+      if (command === 'list') {
+        debug('cache command %o', {
+          command,
+          size: opts.size
+        });
+        return cache.list(opts.size).catch({
+          code: 'ENOENT'
+        }, () => {
+          logger.always('No cached binary versions were found.');
+          process.exit(0);
+        }).catch(e => {
+          debug('cache list command failed with "%s"', e.message);
+          util.logErrorExit1(e);
+        });
+      }
+
+      cache[command]();
+    });
+    program.command('info').usage('[command]').description('Prints Cypress and system information').option('--dev', text('dev'), coerceFalse).action(opts => {
+      require('./exec/info').start(opts).then(util.exit).catch(util.logErrorExit1);
+    });
+    debug('cli starts with arguments %j', args);
+    util.printNodeOptions(); // if there are no arguments
+
+    if (args.length <= 2) {
+      debug('printing help');
+      program.help(); // exits
+    }
+
+    const firstCommand = args[2];
+
+    if (!_.includes(knownCommands, firstCommand)) {
+      debug('unknown command %s', firstCommand);
+      logger.error('Unknown command', `"${firstCommand}"`);
+      program.outputHelp();
+      return util.exit(1);
+    }
+
+    if (includesVersion(args)) {
+      // commander 2.11.0 changes behavior
+      // and now does not understand top level options
+      // .option('-v, --version').command('version')
+      // so we have to manually catch '-v, --version'
+      return showVersions(args);
+    }
+
+    debug('program parsing arguments');
+    return program.parse(args);
+  }
+
+}; // @ts-ignore
+
+if (!module.parent) {
+  logger.error('This CLI module should be required from another Node module');
+  logger.error('and not executed directly');
+  process.exit(-1);
+}

node_modules/cypress/lib/cypress.js

@@ -0,0 +1,75 @@
+"use strict";
+
+// https://github.com/cypress-io/cypress/issues/316
+const Promise = require('bluebird');
+
+const tmp = Promise.promisifyAll(require('tmp'));
+
+const fs = require('./fs');
+
+const open = require('./exec/open');
+
+const run = require('./exec/run');
+
+const util = require('./util');
+
+const cli = require('./cli');
+
+const cypressModuleApi = {
+  /**
+   * Opens Cypress GUI
+   * @see https://on.cypress.io/module-api#cypress-open
+   */
+  open(options = {}) {
+    options = util.normalizeModuleOptions(options);
+    return open.start(options);
+  },
+
+  /**
+   * Runs Cypress tests in the current project
+   * @see https://on.cypress.io/module-api#cypress-run
+   */
+  run(options = {}) {
+    if (!run.isValidProject(options.project)) {
+      return Promise.reject(new Error(`Invalid project path parameter: ${options.project}`));
+    }
+
+    options = util.normalizeModuleOptions(options);
+    return tmp.fileAsync().then(outputPath => {
+      options.outputPath = outputPath;
+      return run.start(options).then(failedTests => {
+        return fs.readJsonAsync(outputPath, {
+          throws: false
+        }).then(output => {
+          if (!output) {
+            return {
+              status: 'failed',
+              failures: failedTests,
+              message: 'Could not find Cypress test run results'
+            };
+          }
+
+          return output;
+        });
+      });
+    });
+  },
+
+  cli: {
+    /**
+     * Parses CLI arguments into an object that you can pass to "cypress.run"
+     * @example
+     *  const cypress = require('cypress')
+     *  const cli = ['cypress', 'run', '--browser', 'firefox']
+     *  const options = await cypress.cli.parseRunArguments(cli)
+     *  // options is {browser: 'firefox'}
+     *  await cypress.run(options)
+     * @see https://on.cypress.io/module-api
+     */
+    parseRunArguments(args) {
+      return cli.parseRunCommand(args);
+    }
+
+  }
+};
+module.exports = cypressModuleApi;

node_modules/cypress/lib/errors.js

@@ -0,0 +1,392 @@
+"use strict";
+
+const chalk = require('chalk');
+
+const {
+  stripIndent,
+  stripIndents
+} = require('common-tags');
+
+const {
+  merge
+} = require('ramda');
+
+const la = require('lazy-ass');
+
+const is = require('check-more-types');
+
+const util = require('./util');
+
+const state = require('./tasks/state');
+
+const docsUrl = 'https://on.cypress.io';
+const requiredDependenciesUrl = `${docsUrl}/required-dependencies`;
+const runDocumentationUrl = `${docsUrl}/cypress-run`; // TODO it would be nice if all error objects could be enforced via types
+// to only have description + solution properties
+
+const hr = '----------';
+const genericErrorSolution = stripIndent`
+  Search for an existing issue or open a GitHub issue at
+
+    ${chalk.blue(util.issuesUrl)}
+`; // common errors Cypress application can encounter
+
+const unknownError = {
+  description: 'Unknown Cypress CLI error',
+  solution: genericErrorSolution
+};
+const invalidRunProjectPath = {
+  description: 'Invalid --project path',
+  solution: stripIndent`
+    Please provide a valid project path.
+
+    Learn more about ${chalk.cyan('cypress run')} at:
+
+      ${chalk.blue(runDocumentationUrl)}
+  `
+};
+const failedDownload = {
+  description: 'The Cypress App could not be downloaded.',
+  solution: stripIndent`
+  Does your workplace require a proxy to be used to access the Internet? If so, you must configure the HTTP_PROXY environment variable before downloading Cypress. Read more: https://on.cypress.io/proxy-configuration
+
+  Otherwise, please check network connectivity and try again:`
+};
+const failedUnzip = {
+  description: 'The Cypress App could not be unzipped.',
+  solution: genericErrorSolution
+};
+
+const missingApp = binaryDir => {
+  return {
+    description: `No version of Cypress is installed in: ${chalk.cyan(binaryDir)}`,
+    solution: stripIndent`
+    \nPlease reinstall Cypress by running: ${chalk.cyan('cypress install')}
+  `
+  };
+};
+
+const binaryNotExecutable = executable => {
+  return {
+    description: `Cypress cannot run because this binary file does not have executable permissions here:\n\n${executable}`,
+    solution: stripIndent`\n
+    Reasons this may happen:
+
+    - node was installed as 'root' or with 'sudo'
+    - the cypress npm package as 'root' or with 'sudo'
+
+    Please check that you have the appropriate user permissions.
+
+    You can also try clearing the cache with 'cypress cache clear' and reinstalling. 
+  `
+  };
+};
+
+const notInstalledCI = executable => {
+  return {
+    description: 'The cypress npm package is installed, but the Cypress binary is missing.',
+    solution: stripIndent`\n
+    We expected the binary to be installed here: ${chalk.cyan(executable)}
+
+    Reasons it may be missing:
+
+    - You're caching 'node_modules' but are not caching this path: ${util.getCacheDir()}
+    - You ran 'npm install' at an earlier build step but did not persist: ${util.getCacheDir()}
+
+    Properly caching the binary will fix this error and avoid downloading and unzipping Cypress.
+
+    Alternatively, you can run 'cypress install' to download the binary again.
+
+    ${chalk.blue('https://on.cypress.io/not-installed-ci-error')}
+  `
+  };
+};
+
+const nonZeroExitCodeXvfb = {
+  description: 'Xvfb exited with a non zero exit code.',
+  solution: stripIndent`
+    There was a problem spawning Xvfb.
+
+    This is likely a problem with your system, permissions, or installation of Xvfb.
+    `
+};
+const missingXvfb = {
+  description: 'Your system is missing the dependency: Xvfb',
+  solution: stripIndent`
+    Install Xvfb and run Cypress again.
+
+    Read our documentation on dependencies for more information:
+
+      ${chalk.blue(requiredDependenciesUrl)}
+
+    If you are using Docker, we provide containers with all required dependencies installed.
+    `
+};
+
+const smokeTestFailure = (smokeTestCommand, timedOut) => {
+  return {
+    description: `Cypress verification ${timedOut ? 'timed out' : 'failed'}.`,
+    solution: stripIndent`
+    This command failed with the following output:
+
+    ${smokeTestCommand}
+
+    `
+  };
+};
+
+const invalidSmokeTestDisplayError = {
+  code: 'INVALID_SMOKE_TEST_DISPLAY_ERROR',
+  description: 'Cypress verification failed.',
+
+  solution(msg) {
+    return stripIndent`
+      Cypress failed to start after spawning a new Xvfb server.
+
+      The error logs we received were:
+
+      ${hr}
+
+      ${msg}
+
+      ${hr}
+
+      This may be due to a missing library or dependency. ${chalk.blue(requiredDependenciesUrl)}
+
+      Please refer to the error above for more detail.
+    `;
+  }
+
+};
+const missingDependency = {
+  description: 'Cypress failed to start.',
+  // this message is too Linux specific
+  solution: stripIndent`
+    This may be due to a missing library or dependency. ${chalk.blue(requiredDependenciesUrl)}
+
+    Please refer to the error below for more details.
+  `
+};
+const invalidCacheDirectory = {
+  description: 'Cypress cannot write to the cache directory due to file permissions',
+  solution: stripIndent`
+    See discussion and possible solutions at
+    ${chalk.blue(util.getGitHubIssueUrl(1281))}
+  `
+};
+const versionMismatch = {
+  description: 'Installed version does not match package version.',
+  solution: 'Install Cypress and verify app again'
+};
+const incompatibleHeadlessFlags = {
+  description: '`--headed` and `--headless` cannot both be passed.',
+  solution: 'Either pass `--headed` or `--headless`, but not both.'
+};
+const solutionUnknown = stripIndent`
+  Please search Cypress documentation for possible solutions:
+
+    ${chalk.blue(docsUrl)}
+
+  Check if there is a GitHub issue describing this crash:
+
+    ${chalk.blue(util.issuesUrl)}
+
+  Consider opening a new issue.
+`;
+const unexpected = {
+  description: 'An unexpected error occurred while verifying the Cypress executable.',
+  solution: solutionUnknown
+};
+const invalidCypressEnv = {
+  description: chalk.red('The environment variable with the reserved name "CYPRESS_INTERNAL_ENV" is set.'),
+  solution: chalk.red('Unset the "CYPRESS_INTERNAL_ENV" environment variable and run Cypress again.'),
+  exitCode: 11
+};
+const invalidTestingType = {
+  description: 'Invalid testingType',
+  solution: `Please provide a valid testingType. Valid test types are ${chalk.cyan('\'e2e\'')} and ${chalk.cyan('\'component\'')}.`
+};
+/**
+ * This error happens when CLI detects that the child Test Runner process
+ * was killed with a signal, like SIGBUS
+ * @see https://github.com/cypress-io/cypress/issues/5808
+ * @param {'close'|'event'} eventName Child close event name
+ * @param {string} signal Signal that closed the child process, like "SIGBUS"
+*/
+
+const childProcessKilled = (eventName, signal) => {
+  return {
+    description: `The Test Runner unexpectedly exited via a ${chalk.cyan(eventName)} event with signal ${chalk.cyan(signal)}`,
+    solution: solutionUnknown
+  };
+};
+
+const CYPRESS_RUN_BINARY = {
+  notValid: value => {
+    const properFormat = `**/${state.getPlatformExecutable()}`;
+    return {
+      description: `Could not run binary set by environment variable: CYPRESS_RUN_BINARY=${value}`,
+      solution: `Ensure the environment variable is a path to the Cypress binary, matching ${properFormat}`
+    };
+  }
+};
+
+function addPlatformInformation(info) {
+  return util.getPlatformInfo().then(platform => {
+    return merge(info, {
+      platform
+    });
+  });
+}
+/**
+ * Given an error object (see the errors above), forms error message text with details,
+ * then resolves with Error instance you can throw or reject with.
+ * @param {object} errorObject
+ * @returns {Promise<Error>} resolves with an Error
+ * @example
+  ```js
+  // inside a Promise with "resolve" and "reject"
+  const errorObject = childProcessKilled('exit', 'SIGKILL')
+  return getError(errorObject).then(reject)
+  ```
+ */
+
+
+function getError(errorObject) {
+  return formErrorText(errorObject).then(errorMessage => {
+    const err = new Error(errorMessage);
+    err.known = true;
+    return err;
+  });
+}
+/**
+ * Forms nice error message with error and platform information,
+ * and if possible a way to solve it. Resolves with a string.
+ */
+
+
+function formErrorText(info, msg, prevMessage) {
+  return addPlatformInformation(info).then(obj => {
+    const formatted = [];
+
+    function add(msg) {
+      formatted.push(stripIndents(msg));
+    }
+
+    la(is.unemptyString(obj.description), 'expected error description to be text', obj.description); // assuming that if there the solution is a function it will handle
+    // error message and (optional previous error message)
+
+    if (is.fn(obj.solution)) {
+      const text = obj.solution(msg, prevMessage);
+      la(is.unemptyString(text), 'expected solution to be text', text);
+      add(`
+        ${obj.description}
+
+        ${text}
+
+      `);
+    } else {
+      la(is.unemptyString(obj.solution), 'expected error solution to be text', obj.solution);
+      add(`
+        ${obj.description}
+
+        ${obj.solution}
+
+      `);
+
+      if (msg) {
+        add(`
+          ${hr}
+
+          ${msg}
+
+        `);
+      }
+    }
+
+    add(`
+      ${hr}
+
+      ${obj.platform}
+    `);
+
+    if (obj.footer) {
+      add(`
+
+        ${hr}
+
+        ${obj.footer}
+      `);
+    }
+
+    return formatted.join('\n\n');
+  });
+}
+
+const raise = info => {
+  return text => {
+    const err = new Error(text);
+
+    if (info.code) {
+      err.code = info.code;
+    }
+
+    err.known = true;
+    throw err;
+  };
+};
+
+const throwFormErrorText = info => {
+  return (msg, prevMessage) => {
+    return formErrorText(info, msg, prevMessage).then(raise(info));
+  };
+};
+/**
+ * Forms full error message with error and OS details, prints to the error output
+ * and then exits the process.
+ * @param {ErrorInformation} info Error information {description, solution}
+ * @example return exitWithError(errors.invalidCypressEnv)('foo')
+ */
+
+
+const exitWithError = info => {
+  return msg => {
+    return formErrorText(info, msg).then(text => {
+      // eslint-disable-next-line no-console
+      console.error(text);
+      process.exit(info.exitCode || 1);
+    });
+  };
+};
+
+module.exports = {
+  raise,
+  exitWithError,
+  // formError,
+  formErrorText,
+  throwFormErrorText,
+  getError,
+  hr,
+  errors: {
+    unknownError,
+    nonZeroExitCodeXvfb,
+    missingXvfb,
+    missingApp,
+    notInstalledCI,
+    missingDependency,
+    invalidSmokeTestDisplayError,
+    versionMismatch,
+    binaryNotExecutable,
+    unexpected,
+    failedDownload,
+    failedUnzip,
+    invalidCypressEnv,
+    invalidCacheDirectory,
+    CYPRESS_RUN_BINARY,
+    smokeTestFailure,
+    childProcessKilled,
+    incompatibleHeadlessFlags,
+    invalidRunProjectPath,
+    invalidTestingType
+  }
+};

node_modules/cypress/lib/exec/info.js

@@ -0,0 +1,96 @@
+"use strict";
+
+/* eslint-disable no-console */
+const spawn = require('./spawn');
+
+const util = require('../util');
+
+const state = require('../tasks/state');
+
+const os = require('os');
+
+const chalk = require('chalk');
+
+const prettyBytes = require('pretty-bytes');
+
+const _ = require('lodash');
+
+const R = require('ramda'); // color for numbers and show values
+
+
+const g = chalk.green; // color for paths
+
+const p = chalk.cyan; // urls
+
+const link = chalk.blue.underline; // to be exported
+
+const methods = {};
+
+methods.findProxyEnvironmentVariables = () => {
+  return _.pick(process.env, ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY']);
+};
+
+const maskSensitiveVariables = R.evolve({
+  CYPRESS_RECORD_KEY: R.always('<redacted>')
+});
+
+methods.findCypressEnvironmentVariables = () => {
+  const isCyVariable = (val, key) => key.startsWith('CYPRESS_');
+
+  return R.pickBy(isCyVariable)(process.env);
+};
+
+const formatCypressVariables = () => {
+  const vars = methods.findCypressEnvironmentVariables();
+  return maskSensitiveVariables(vars);
+};
+
+methods.start = (options = {}) => {
+  const args = ['--mode=info'];
+  return spawn.start(args, {
+    dev: options.dev
+  }).then(() => {
+    console.log();
+    const proxyVars = methods.findProxyEnvironmentVariables();
+
+    if (_.isEmpty(proxyVars)) {
+      console.log('Proxy Settings: none detected');
+    } else {
+      console.log('Proxy Settings:');
+
+      _.forEach(proxyVars, (value, key) => {
+        console.log('%s: %s', key, g(value));
+      });
+
+      console.log();
+      console.log('Learn More: %s', link('https://on.cypress.io/proxy-configuration'));
+      console.log();
+    }
+  }).then(() => {
+    const cyVars = formatCypressVariables();
+
+    if (_.isEmpty(cyVars)) {
+      console.log('Environment Variables: none detected');
+    } else {
+      console.log('Environment Variables:');
+
+      _.forEach(cyVars, (value, key) => {
+        console.log('%s: %s', key, g(value));
+      });
+    }
+  }).then(() => {
+    console.log();
+    console.log('Application Data:', p(util.getApplicationDataFolder()));
+    console.log('Browser Profiles:', p(util.getApplicationDataFolder('browsers')));
+    console.log('Binary Caches: %s', p(state.getCacheDir()));
+  }).then(() => {
+    console.log();
+    return util.getOsVersionAsync().then(osVersion => {
+      console.log('Cypress Version: %s', g(util.pkgVersion()));
+      console.log('System Platform: %s (%s)', g(os.platform()), g(osVersion));
+      console.log('System Memory: %s free %s', g(prettyBytes(os.totalmem())), g(prettyBytes(os.freemem())));
+    });
+  });
+};
+
+module.exports = methods;

node_modules/cypress/lib/exec/open.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const debug = require('debug')('cypress:cli');
+
+const util = require('../util');
+
+const spawn = require('./spawn');
+
+const verify = require('../tasks/verify');
+
+const {
+  processTestingType
+} = require('./shared');
+
+module.exports = {
+  start(options = {}) {
+    if (!util.isInstalledGlobally() && !options.global && !options.project) {
+      options.project = process.cwd();
+    }
+
+    const args = [];
+
+    if (options.config) {
+      args.push('--config', options.config);
+    }
+
+    if (options.configFile !== undefined) {
+      args.push('--config-file', options.configFile);
+    }
+
+    if (options.browser) {
+      args.push('--browser', options.browser);
+    }
+
+    if (options.env) {
+      args.push('--env', options.env);
+    }
+
+    if (options.port) {
+      args.push('--port', options.port);
+    }
+
+    if (options.project) {
+      args.push('--project', options.project);
+    }
+
+    args.push(...processTestingType(options.testingType));
+    debug('opening from options %j', options);
+    debug('command line arguments %j', args);
+
+    function open() {
+      return spawn.start(args, {
+        dev: options.dev,
+        detached: Boolean(options.detached),
+        stdio: 'inherit'
+      });
+    }
+
+    if (options.dev) {
+      return open();
+    }
+
+    return verify.start().then(open);
+  }
+
+};

node_modules/cypress/lib/exec/run.js

@@ -0,0 +1,200 @@
+"use strict";
+
+const _ = require('lodash');
+
+const debug = require('debug')('cypress:cli:run');
+
+const util = require('../util');
+
+const spawn = require('./spawn');
+
+const verify = require('../tasks/verify');
+
+const {
+  exitWithError,
+  errors
+} = require('../errors');
+
+const {
+  processTestingType,
+  throwInvalidOptionError
+} = require('./shared');
+/**
+ * Typically a user passes a string path to the project.
+ * But "cypress open" allows using `false` to open in global mode,
+ * and the user can accidentally execute `cypress run --project false`
+ * which should be invalid.
+ */
+
+
+const isValidProject = v => {
+  if (typeof v === 'boolean') {
+    return false;
+  }
+
+  if (v === '' || v === 'false' || v === 'true') {
+    return false;
+  }
+
+  return true;
+};
+/**
+ * Maps options collected by the CLI
+ * and forms list of CLI arguments to the server.
+ *
+ * Note: there is lightweight validation, with errors
+ * thrown synchronously.
+ *
+ * @returns {string[]} list of CLI arguments
+ */
+
+
+const processRunOptions = (options = {}) => {
+  debug('processing run options %o', options);
+
+  if (!isValidProject(options.project)) {
+    debug('invalid project option %o', {
+      project: options.project
+    });
+    return throwInvalidOptionError(errors.invalidRunProjectPath);
+  }
+
+  const args = ['--run-project', options.project];
+
+  if (options.browser) {
+    args.push('--browser', options.browser);
+  }
+
+  if (options.ciBuildId) {
+    args.push('--ci-build-id', options.ciBuildId);
+  }
+
+  if (options.config) {
+    args.push('--config', options.config);
+  }
+
+  if (options.configFile !== undefined) {
+    args.push('--config-file', options.configFile);
+  }
+
+  if (options.env) {
+    args.push('--env', options.env);
+  }
+
+  if (options.exit === false) {
+    args.push('--no-exit');
+  }
+
+  if (options.group) {
+    args.push('--group', options.group);
+  }
+
+  if (options.headed) {
+    args.push('--headed', options.headed);
+  }
+
+  if (options.headless) {
+    if (options.headed) {
+      return throwInvalidOptionError(errors.incompatibleHeadlessFlags);
+    }
+
+    args.push('--headed', !options.headless);
+  } // if key is set use that - else attempt to find it by environment variable
+
+
+  if (options.key == null) {
+    debug('--key is not set, looking up environment variable CYPRESS_RECORD_KEY');
+    options.key = util.getEnv('CYPRESS_RECORD_KEY');
+  } // if we have a key assume we're in record mode
+
+
+  if (options.key) {
+    args.push('--key', options.key);
+  }
+
+  if (options.outputPath) {
+    args.push('--output-path', options.outputPath);
+  }
+
+  if (options.parallel) {
+    args.push('--parallel');
+  }
+
+  if (options.port) {
+    args.push('--port', options.port);
+  }
+
+  if (options.quiet) {
+    args.push('--quiet');
+  } // if record is defined and we're not
+  // already in ci mode, then send it up
+
+
+  if (options.record != null) {
+    args.push('--record', options.record);
+  } // if we have a specific reporter push that into the args
+
+
+  if (options.reporter) {
+    args.push('--reporter', options.reporter);
+  } // if we have a specific reporter push that into the args
+
+
+  if (options.reporterOptions) {
+    args.push('--reporter-options', options.reporterOptions);
+  } // if we have specific spec(s) push that into the args
+
+
+  if (options.spec) {
+    args.push('--spec', options.spec);
+  }
+
+  if (options.tag) {
+    args.push('--tag', options.tag);
+  }
+
+  args.push(...processTestingType(options.testingType));
+  return args;
+};
+
+module.exports = {
+  processRunOptions,
+  isValidProject,
+
+  // resolves with the number of failed tests
+  start(options = {}) {
+    _.defaults(options, {
+      key: null,
+      spec: null,
+      reporter: null,
+      reporterOptions: null,
+      project: process.cwd()
+    });
+
+    function run() {
+      let args;
+
+      try {
+        args = processRunOptions(options);
+      } catch (err) {
+        if (err.details) {
+          return exitWithError(err.details)();
+        }
+
+        throw err;
+      }
+
+      debug('run to spawn.start args %j', args);
+      return spawn.start(args, {
+        dev: options.dev
+      });
+    }
+
+    if (options.dev) {
+      return run();
+    }
+
+    return verify.start().then(run);
+  }
+
+};

node_modules/cypress/lib/exec/shared.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const {
+  errors
+} = require('../errors');
+/**
+ * Throws an error with "details" property from
+ * "errors" object.
+ * @param {Object} details - Error details
+ */
+
+
+const throwInvalidOptionError = details => {
+  if (!details) {
+    details = errors.unknownError;
+  } // throw this error synchronously, it will be caught later on and
+  // the details will be propagated to the promise chain
+
+
+  const err = new Error();
+  err.details = details;
+  throw err;
+};
+/**
+ * Selects exec args based on the configured `testingType`
+ * @param {string} testingType The type of tests being executed
+ * @returns {string[]} The array of new exec arguments
+ */
+
+
+const processTestingType = testingType => {
+  if (testingType) {
+    if (testingType === 'e2e') {
+      return ['--testing-type', 'e2e'];
+    }
+
+    if (testingType === 'component') {
+      return ['--testing-type', 'component'];
+    }
+
+    return throwInvalidOptionError(errors.invalidTestingType);
+  }
+
+  return [];
+};
+
+module.exports = {
+  throwInvalidOptionError,
+  processTestingType
+};

node_modules/cypress/lib/exec/spawn.js

@@ -0,0 +1,299 @@
+"use strict";
+
+const _ = require('lodash');
+
+const os = require('os');
+
+const cp = require('child_process');
+
+const path = require('path');
+
+const Promise = require('bluebird');
+
+const debug = require('debug')('cypress:cli');
+
+const debugElectron = require('debug')('cypress:electron');
+
+const util = require('../util');
+
+const state = require('../tasks/state');
+
+const xvfb = require('./xvfb');
+
+const verify = require('../tasks/verify');
+
+const errors = require('../errors');
+
+const isXlibOrLibudevRe = /^(?:Xlib|libudev)/;
+const isHighSierraWarningRe = /\*\*\* WARNING/;
+const isRenderWorkerRe = /\.RenderWorker-/;
+const GARBAGE_WARNINGS = [isXlibOrLibudevRe, isHighSierraWarningRe, isRenderWorkerRe];
+
+const isGarbageLineWarning = str => {
+  return _.some(GARBAGE_WARNINGS, re => {
+    return re.test(str);
+  });
+};
+
+function isPlatform(platform) {
+  return os.platform() === platform;
+}
+
+function needsStderrPiped(needsXvfb) {
+  return _.some([isPlatform('darwin'), needsXvfb && isPlatform('linux'), util.isPossibleLinuxWithIncorrectDisplay()]);
+}
+
+function needsEverythingPipedDirectly() {
+  return isPlatform('win32');
+}
+
+function getStdio(needsXvfb) {
+  if (needsEverythingPipedDirectly()) {
+    return 'pipe';
+  } // https://github.com/cypress-io/cypress/issues/921
+  // https://github.com/cypress-io/cypress/issues/1143
+  // https://github.com/cypress-io/cypress/issues/1745
+
+
+  if (needsStderrPiped(needsXvfb)) {
+    // returning pipe here so we can massage stderr
+    // and remove garbage from Xlib and libuv
+    // due to starting the Xvfb process on linux
+    return ['inherit', 'inherit', 'pipe'];
+  }
+
+  return 'inherit';
+}
+
+module.exports = {
+  isGarbageLineWarning,
+
+  start(args, options = {}) {
+    const needsXvfb = xvfb.isNeeded();
+    let executable = state.getPathToExecutable(state.getBinaryDir());
+
+    if (util.getEnv('CYPRESS_RUN_BINARY')) {
+      executable = path.resolve(util.getEnv('CYPRESS_RUN_BINARY'));
+    }
+
+    debug('needs to start own Xvfb?', needsXvfb); // Always push cwd into the args
+    // which additionally acts as a signal to the
+    // binary that it was invoked through the NPM module
+
+    args = args || [];
+
+    if (typeof args === 'string') {
+      args = [args];
+    }
+
+    args = [...args, '--cwd', process.cwd()];
+
+    _.defaults(options, {
+      dev: false,
+      env: process.env,
+      detached: false,
+      stdio: getStdio(needsXvfb)
+    });
+
+    const spawn = (overrides = {}) => {
+      return new Promise((resolve, reject) => {
+        _.defaults(overrides, {
+          onStderrData: false,
+          electronLogging: false
+        });
+
+        const {
+          onStderrData,
+          electronLogging
+        } = overrides;
+        const envOverrides = util.getEnvOverrides(options);
+        const electronArgs = [];
+        const node11WindowsFix = isPlatform('win32');
+
+        if (options.dev) {
+          // if we're in dev then reset
+          // the launch cmd to be 'npm run dev'
+          executable = 'node';
+          electronArgs.unshift(path.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js'));
+          debug('in dev mode the args became %o', args);
+        }
+
+        if (!options.dev && verify.needsSandbox()) {
+          electronArgs.push('--no-sandbox');
+        } // strip dev out of child process options
+
+
+        let stdioOptions = _.pick(options, 'env', 'detached', 'stdio'); // figure out if we're going to be force enabling or disabling colors.
+        // also figure out whether we should force stdout and stderr into thinking
+        // it is a tty as opposed to a pipe.
+
+
+        stdioOptions.env = _.extend({}, stdioOptions.env, envOverrides);
+
+        if (node11WindowsFix) {
+          stdioOptions = _.extend({}, stdioOptions, {
+            windowsHide: false
+          });
+        }
+
+        if (electronLogging) {
+          stdioOptions.env.ELECTRON_ENABLE_LOGGING = true;
+        }
+
+        if (util.isPossibleLinuxWithIncorrectDisplay()) {
+          // make sure we use the latest DISPLAY variable if any
+          debug('passing DISPLAY', process.env.DISPLAY);
+          stdioOptions.env.DISPLAY = process.env.DISPLAY;
+        }
+
+        if (stdioOptions.env.ELECTRON_RUN_AS_NODE) {
+          // Since we are running electron as node, we need to add an entry point file.
+          const serverEntryPoint = path.join(state.getBinaryPkgPath(path.dirname(executable)), '..', 'index.js');
+          args = [serverEntryPoint, ...args];
+        } else {
+          // Start arguments with "--" so Electron knows these are OUR
+          // arguments and does not try to sanitize them. Otherwise on Windows
+          // an url in one of the arguments crashes it :(
+          // https://github.com/cypress-io/cypress/issues/5466
+          args = [...electronArgs, '--', ...args];
+        }
+
+        debug('spawning Cypress with executable: %s', executable);
+        debug('spawn args %o %o', args, _.omit(stdioOptions, 'env'));
+        const child = cp.spawn(executable, args, stdioOptions);
+
+        function resolveOn(event) {
+          return function (code, signal) {
+            debug('child event fired %o', {
+              event,
+              code,
+              signal
+            });
+
+            if (code === null) {
+              const errorObject = errors.errors.childProcessKilled(event, signal);
+              return errors.getError(errorObject).then(reject);
+            }
+
+            resolve(code);
+          };
+        }
+
+        child.on('close', resolveOn('close'));
+        child.on('exit', resolveOn('exit'));
+        child.on('error', reject); // if stdio options is set to 'pipe', then
+        //   we should set up pipes:
+        //  process STDIN (read stream) => child STDIN (writeable)
+        //  child STDOUT => process STDOUT
+        //  child STDERR => process STDERR with additional filtering
+
+        if (child.stdin) {
+          debug('piping process STDIN into child STDIN');
+          process.stdin.pipe(child.stdin);
+        }
+
+        if (child.stdout) {
+          debug('piping child STDOUT to process STDOUT');
+          child.stdout.pipe(process.stdout);
+        } // if this is defined then we are manually piping for linux
+        // to filter out the garbage
+
+
+        if (child.stderr) {
+          debug('piping child STDERR to process STDERR');
+          child.stderr.on('data', data => {
+            const str = data.toString(); // bail if this is warning line garbage
+
+            if (isGarbageLineWarning(str)) {
+              return;
+            } // if we have a callback and this explictly returns
+            // false then bail
+
+
+            if (onStderrData && onStderrData(str) === false) {
+              return;
+            } // else pass it along!
+
+
+            process.stderr.write(data);
+          });
+        } // https://github.com/cypress-io/cypress/issues/1841
+        // https://github.com/cypress-io/cypress/issues/5241
+        // In some versions of node, it will throw on windows
+        // when you close the parent process after piping
+        // into the child process. unpiping does not seem
+        // to have any effect. so we're just catching the
+        // error here and not doing anything.
+
+
+        process.stdin.on('error', err => {
+          if (['EPIPE', 'ENOTCONN'].includes(err.code)) {
+            return;
+          }
+
+          throw err;
+        });
+
+        if (stdioOptions.detached) {
+          child.unref();
+        }
+      });
+    };
+
+    const spawnInXvfb = () => {
+      return xvfb.start().then(userFriendlySpawn).finally(xvfb.stop);
+    };
+
+    const userFriendlySpawn = linuxWithDisplayEnv => {
+      debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
+      let brokenGtkDisplay;
+      const overrides = {};
+
+      if (linuxWithDisplayEnv) {
+        _.extend(overrides, {
+          electronLogging: true,
+
+          onStderrData(str) {
+            // if we receive a broken pipe anywhere
+            // then we know that's why cypress exited early
+            if (util.isBrokenGtkDisplay(str)) {
+              brokenGtkDisplay = true;
+            } // we should attempt to always slurp up
+            // the stderr logs unless we've explicitly
+            // enabled the electron debug logging
+
+
+            if (!debugElectron.enabled) {
+              return false;
+            }
+          }
+
+        });
+      }
+
+      return spawn(overrides).then(code => {
+        if (code !== 0 && brokenGtkDisplay) {
+          util.logBrokenGtkDisplayWarning();
+          return spawnInXvfb();
+        }
+
+        return code;
+      }) // we can format and handle an error message from the code above
+      // prevent wrapping error again by using "known: undefined" filter
+      .catch({
+        known: undefined
+      }, errors.throwFormErrorText(errors.errors.unexpected));
+    };
+
+    if (needsXvfb) {
+      return spawnInXvfb();
+    } // if we are on linux and there's already a DISPLAY
+    // set, then we may need to rerun cypress after
+    // spawning our own Xvfb server
+
+
+    const linuxWithDisplayEnv = util.isPossibleLinuxWithIncorrectDisplay();
+    return userFriendlySpawn(linuxWithDisplayEnv);
+  }
+
+};

node_modules/cypress/lib/exec/versions.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const Promise = require('bluebird');
+
+const debug = require('debug')('cypress:cli');
+
+const path = require('path');
+
+const util = require('../util');
+
+const state = require('../tasks/state');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const getVersions = () => {
+  return Promise.try(() => {
+    if (util.getEnv('CYPRESS_RUN_BINARY')) {
+      let envBinaryPath = path.resolve(util.getEnv('CYPRESS_RUN_BINARY'));
+      return state.parseRealPlatformBinaryFolderAsync(envBinaryPath).then(envBinaryDir => {
+        if (!envBinaryDir) {
+          return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))();
+        }
+
+        debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
+        return envBinaryDir;
+      }).catch({
+        code: 'ENOENT'
+      }, err => {
+        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(err.message);
+      });
+    }
+
+    return state.getBinaryDir();
+  }).then(state.getBinaryPkgAsync).then(pkg => {
+    const versions = {
+      binary: state.getBinaryPkgVersion(pkg),
+      electronVersion: state.getBinaryElectronVersion(pkg),
+      electronNodeVersion: state.getBinaryElectronNodeVersion(pkg)
+    };
+    debug('binary versions %o', versions);
+    return versions;
+  }).then(binaryVersions => {
+    const versions = {
+      package: util.pkgVersion(),
+      binary: binaryVersions.binary || 'not installed',
+      electronVersion: binaryVersions.electronVersion || 'not found',
+      electronNodeVersion: binaryVersions.electronNodeVersion || 'not found'
+    };
+    debug('combined versions %o', versions);
+    return versions;
+  });
+};
+
+module.exports = {
+  getVersions
+};

node_modules/cypress/lib/exec/xvfb.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const os = require('os');
+
+const Promise = require('bluebird');
+
+const Xvfb = require('@cypress/xvfb');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const Debug = require('debug');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const util = require('../util');
+
+const debug = Debug('cypress:cli');
+const debugXvfb = Debug('cypress:xvfb');
+debug.Debug = debugXvfb.Debug = Debug;
+const xvfbOptions = {
+  timeout: 30000,
+  // milliseconds
+  // need to explicitly define screen otherwise electron will crash
+  // https://github.com/cypress-io/cypress/issues/6184
+  xvfb_args: ['-screen', '0', '1280x1024x24'],
+
+  onStderrData(data) {
+    if (debugXvfb.enabled) {
+      debugXvfb(data.toString());
+    }
+  }
+
+};
+const xvfb = Promise.promisifyAll(new Xvfb(xvfbOptions));
+module.exports = {
+  _debugXvfb: debugXvfb,
+  // expose for testing
+  _xvfb: xvfb,
+  // expose for testing
+  _xvfbOptions: xvfbOptions,
+
+  // expose for testing
+  start() {
+    debug('Starting Xvfb');
+    return xvfb.startAsync().return(null).catch({
+      nonZeroExitCode: true
+    }, throwFormErrorText(errors.nonZeroExitCodeXvfb)).catch(err => {
+      if (err.known) {
+        throw err;
+      }
+
+      return throwFormErrorText(errors.missingXvfb)(err);
+    });
+  },
+
+  stop() {
+    debug('Stopping Xvfb');
+    return xvfb.stopAsync().return(null).catch(() => {// noop
+    });
+  },
+
+  isNeeded() {
+    if (process.env.ELECTRON_RUN_AS_NODE) {
+      debug('Environment variable ELECTRON_RUN_AS_NODE detected, xvfb is not needed');
+      return false; // xvfb required for electron processes only.
+    }
+
+    if (os.platform() !== 'linux') {
+      return false;
+    }
+
+    if (process.env.DISPLAY) {
+      const issueUrl = util.getGitHubIssueUrl(4034);
+      const message = stripIndent`
+        DISPLAY environment variable is set to ${process.env.DISPLAY} on Linux
+        Assuming this DISPLAY points at working X11 server,
+        Cypress will not spawn own Xvfb
+
+        NOTE: if the X11 server is NOT working, Cypress will exit without explanation,
+          see ${issueUrl}
+        Solution: Unset the DISPLAY variable and try again:
+          DISPLAY= npx cypress run ...
+      `;
+      debug(message);
+      return false;
+    }
+
+    debug('undefined DISPLAY environment variable');
+    debug('Cypress will spawn its own Xvfb');
+    return true;
+  },
+
+  // async method, resolved with Boolean
+  verify() {
+    return xvfb.startAsync().return(true).catch(err => {
+      debug('Could not verify xvfb: %s', err.message);
+      return false;
+    }).finally(xvfb.stopAsync);
+  }
+
+};

node_modules/cypress/lib/fs.js

@@ -0,0 +1,5 @@
+"use strict";
+
+const Promise = require('bluebird');
+
+module.exports = Promise.promisifyAll(require('fs-extra'));

node_modules/cypress/lib/logger.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const R = require('ramda');
+
+const chalk = require('chalk');
+
+let logs = [];
+
+const logLevel = () => {
+  return process.env.npm_config_loglevel || 'notice';
+};
+
+const error = (...messages) => {
+  logs.push(messages.join(' '));
+  console.log(chalk.red(...messages)); // eslint-disable-line no-console
+};
+
+const warn = (...messages) => {
+  if (logLevel() === 'silent') return;
+  logs.push(messages.join(' '));
+  console.log(chalk.yellow(...messages)); // eslint-disable-line no-console
+};
+
+const log = (...messages) => {
+  if (logLevel() === 'silent' || logLevel() === 'warn') return;
+  logs.push(messages.join(' '));
+  console.log(...messages); // eslint-disable-line no-console
+};
+
+const always = (...messages) => {
+  logs.push(messages.join(' '));
+  console.log(...messages); // eslint-disable-line no-console
+}; // splits long text into lines and calls log()
+// on each one to allow easy unit testing for specific message
+
+
+const logLines = text => {
+  const lines = text.split('\n');
+  R.forEach(log, lines);
+};
+
+const print = () => {
+  return logs.join('\n');
+};
+
+const reset = () => {
+  logs = [];
+};
+
+module.exports = {
+  log,
+  warn,
+  error,
+  always,
+  logLines,
+  print,
+  reset,
+  logLevel
+};

node_modules/cypress/lib/tasks/cache.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const state = require('./state');
+
+const logger = require('../logger');
+
+const fs = require('../fs');
+
+const util = require('../util');
+
+const {
+  join
+} = require('path');
+
+const Table = require('cli-table3');
+
+const dayjs = require('dayjs');
+
+const relativeTime = require('dayjs/plugin/relativeTime');
+
+const chalk = require('chalk');
+
+const _ = require('lodash');
+
+const getFolderSize = require('./get-folder-size');
+
+const Bluebird = require('bluebird');
+
+dayjs.extend(relativeTime); // output colors for the table
+
+const colors = {
+  titles: chalk.white,
+  dates: chalk.cyan,
+  values: chalk.green,
+  size: chalk.gray
+};
+
+const logCachePath = () => {
+  logger.always(state.getCacheDir());
+  return undefined;
+};
+
+const clear = () => {
+  return fs.removeAsync(state.getCacheDir());
+};
+
+const prune = () => {
+  const cacheDir = state.getCacheDir();
+  const currentVersion = util.pkgVersion();
+  let deletedBinary = false;
+  return fs.readdirAsync(cacheDir).then(versions => {
+    return Bluebird.all(versions.map(version => {
+      if (version !== currentVersion) {
+        deletedBinary = true;
+        const versionDir = join(cacheDir, version);
+        return fs.removeAsync(versionDir);
+      }
+    }));
+  }).then(() => {
+    if (deletedBinary) {
+      logger.always(`Deleted all binary caches except for the ${currentVersion} binary cache.`);
+    } else {
+      logger.always(`No binary caches found to prune.`);
+    }
+  }).catch({
+    code: 'ENOENT'
+  }, () => {
+    logger.always(`No Cypress cache was found at ${cacheDir}. Nothing to prune.`);
+  });
+};
+
+const fileSizeInMB = size => {
+  return `${(size / 1024 / 1024).toFixed(1)}MB`;
+};
+/**
+ * Collects all cached versions, finds when each was used
+ * and prints a table with results to the terminal
+ */
+
+
+const list = showSize => {
+  return getCachedVersions(showSize).then(binaries => {
+    const head = [colors.titles('version'), colors.titles('last used')];
+
+    if (showSize) {
+      head.push(colors.titles('size'));
+    }
+
+    const table = new Table({
+      head
+    });
+    binaries.forEach(binary => {
+      const versionString = colors.values(binary.version);
+      const lastUsed = binary.accessed ? colors.dates(binary.accessed) : 'unknown';
+      const row = [versionString, lastUsed];
+
+      if (showSize) {
+        const size = colors.size(fileSizeInMB(binary.size));
+        row.push(size);
+      }
+
+      return table.push(row);
+    });
+    logger.always(table.toString());
+  });
+};
+
+const getCachedVersions = showSize => {
+  const cacheDir = state.getCacheDir();
+  return fs.readdirAsync(cacheDir).filter(util.isSemver).map(version => {
+    return {
+      version,
+      folderPath: join(cacheDir, version)
+    };
+  }).mapSeries(binary => {
+    // last access time on the folder is different from last access time
+    // on the Cypress binary
+    const binaryDir = state.getBinaryDir(binary.version);
+    const executable = state.getPathToExecutable(binaryDir);
+    return fs.statAsync(executable).then(stat => {
+      const lastAccessedTime = _.get(stat, 'atime');
+
+      if (!lastAccessedTime) {
+        // the test runner has never been opened
+        // or could be a test simulating missing timestamp
+        return binary;
+      }
+
+      const accessed = dayjs(lastAccessedTime).fromNow();
+      binary.accessed = accessed;
+      return binary;
+    }, e => {
+      // could not find the binary or gets its stats
+      return binary;
+    });
+  }).mapSeries(binary => {
+    if (showSize) {
+      const binaryDir = state.getBinaryDir(binary.version);
+      return getFolderSize(binaryDir).then(size => {
+        return { ...binary,
+          size
+        };
+      });
+    }
+
+    return binary;
+  });
+};
+
+module.exports = {
+  path: logCachePath,
+  clear,
+  prune,
+  list,
+  getCachedVersions
+};

node_modules/cypress/lib/tasks/download.js

@@ -0,0 +1,343 @@
+"use strict";
+
+const arch = require('arch');
+
+const la = require('lazy-ass');
+
+const is = require('check-more-types');
+
+const os = require('os');
+
+const url = require('url');
+
+const path = require('path');
+
+const debug = require('debug')('cypress:cli');
+
+const request = require('@cypress/request');
+
+const Promise = require('bluebird');
+
+const requestProgress = require('request-progress');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const fs = require('../fs');
+
+const util = require('../util');
+
+const defaultBaseUrl = 'https://download.cypress.io/';
+
+const getProxyUrl = () => {
+  return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.npm_config_https_proxy || process.env.HTTP_PROXY || process.env.http_proxy || process.env.npm_config_proxy || null;
+};
+
+const getRealOsArch = () => {
+  // os.arch() returns the arch for which this node was compiled
+  // we want the operating system's arch instead: x64 or x86
+  const osArch = arch();
+
+  if (osArch === 'x86') {
+    // match process.platform output
+    return 'ia32';
+  }
+
+  return osArch;
+};
+
+const getBaseUrl = () => {
+  if (util.getEnv('CYPRESS_DOWNLOAD_MIRROR')) {
+    let baseUrl = util.getEnv('CYPRESS_DOWNLOAD_MIRROR');
+
+    if (!baseUrl.endsWith('/')) {
+      baseUrl += '/';
+    }
+
+    return baseUrl;
+  }
+
+  return defaultBaseUrl;
+};
+
+const getCA = () => {
+  return new Promise(resolve => {
+    if (!util.getEnv('CYPRESS_DOWNLOAD_USE_CA')) {
+      resolve();
+    }
+
+    if (process.env.npm_config_ca) {
+      resolve(process.env.npm_config_ca);
+    } else if (process.env.npm_config_cafile) {
+      fs.readFile(process.env.npm_config_cafile, 'utf8').then(cafileContent => {
+        resolve(cafileContent);
+      }).catch(() => {
+        resolve();
+      });
+    } else {
+      resolve();
+    }
+  });
+};
+
+const prepend = urlPath => {
+  const endpoint = url.resolve(getBaseUrl(), urlPath);
+  const platform = os.platform();
+  const arch = getRealOsArch();
+  return `${endpoint}?platform=${platform}&arch=${arch}`;
+};
+
+const getUrl = version => {
+  if (is.url(version)) {
+    debug('version is already an url', version);
+    return version;
+  }
+
+  return version ? prepend(`desktop/${version}`) : prepend('desktop');
+};
+
+const statusMessage = err => {
+  return err.statusCode ? [err.statusCode, err.statusMessage].join(' - ') : err.toString();
+};
+
+const prettyDownloadErr = (err, version) => {
+  const msg = stripIndent`
+    URL: ${getUrl(version)}
+    ${statusMessage(err)}
+  `;
+  debug(msg);
+  return throwFormErrorText(errors.failedDownload)(msg);
+};
+/**
+ * Checks checksum and file size for the given file. Allows both
+ * values or just one of them to be checked.
+ */
+
+
+const verifyDownloadedFile = (filename, expectedSize, expectedChecksum) => {
+  if (expectedSize && expectedChecksum) {
+    debug('verifying checksum and file size');
+    return Promise.join(util.getFileChecksum(filename), util.getFileSize(filename), (checksum, filesize) => {
+      if (checksum === expectedChecksum && filesize === expectedSize) {
+        debug('downloaded file has the expected checksum and size ✅');
+        return;
+      }
+
+      debug('raising error: checksum or file size mismatch');
+      const text = stripIndent`
+          Corrupted download
+
+          Expected downloaded file to have checksum: ${expectedChecksum}
+          Computed checksum: ${checksum}
+
+          Expected downloaded file to have size: ${expectedSize}
+          Computed size: ${filesize}
+        `;
+      debug(text);
+      throw new Error(text);
+    });
+  }
+
+  if (expectedChecksum) {
+    debug('only checking expected file checksum %d', expectedChecksum);
+    return util.getFileChecksum(filename).then(checksum => {
+      if (checksum === expectedChecksum) {
+        debug('downloaded file has the expected checksum ✅');
+        return;
+      }
+
+      debug('raising error: file checksum mismatch');
+      const text = stripIndent`
+        Corrupted download
+
+        Expected downloaded file to have checksum: ${expectedChecksum}
+        Computed checksum: ${checksum}
+      `;
+      throw new Error(text);
+    });
+  }
+
+  if (expectedSize) {
+    // maybe we don't have a checksum, but at least CDN returns content length
+    // which we can check against the file size
+    debug('only checking expected file size %d', expectedSize);
+    return util.getFileSize(filename).then(filesize => {
+      if (filesize === expectedSize) {
+        debug('downloaded file has the expected size ✅');
+        return;
+      }
+
+      debug('raising error: file size mismatch');
+      const text = stripIndent`
+          Corrupted download
+
+          Expected downloaded file to have size: ${expectedSize}
+          Computed size: ${filesize}
+        `;
+      throw new Error(text);
+    });
+  }
+
+  debug('downloaded file lacks checksum or size to verify');
+  return Promise.resolve();
+}; // downloads from given url
+// return an object with
+// {filename: ..., downloaded: true}
+
+
+const downloadFromUrl = ({
+  url,
+  downloadDestination,
+  progress,
+  ca
+}) => {
+  return new Promise((resolve, reject) => {
+    const proxy = getProxyUrl();
+    debug('Downloading package', {
+      url,
+      proxy,
+      downloadDestination
+    });
+    let redirectVersion;
+    const reqOptions = {
+      url,
+      proxy,
+
+      followRedirect(response) {
+        const version = response.headers['x-version'];
+        debug('redirect version:', version);
+
+        if (version) {
+          // set the version in options if we have one.
+          // this insulates us from potential redirect
+          // problems where version would be set to undefined.
+          redirectVersion = version;
+        } // yes redirect
+
+
+        return true;
+      }
+
+    };
+
+    if (ca) {
+      debug('using custom CA details from npm config');
+      reqOptions.agentOptions = {
+        ca
+      };
+    }
+
+    const req = request(reqOptions); // closure
+
+    let started = null;
+    let expectedSize;
+    let expectedChecksum;
+    requestProgress(req, {
+      throttle: progress.throttle
+    }).on('response', response => {
+      // we have computed checksum and filesize during test runner binary build
+      // and have set it on the S3 object as user meta data, available via
+      // these custom headers "x-amz-meta-..."
+      // see https://github.com/cypress-io/cypress/pull/4092
+      expectedSize = response.headers['x-amz-meta-size'] || response.headers['content-length'];
+      expectedChecksum = response.headers['x-amz-meta-checksum'];
+
+      if (expectedChecksum) {
+        debug('expected checksum %s', expectedChecksum);
+      }
+
+      if (expectedSize) {
+        // convert from string (all Amazon custom headers are strings)
+        expectedSize = Number(expectedSize);
+        debug('expected file size %d', expectedSize);
+      } // start counting now once we've gotten
+      // response headers
+
+
+      started = new Date(); // if our status code does not start with 200
+
+      if (!/^2/.test(response.statusCode)) {
+        debug('response code %d', response.statusCode);
+        const err = new Error(stripIndent`
+          Failed downloading the Cypress binary.
+          Response code: ${response.statusCode}
+          Response message: ${response.statusMessage}
+        `);
+        reject(err);
+      }
+    }).on('error', reject).on('progress', state => {
+      // total time we've elapsed
+      // starting on our first progress notification
+      const elapsed = new Date() - started; // request-progress sends a value between 0 and 1
+
+      const percentage = util.convertPercentToPercentage(state.percent);
+      const eta = util.calculateEta(percentage, elapsed); // send up our percent and seconds remaining
+
+      progress.onProgress(percentage, util.secsRemaining(eta));
+    }) // save this download here
+    .pipe(fs.createWriteStream(downloadDestination)).on('finish', () => {
+      debug('downloading finished');
+      verifyDownloadedFile(downloadDestination, expectedSize, expectedChecksum).then(() => {
+        return resolve(redirectVersion);
+      }, reject);
+    });
+  });
+};
+/**
+ * Download Cypress.zip from external url to local file.
+ * @param [string] version Could be "3.3.0" or full URL
+ * @param [string] downloadDestination Local filename to save as
+ */
+
+
+const start = opts => {
+  let {
+    version,
+    downloadDestination,
+    progress
+  } = opts;
+
+  if (!downloadDestination) {
+    la(is.unemptyString(downloadDestination), 'missing download dir', opts);
+  }
+
+  if (!progress) {
+    progress = {
+      onProgress: () => {
+        return {};
+      }
+    };
+  }
+
+  const url = getUrl(version);
+  progress.throttle = 100;
+  debug('needed Cypress version: %s', version);
+  debug('source url %s', url);
+  debug(`downloading cypress.zip to "${downloadDestination}"`); // ensure download dir exists
+
+  return fs.ensureDirAsync(path.dirname(downloadDestination)).then(() => {
+    return getCA();
+  }).then(ca => {
+    return downloadFromUrl({
+      url,
+      downloadDestination,
+      progress,
+      ca
+    });
+  }).catch(err => {
+    return prettyDownloadErr(err, version);
+  });
+};
+
+module.exports = {
+  start,
+  getUrl,
+  getProxyUrl,
+  getCA
+};

node_modules/cypress/lib/tasks/get-folder-size.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const fs = require('../fs');
+
+const {
+  join
+} = require('path');
+
+const Bluebird = require('bluebird');
+/**
+ * Get the size of a folder or a file.
+ *
+ * This function returns the actual file size of the folder (size), not the allocated space on disk (size on disk).
+ * For more details between the difference, check this link:
+ * https://www.howtogeek.com/180369/why-is-there-a-big-difference-between-size-and-size-on-disk/
+ *
+ * @param {string} path path to the file or the folder.
+ */
+
+
+async function getSize(path) {
+  const stat = await fs.lstat(path);
+
+  if (stat.isDirectory()) {
+    const list = await fs.readdir(path);
+    return Bluebird.resolve(list).reduce(async (prev, curr) => {
+      const currPath = join(path, curr);
+      const s = await fs.lstat(currPath);
+
+      if (s.isDirectory()) {
+        return prev + (await getSize(currPath));
+      }
+
+      return prev + s.size;
+    }, 0);
+  }
+
+  return stat.size;
+}
+
+module.exports = getSize;

node_modules/cypress/lib/tasks/install.js

@@ -0,0 +1,449 @@
+"use strict";
+
+const _ = require('lodash');
+
+const os = require('os');
+
+const url = require('url');
+
+const path = require('path');
+
+const chalk = require('chalk');
+
+const debug = require('debug')('cypress:cli');
+
+const {
+  Listr
+} = require('listr2');
+
+const Promise = require('bluebird');
+
+const logSymbols = require('log-symbols');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const fs = require('../fs');
+
+const download = require('./download');
+
+const util = require('../util');
+
+const state = require('./state');
+
+const unzip = require('./unzip');
+
+const logger = require('../logger');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const verbose = require('../VerboseRenderer');
+
+const getNpmArgv = () => {
+  const json = process.env.npm_config_argv;
+
+  if (!json) {
+    return;
+  }
+
+  debug('found npm argv json %o', json);
+
+  try {
+    return JSON.parse(json).original || [];
+  } catch (e) {
+    return [];
+  }
+}; // attempt to discover the version specifier used to install Cypress
+// for example: "^5.0.0", "https://cdn.cypress.io/...", ...
+
+
+const getVersionSpecifier = (startDir = path.resolve(__dirname, '../..')) => {
+  const argv = getNpmArgv();
+
+  if (argv) {
+    const tgz = _.find(argv, t => t.endsWith('cypress.tgz'));
+
+    if (tgz) {
+      return tgz;
+    }
+  }
+
+  const getVersionSpecifierFromPkg = dir => {
+    debug('looking for versionSpecifier %o', {
+      dir
+    });
+
+    const tryParent = () => {
+      const parentPath = path.resolve(dir, '..');
+
+      if (parentPath === dir) {
+        debug('reached FS root with no versionSpecifier found');
+        return;
+      }
+
+      return getVersionSpecifierFromPkg(parentPath);
+    };
+
+    return fs.readJSON(path.join(dir, 'package.json')).catch(() => ({})).then(pkg => {
+      const specifier = _.chain(['dependencies', 'devDependencies', 'optionalDependencies']).map(prop => _.get(pkg, `${prop}.cypress`)).compact().first().value();
+
+      return specifier || tryParent();
+    });
+  }; // recurse through parent directories until package.json with `cypress` is found
+
+
+  return getVersionSpecifierFromPkg(startDir).then(versionSpecifier => {
+    debug('finished looking for versionSpecifier', {
+      versionSpecifier
+    });
+    return versionSpecifier;
+  });
+};
+
+const betaNpmUrlRe = /^\/beta\/npm\/(?<version>[0-9.]+)\/(?<artifactSlug>[^/]+)\/cypress\.tgz$/; // convert a prerelease NPM package .tgz URL to the corresponding binary .zip URL
+
+const getBinaryUrlFromPrereleaseNpmUrl = npmUrl => {
+  let parsed;
+
+  try {
+    parsed = url.parse(npmUrl);
+  } catch (e) {
+    return;
+  }
+
+  const matches = betaNpmUrlRe.exec(parsed.pathname);
+
+  if (parsed.hostname !== 'cdn.cypress.io' || !matches) {
+    return;
+  }
+
+  const {
+    version,
+    artifactSlug
+  } = matches.groups;
+  parsed.pathname = `/beta/binary/${version}/${os.platform()}-${os.arch()}/${artifactSlug}/cypress.zip`;
+  return parsed.format();
+};
+
+const alreadyInstalledMsg = () => {
+  if (!util.isPostInstall()) {
+    logger.log(stripIndent`
+      Skipping installation:
+
+        Pass the ${chalk.yellow('--force')} option if you'd like to reinstall anyway.
+    `);
+  }
+};
+
+const displayCompletionMsg = () => {
+  // check here to see if we are globally installed
+  if (util.isInstalledGlobally()) {
+    // if we are display a warning
+    logger.log();
+    logger.warn(stripIndent`
+      ${logSymbols.warning} Warning: It looks like you\'ve installed Cypress globally.
+
+        This will work, but it'\s not recommended.
+
+        The recommended way to install Cypress is as a devDependency per project.
+
+        You should probably run these commands:
+
+        - ${chalk.cyan('npm uninstall -g cypress')}
+        - ${chalk.cyan('npm install --save-dev cypress')}
+    `);
+    return;
+  }
+
+  logger.log();
+  logger.log('You can now open Cypress by running:', chalk.cyan(path.join('node_modules', '.bin', 'cypress'), 'open'));
+  logger.log();
+  logger.log(chalk.grey('https://on.cypress.io/installing-cypress'));
+  logger.log();
+};
+
+const downloadAndUnzip = ({
+  version,
+  installDir,
+  downloadDir
+}) => {
+  const progress = {
+    throttle: 100,
+    onProgress: null
+  };
+  const downloadDestination = path.join(downloadDir, `cypress-${process.pid}.zip`);
+  const rendererOptions = getRendererOptions(); // let the user know what version of cypress we're downloading!
+
+  logger.log(`Installing Cypress ${chalk.gray(`(version: ${version})`)}`);
+  logger.log();
+  const tasks = new Listr([{
+    options: {
+      title: util.titleize('Downloading Cypress')
+    },
+    task: (ctx, task) => {
+      // as our download progresses indicate the status
+      progress.onProgress = progessify(task, 'Downloading Cypress');
+      return download.start({
+        version,
+        downloadDestination,
+        progress
+      }).then(redirectVersion => {
+        if (redirectVersion) version = redirectVersion;
+        debug(`finished downloading file: ${downloadDestination}`);
+      }).then(() => {
+        // save the download destination for unzipping
+        util.setTaskTitle(task, util.titleize(chalk.green('Downloaded Cypress')), rendererOptions.renderer);
+      });
+    }
+  }, unzipTask({
+    progress,
+    zipFilePath: downloadDestination,
+    installDir,
+    rendererOptions
+  }), {
+    options: {
+      title: util.titleize('Finishing Installation')
+    },
+    task: (ctx, task) => {
+      const cleanup = () => {
+        debug('removing zip file %s', downloadDestination);
+        return fs.removeAsync(downloadDestination);
+      };
+
+      return cleanup().then(() => {
+        debug('finished installation in', installDir);
+        util.setTaskTitle(task, util.titleize(chalk.green('Finished Installation'), chalk.gray(installDir)), rendererOptions.renderer);
+      });
+    }
+  }], {
+    rendererOptions
+  }); // start the tasks!
+
+  return Promise.resolve(tasks.run());
+};
+
+const start = (options = {}) => {
+  debug('installing with options %j', options);
+
+  _.defaults(options, {
+    force: false
+  });
+
+  const pkgVersion = util.pkgVersion();
+  let needVersion = pkgVersion;
+  let binaryUrlOverride;
+  debug('version in package.json is', needVersion); // let this environment variable reset the binary version we need
+
+  if (util.getEnv('CYPRESS_INSTALL_BINARY')) {
+    // because passed file paths are often double quoted
+    // and might have extra whitespace around, be robust and trim the string
+    const trimAndRemoveDoubleQuotes = true;
+    const envVarVersion = util.getEnv('CYPRESS_INSTALL_BINARY', trimAndRemoveDoubleQuotes);
+    debug('using environment variable CYPRESS_INSTALL_BINARY "%s"', envVarVersion);
+
+    if (envVarVersion === '0') {
+      debug('environment variable CYPRESS_INSTALL_BINARY = 0, skipping install');
+      logger.log(stripIndent`
+        ${chalk.yellow('Note:')} Skipping binary installation: Environment variable CYPRESS_INSTALL_BINARY = 0.`);
+      logger.log();
+      return Promise.resolve();
+    }
+
+    binaryUrlOverride = envVarVersion;
+  }
+
+  if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
+    const envCache = util.getEnv('CYPRESS_CACHE_FOLDER');
+    logger.log(stripIndent`
+        ${chalk.yellow('Note:')} Overriding Cypress cache directory to: ${chalk.cyan(envCache)}
+
+              Previous installs of Cypress may not be found.
+      `);
+    logger.log();
+  }
+
+  const installDir = state.getVersionDir(pkgVersion);
+  const cacheDir = state.getCacheDir();
+  const binaryDir = state.getBinaryDir(pkgVersion);
+  return fs.ensureDirAsync(cacheDir).catch({
+    code: 'EACCES'
+  }, err => {
+    return throwFormErrorText(errors.invalidCacheDirectory)(stripIndent`
+    Failed to access ${chalk.cyan(cacheDir)}:
+
+    ${err.message}
+    `);
+  }).then(() => {
+    return Promise.all([state.getBinaryPkgAsync(binaryDir).then(state.getBinaryPkgVersion), getVersionSpecifier()]);
+  }).then(([binaryVersion, versionSpecifier]) => {
+    if (!binaryUrlOverride && versionSpecifier) {
+      const computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);
+
+      if (computedBinaryUrl) {
+        debug('computed binary url from version specifier %o', {
+          computedBinaryUrl,
+          needVersion
+        });
+        binaryUrlOverride = computedBinaryUrl;
+      }
+    }
+
+    needVersion = binaryUrlOverride || needVersion;
+    debug('installed version is', binaryVersion, 'version needed is', needVersion);
+
+    if (!binaryVersion) {
+      debug('no binary installed under cli version');
+      return true;
+    }
+
+    logger.log();
+    logger.log(stripIndent`
+      Cypress ${chalk.green(binaryVersion)} is installed in ${chalk.cyan(installDir)}
+      `);
+    logger.log();
+
+    if (options.force) {
+      debug('performing force install over existing binary');
+      return true;
+    }
+
+    if (binaryVersion === needVersion || !util.isSemver(needVersion)) {
+      // our version matches, tell the user this is a noop
+      alreadyInstalledMsg();
+      return false;
+    }
+
+    return true;
+  }).then(shouldInstall => {
+    // noop if we've been told not to download
+    if (!shouldInstall) {
+      debug('Not downloading or installing binary');
+      return;
+    }
+
+    if (needVersion !== pkgVersion) {
+      logger.log(chalk.yellow(stripIndent`
+          ${logSymbols.warning} Warning: Forcing a binary version different than the default.
+
+            The CLI expected to install version: ${chalk.green(pkgVersion)}
+
+            Instead we will install version: ${chalk.green(needVersion)}
+
+            These versions may not work properly together.
+        `));
+      logger.log();
+    } // see if version supplied is a path to a binary
+
+
+    return fs.pathExistsAsync(needVersion).then(exists => {
+      if (exists) {
+        return path.extname(needVersion) === '.zip' ? needVersion : false;
+      }
+
+      const possibleFile = util.formAbsolutePath(needVersion);
+      debug('checking local file', possibleFile, 'cwd', process.cwd());
+      return fs.pathExistsAsync(possibleFile).then(exists => {
+        // if this exists return the path to it
+        // else false
+        if (exists && path.extname(possibleFile) === '.zip') {
+          return possibleFile;
+        }
+
+        return false;
+      });
+    }).then(pathToLocalFile => {
+      if (pathToLocalFile) {
+        const absolutePath = path.resolve(needVersion);
+        debug('found local file at', absolutePath);
+        debug('skipping download');
+        const rendererOptions = getRendererOptions();
+        return new Listr([unzipTask({
+          progress: {
+            throttle: 100,
+            onProgress: null
+          },
+          zipFilePath: absolutePath,
+          installDir,
+          rendererOptions
+        })], {
+          rendererOptions
+        }).run();
+      }
+
+      if (options.force) {
+        debug('Cypress already installed at', installDir);
+        debug('but the installation was forced');
+      }
+
+      debug('preparing to download and unzip version ', needVersion, 'to path', installDir);
+      const downloadDir = os.tmpdir();
+      return downloadAndUnzip({
+        version: needVersion,
+        installDir,
+        downloadDir
+      });
+    }) // delay 1 sec for UX, unless we are testing
+    .then(() => {
+      return Promise.delay(1000);
+    }).then(displayCompletionMsg);
+  });
+};
+
+module.exports = {
+  start,
+  _getVersionSpecifier: getVersionSpecifier,
+  _getBinaryUrlFromPrereleaseNpmUrl: getBinaryUrlFromPrereleaseNpmUrl
+};
+
+const unzipTask = ({
+  zipFilePath,
+  installDir,
+  progress,
+  rendererOptions
+}) => {
+  return {
+    options: {
+      title: util.titleize('Unzipping Cypress')
+    },
+    task: (ctx, task) => {
+      // as our unzip progresses indicate the status
+      progress.onProgress = progessify(task, 'Unzipping Cypress');
+      return unzip.start({
+        zipFilePath,
+        installDir,
+        progress
+      }).then(() => {
+        util.setTaskTitle(task, util.titleize(chalk.green('Unzipped Cypress')), rendererOptions.renderer);
+      });
+    }
+  };
+};
+
+const progessify = (task, title) => {
+  // return higher order function
+  return (percentComplete, remaining) => {
+    percentComplete = chalk.white(` ${percentComplete}%`); // pluralize seconds remaining
+
+    remaining = chalk.gray(`${remaining}s`);
+    util.setTaskTitle(task, util.titleize(title, percentComplete, remaining), getRendererOptions().renderer);
+  };
+}; // if we are running in CI then use
+// the verbose renderer else use
+// the default
+
+
+const getRendererOptions = () => {
+  let renderer = util.isCi() ? verbose : 'default';
+
+  if (logger.logLevel() === 'silent') {
+    renderer = 'silent';
+  }
+
+  return {
+    renderer
+  };
+};

node_modules/cypress/lib/tasks/state.js

@@ -0,0 +1,226 @@
+"use strict";
+
+const _ = require('lodash');
+
+const os = require('os');
+
+const path = require('path');
+
+const untildify = require('untildify');
+
+const R = require('ramda');
+
+const debug = require('debug')('cypress:cli');
+
+const fs = require('../fs');
+
+const util = require('../util');
+
+const getPlatformExecutable = () => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return 'Contents/MacOS/Cypress';
+
+    case 'linux':
+      return 'Cypress';
+
+    case 'win32':
+      return 'Cypress.exe';
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+
+const getPlatFormBinaryFolder = () => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return 'Cypress.app';
+
+    case 'linux':
+      return 'Cypress';
+
+    case 'win32':
+      return 'Cypress';
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+
+const getBinaryPkgPath = binaryDir => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return path.join(binaryDir, 'Contents', 'Resources', 'app', 'package.json');
+
+    case 'linux':
+      return path.join(binaryDir, 'resources', 'app', 'package.json');
+
+    case 'win32':
+      return path.join(binaryDir, 'resources', 'app', 'package.json');
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+/**
+ * Get path to binary directory
+*/
+
+
+const getBinaryDir = (version = util.pkgVersion()) => {
+  return path.join(getVersionDir(version), getPlatFormBinaryFolder());
+};
+
+const getVersionDir = (version = util.pkgVersion()) => {
+  return path.join(getCacheDir(), version);
+};
+/**
+ * When executing "npm postinstall" hook, the working directory is set to
+ * "<current folder>/node_modules/cypress", which can be surprising when using relative paths.
+ */
+
+
+const isInstallingFromPostinstallHook = () => {
+  // individual folders
+  const cwdFolders = process.cwd().split(path.sep);
+  const length = cwdFolders.length;
+  return cwdFolders[length - 2] === 'node_modules' && cwdFolders[length - 1] === 'cypress';
+};
+
+const getCacheDir = () => {
+  let cache_directory = util.getCacheDir();
+
+  if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
+    const envVarCacheDir = untildify(util.getEnv('CYPRESS_CACHE_FOLDER'));
+    debug('using environment variable CYPRESS_CACHE_FOLDER %s', envVarCacheDir);
+
+    if (!path.isAbsolute(envVarCacheDir) && isInstallingFromPostinstallHook()) {
+      const packageRootFolder = path.join('..', '..', envVarCacheDir);
+      cache_directory = path.resolve(packageRootFolder);
+      debug('installing from postinstall hook, original root folder is %s', packageRootFolder);
+      debug('and resolved cache directory is %s', cache_directory);
+    } else {
+      cache_directory = path.resolve(envVarCacheDir);
+    }
+  }
+
+  return cache_directory;
+};
+
+const parseRealPlatformBinaryFolderAsync = binaryPath => {
+  return fs.realpathAsync(binaryPath).then(realPath => {
+    debug('CYPRESS_RUN_BINARY has realpath:', realPath);
+
+    if (!realPath.toString().endsWith(getPlatformExecutable())) {
+      return false;
+    }
+
+    if (os.platform() === 'darwin') {
+      return path.resolve(realPath, '..', '..', '..');
+    }
+
+    return path.resolve(realPath, '..');
+  });
+};
+
+const getDistDir = () => {
+  return path.join(__dirname, '..', '..', 'dist');
+};
+/**
+ * Returns full filename to the file that keeps the Test Runner verification state as JSON text.
+ * Note: the binary state file will be stored one level up from the given binary folder.
+ * @param {string} binaryDir - full path to the folder holding the binary.
+ */
+
+
+const getBinaryStatePath = binaryDir => {
+  return path.join(binaryDir, '..', 'binary_state.json');
+};
+
+const getBinaryStateContentsAsync = binaryDir => {
+  const fullPath = getBinaryStatePath(binaryDir);
+  return fs.readJsonAsync(fullPath).catch({
+    code: 'ENOENT'
+  }, SyntaxError, () => {
+    debug('could not read binary_state.json file at "%s"', fullPath);
+    return {};
+  });
+};
+
+const getBinaryVerifiedAsync = binaryDir => {
+  return getBinaryStateContentsAsync(binaryDir).tap(debug).get('verified');
+};
+
+const clearBinaryStateAsync = binaryDir => {
+  return fs.removeAsync(getBinaryStatePath(binaryDir));
+};
+/**
+ * Writes the new binary status.
+ * @param {boolean} verified The new test runner state after smoke test
+ * @param {string} binaryDir Folder holding the binary
+ * @returns {Promise<void>} returns a promise
+ */
+
+
+const writeBinaryVerifiedAsync = (verified, binaryDir) => {
+  return getBinaryStateContentsAsync(binaryDir).then(contents => {
+    return fs.outputJsonAsync(getBinaryStatePath(binaryDir), _.extend(contents, {
+      verified
+    }), {
+      spaces: 2
+    });
+  });
+};
+
+const getPathToExecutable = binaryDir => {
+  return path.join(binaryDir, getPlatformExecutable());
+};
+/**
+ * Resolves with an object read from the binary app package.json file.
+ * If the file does not exist resolves with null
+ */
+
+
+const getBinaryPkgAsync = binaryDir => {
+  const pathToPackageJson = getBinaryPkgPath(binaryDir);
+  debug('Reading binary package.json from:', pathToPackageJson);
+  return fs.pathExistsAsync(pathToPackageJson).then(exists => {
+    if (!exists) {
+      return null;
+    }
+
+    return fs.readJsonAsync(pathToPackageJson);
+  });
+};
+
+const getBinaryPkgVersion = R.propOr(null, 'version');
+const getBinaryElectronVersion = R.propOr(null, 'electronVersion');
+const getBinaryElectronNodeVersion = R.propOr(null, 'electronNodeVersion');
+module.exports = {
+  getPathToExecutable,
+  getPlatformExecutable,
+  // those names start to sound like Java
+  getBinaryElectronNodeVersion,
+  getBinaryElectronVersion,
+  getBinaryPkgVersion,
+  getBinaryVerifiedAsync,
+  getBinaryPkgAsync,
+  getBinaryPkgPath,
+  getBinaryDir,
+  getCacheDir,
+  clearBinaryStateAsync,
+  writeBinaryVerifiedAsync,
+  parseRealPlatformBinaryFolderAsync,
+  getDistDir,
+  getVersionDir
+};

node_modules/cypress/lib/tasks/unzip.js

@@ -0,0 +1,226 @@
+"use strict";
+
+const _ = require('lodash');
+
+const la = require('lazy-ass');
+
+const is = require('check-more-types');
+
+const cp = require('child_process');
+
+const os = require('os');
+
+const yauzl = require('yauzl');
+
+const debug = require('debug')('cypress:cli:unzip');
+
+const extract = require('extract-zip');
+
+const Promise = require('bluebird');
+
+const readline = require('readline');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const fs = require('../fs');
+
+const util = require('../util');
+
+const unzipTools = {
+  extract
+}; // expose this function for simple testing
+
+const unzip = ({
+  zipFilePath,
+  installDir,
+  progress
+}) => {
+  debug('unzipping from %s', zipFilePath);
+  debug('into', installDir);
+
+  if (!zipFilePath) {
+    throw new Error('Missing zip filename');
+  }
+
+  const startTime = Date.now();
+  let yauzlDoneTime = 0;
+  return fs.ensureDirAsync(installDir).then(() => {
+    return new Promise((resolve, reject) => {
+      return yauzl.open(zipFilePath, (err, zipFile) => {
+        yauzlDoneTime = Date.now();
+
+        if (err) {
+          debug('error using yauzl %s', err.message);
+          return reject(err);
+        }
+
+        const total = zipFile.entryCount;
+        debug('zipFile entries count', total);
+        const started = new Date();
+        let percent = 0;
+        let count = 0;
+
+        const notify = percent => {
+          const elapsed = +new Date() - +started;
+          const eta = util.calculateEta(percent, elapsed);
+          progress.onProgress(percent, util.secsRemaining(eta));
+        };
+
+        const tick = () => {
+          count += 1;
+          percent = count / total * 100;
+          const displayPercent = percent.toFixed(0);
+          return notify(displayPercent);
+        };
+
+        const unzipWithNode = () => {
+          debug('unzipping with node.js (slow)');
+          const opts = {
+            dir: installDir,
+            onEntry: tick
+          };
+          debug('calling Node extract tool %s %o', zipFilePath, opts);
+          return unzipTools.extract(zipFilePath, opts).then(() => {
+            debug('node unzip finished');
+            return resolve();
+          }).catch(err => {
+            if (err) {
+              debug('error %s', err.message);
+              return reject(err);
+            }
+          });
+        };
+
+        const unzipFallback = _.once(unzipWithNode);
+
+        const unzipWithUnzipTool = () => {
+          debug('unzipping via `unzip`');
+          const inflatingRe = /inflating:/;
+          const sp = cp.spawn('unzip', ['-o', zipFilePath, '-d', installDir]);
+          sp.on('error', err => {
+            debug('unzip tool error: %s', err.message);
+            unzipFallback();
+          });
+          sp.on('close', code => {
+            debug('unzip tool close with code %d', code);
+
+            if (code === 0) {
+              percent = 100;
+              notify(percent);
+              return resolve();
+            }
+
+            debug('`unzip` failed %o', {
+              code
+            });
+            return unzipFallback();
+          });
+          sp.stdout.on('data', data => {
+            if (inflatingRe.test(data)) {
+              return tick();
+            }
+          });
+          sp.stderr.on('data', data => {
+            debug('`unzip` stderr %s', data);
+          });
+        }; // we attempt to first unzip with the native osx
+        // ditto because its less likely to have problems
+        // with corruption, symlinks, or icons causing failures
+        // and can handle resource forks
+        // http://automatica.com.au/2011/02/unzip-mac-os-x-zip-in-terminal/
+
+
+        const unzipWithOsx = () => {
+          debug('unzipping via `ditto`');
+          const copyingFileRe = /^copying file/;
+          const sp = cp.spawn('ditto', ['-xkV', zipFilePath, installDir]); // f-it just unzip with node
+
+          sp.on('error', err => {
+            debug(err.message);
+            unzipFallback();
+          });
+          sp.on('close', code => {
+            if (code === 0) {
+              // make sure we get to 100% on the progress bar
+              // because reading in lines is not really accurate
+              percent = 100;
+              notify(percent);
+              return resolve();
+            }
+
+            debug('`ditto` failed %o', {
+              code
+            });
+            return unzipFallback();
+          });
+          return readline.createInterface({
+            input: sp.stderr
+          }).on('line', line => {
+            if (copyingFileRe.test(line)) {
+              return tick();
+            }
+          });
+        };
+
+        switch (os.platform()) {
+          case 'darwin':
+            return unzipWithOsx();
+
+          case 'linux':
+            return unzipWithUnzipTool();
+
+          case 'win32':
+            return unzipWithNode();
+
+          default:
+            return;
+        }
+      });
+    }).tap(() => {
+      debug('unzip completed %o', {
+        yauzlMs: yauzlDoneTime - startTime,
+        unzipMs: Date.now() - yauzlDoneTime
+      });
+    });
+  });
+};
+
+const start = ({
+  zipFilePath,
+  installDir,
+  progress
+}) => {
+  la(is.unemptyString(installDir), 'missing installDir');
+
+  if (!progress) {
+    progress = {
+      onProgress: () => {
+        return {};
+      }
+    };
+  }
+
+  return fs.pathExists(installDir).then(exists => {
+    if (exists) {
+      debug('removing existing unzipped binary', installDir);
+      return fs.removeAsync(installDir);
+    }
+  }).then(() => {
+    return unzip({
+      zipFilePath,
+      installDir,
+      progress
+    });
+  }).catch(throwFormErrorText(errors.failedUnzip));
+};
+
+module.exports = {
+  start,
+  utils: {
+    unzip,
+    unzipTools
+  }
+};

node_modules/cypress/lib/tasks/verify.js

@@ -0,0 +1,349 @@
+"use strict";
+
+const _ = require('lodash');
+
+const chalk = require('chalk');
+
+const {
+  Listr
+} = require('listr2');
+
+const debug = require('debug')('cypress:cli');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const Promise = require('bluebird');
+
+const logSymbols = require('log-symbols');
+
+const path = require('path');
+
+const os = require('os');
+
+const verbose = require('../VerboseRenderer');
+
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+
+const util = require('../util');
+
+const logger = require('../logger');
+
+const xvfb = require('../exec/xvfb');
+
+const state = require('./state');
+
+const VERIFY_TEST_RUNNER_TIMEOUT_MS = 30000;
+
+const checkExecutable = binaryDir => {
+  const executable = state.getPathToExecutable(binaryDir);
+  debug('checking if executable exists', executable);
+  return util.isExecutableAsync(executable).then(isExecutable => {
+    debug('Binary is executable? :', isExecutable);
+
+    if (!isExecutable) {
+      return throwFormErrorText(errors.binaryNotExecutable(executable))();
+    }
+  }).catch({
+    code: 'ENOENT'
+  }, () => {
+    if (util.isCi()) {
+      return throwFormErrorText(errors.notInstalledCI(executable))();
+    }
+
+    return throwFormErrorText(errors.missingApp(binaryDir))(stripIndent`
+      Cypress executable not found at: ${chalk.cyan(executable)}
+    `);
+  });
+};
+
+const runSmokeTest = (binaryDir, options) => {
+  let executable = state.getPathToExecutable(binaryDir);
+
+  const onSmokeTestError = (smokeTestCommand, linuxWithDisplayEnv) => {
+    return err => {
+      debug('Smoke test failed:', err);
+      let errMessage = err.stderr || err.message;
+      debug('error message:', errMessage);
+
+      if (err.timedOut) {
+        debug('error timedOut is true');
+        return throwFormErrorText(errors.smokeTestFailure(smokeTestCommand, true))(errMessage);
+      }
+
+      if (linuxWithDisplayEnv && util.isBrokenGtkDisplay(errMessage)) {
+        util.logBrokenGtkDisplayWarning();
+        return throwFormErrorText(errors.invalidSmokeTestDisplayError)(errMessage);
+      }
+
+      return throwFormErrorText(errors.missingDependency)(errMessage);
+    };
+  };
+
+  const needsXvfb = xvfb.isNeeded();
+  debug('needs Xvfb?', needsXvfb);
+  /**
+   * Spawn Cypress running smoke test to check if all operating system
+   * dependencies are good.
+   */
+
+  const spawn = linuxWithDisplayEnv => {
+    const random = _.random(0, 1000);
+
+    const args = ['--smoke-test', `--ping=${random}`];
+
+    if (needsSandbox()) {
+      // electron requires --no-sandbox to run as root
+      debug('disabling Electron sandbox');
+      args.unshift('--no-sandbox');
+    }
+
+    if (options.dev) {
+      executable = 'node';
+      args.unshift(path.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js'));
+    }
+
+    const smokeTestCommand = `${executable} ${args.join(' ')}`;
+    debug('running smoke test');
+    debug('using Cypress executable %s', executable);
+    debug('smoke test command:', smokeTestCommand);
+    debug('smoke test timeout %d ms', options.smokeTestTimeout);
+
+    const env = _.extend({}, process.env, {
+      ELECTRON_ENABLE_LOGGING: true
+    });
+
+    const stdioOptions = _.extend({}, {
+      env,
+      timeout: options.smokeTestTimeout
+    });
+
+    return Promise.resolve(util.exec(executable, args, stdioOptions)).catch(onSmokeTestError(smokeTestCommand, linuxWithDisplayEnv)).then(result => {
+      // TODO: when execa > 1.1 is released
+      // change this to `result.all` for both stderr and stdout
+      // use lodash to be robust during tests against null result or missing stdout
+      const smokeTestStdout = _.get(result, 'stdout', '');
+
+      debug('smoke test stdout "%s"', smokeTestStdout);
+
+      if (!util.stdoutLineMatches(String(random), smokeTestStdout)) {
+        debug('Smoke test failed because could not find %d in:', random, result);
+
+        const smokeTestStderr = _.get(result, 'stderr', '');
+
+        const errorText = smokeTestStderr || smokeTestStdout;
+        return throwFormErrorText(errors.smokeTestFailure(smokeTestCommand, false))(errorText);
+      }
+    });
+  };
+
+  const spawnInXvfb = linuxWithDisplayEnv => {
+    return xvfb.start().then(() => {
+      return spawn(linuxWithDisplayEnv);
+    }).finally(xvfb.stop);
+  };
+
+  const userFriendlySpawn = linuxWithDisplayEnv => {
+    debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
+    return spawn(linuxWithDisplayEnv).catch({
+      code: 'INVALID_SMOKE_TEST_DISPLAY_ERROR'
+    }, () => {
+      return spawnInXvfb(linuxWithDisplayEnv);
+    });
+  };
+
+  if (needsXvfb) {
+    return spawnInXvfb();
+  } // if we are on linux and there's already a DISPLAY
+  // set, then we may need to rerun cypress after
+  // spawning our own Xvfb server
+
+
+  const linuxWithDisplayEnv = util.isPossibleLinuxWithIncorrectDisplay();
+  return userFriendlySpawn(linuxWithDisplayEnv);
+};
+
+function testBinary(version, binaryDir, options) {
+  debug('running binary verification check', version); // if running from 'cypress verify', don't print this message
+
+  if (!options.force) {
+    logger.log(stripIndent`
+    It looks like this is your first time using Cypress: ${chalk.cyan(version)}
+    `);
+  }
+
+  logger.log(); // if we are running in CI then use
+  // the verbose renderer else use
+  // the default
+
+  let renderer = util.isCi() ? verbose : 'default';
+  if (logger.logLevel() === 'silent') renderer = 'silent';
+  const rendererOptions = {
+    renderer
+  };
+  const tasks = new Listr([{
+    options: {
+      title: util.titleize('Verifying Cypress can run', chalk.gray(binaryDir))
+    },
+    task: (ctx, task) => {
+      debug('clearing out the verified version');
+      return state.clearBinaryStateAsync(binaryDir).then(() => {
+        return Promise.all([runSmokeTest(binaryDir, options), Promise.resolve().delay(1500) // good user experience
+        ]);
+      }).then(() => {
+        debug('write verified: true');
+        return state.writeBinaryVerifiedAsync(true, binaryDir);
+      }).then(() => {
+        util.setTaskTitle(task, util.titleize(chalk.green('Verified Cypress!'), chalk.gray(binaryDir)), rendererOptions.renderer);
+      });
+    }
+  }], {
+    rendererOptions
+  });
+  return tasks.run();
+}
+
+const maybeVerify = (installedVersion, binaryDir, options) => {
+  return state.getBinaryVerifiedAsync(binaryDir).then(isVerified => {
+    debug('is Verified ?', isVerified);
+    let shouldVerify = !isVerified; // force verify if options.force
+
+    if (options.force) {
+      debug('force verify');
+      shouldVerify = true;
+    }
+
+    if (shouldVerify) {
+      return testBinary(installedVersion, binaryDir, options).then(() => {
+        if (options.welcomeMessage) {
+          logger.log();
+          logger.log('Opening Cypress...');
+        }
+      });
+    }
+  });
+};
+
+const start = (options = {}) => {
+  debug('verifying Cypress app');
+  const packageVersion = util.pkgVersion();
+  let binaryDir = state.getBinaryDir(packageVersion);
+
+  _.defaults(options, {
+    dev: false,
+    force: false,
+    welcomeMessage: true,
+    smokeTestTimeout: VERIFY_TEST_RUNNER_TIMEOUT_MS
+  });
+
+  if (options.dev) {
+    return runSmokeTest('', options);
+  }
+
+  const parseBinaryEnvVar = () => {
+    const envBinaryPath = util.getEnv('CYPRESS_RUN_BINARY');
+    debug('CYPRESS_RUN_BINARY exists, =', envBinaryPath);
+    logger.log(stripIndent`
+      ${chalk.yellow('Note:')} You have set the environment variable:
+
+      ${chalk.white('CYPRESS_RUN_BINARY=')}${chalk.cyan(envBinaryPath)}
+
+      This overrides the default Cypress binary path used.
+    `);
+    logger.log();
+    return util.isExecutableAsync(envBinaryPath).then(isExecutable => {
+      debug('CYPRESS_RUN_BINARY is executable? :', isExecutable);
+
+      if (!isExecutable) {
+        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(stripIndent`
+          The supplied binary path is not executable
+          `);
+      }
+    }).then(() => {
+      return state.parseRealPlatformBinaryFolderAsync(envBinaryPath);
+    }).then(envBinaryDir => {
+      if (!envBinaryDir) {
+        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))();
+      }
+
+      debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
+      binaryDir = envBinaryDir;
+    }).catch({
+      code: 'ENOENT'
+    }, err => {
+      return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(err.message);
+    });
+  };
+
+  return Promise.try(() => {
+    debug('checking environment variables');
+
+    if (util.getEnv('CYPRESS_RUN_BINARY')) {
+      return parseBinaryEnvVar();
+    }
+  }).then(() => {
+    return checkExecutable(binaryDir);
+  }).tap(() => {
+    return debug('binaryDir is ', binaryDir);
+  }).then(() => {
+    return state.getBinaryPkgAsync(binaryDir);
+  }).then(pkg => {
+    return state.getBinaryPkgVersion(pkg);
+  }).then(binaryVersion => {
+    if (!binaryVersion) {
+      debug('no Cypress binary found for cli version ', packageVersion);
+      return throwFormErrorText(errors.missingApp(binaryDir))(`
+      Cannot read binary version from: ${chalk.cyan(state.getBinaryPkgPath(binaryDir))}
+    `);
+    }
+
+    debug(`Found binary version ${chalk.green(binaryVersion)} installed in: ${chalk.cyan(binaryDir)}`);
+
+    if (binaryVersion !== packageVersion) {
+      // warn if we installed with CYPRESS_INSTALL_BINARY or changed version
+      // in the package.json
+      logger.log(`Found binary version ${chalk.green(binaryVersion)} installed in: ${chalk.cyan(binaryDir)}`);
+      logger.log();
+      logger.warn(stripIndent`
+
+
+      ${logSymbols.warning} Warning: Binary version ${chalk.green(binaryVersion)} does not match the expected package version ${chalk.green(packageVersion)}
+
+        These versions may not work properly together.
+      `);
+      logger.log();
+    }
+
+    return maybeVerify(binaryVersion, binaryDir, options);
+  }).catch(err => {
+    if (err.known) {
+      throw err;
+    }
+
+    return throwFormErrorText(errors.unexpected)(err.stack);
+  });
+};
+
+const isLinuxLike = () => os.platform() !== 'win32';
+/**
+ * Returns true if running on a system where Electron needs "--no-sandbox" flag.
+ * @see https://crbug.com/638180
+ *
+ * On Debian we had problems running in sandbox even for non-root users.
+ * @see https://github.com/cypress-io/cypress/issues/5434
+ * Seems there is a lot of discussion around this issue among Electron users
+ * @see https://github.com/electron/electron/issues/17972
+*/
+
+
+const needsSandbox = () => isLinuxLike();
+
+module.exports = {
+  start,
+  VERIFY_TEST_RUNNER_TIMEOUT_MS,
+  needsSandbox
+};

node_modules/cypress/lib/util.js

@@ -0,0 +1,480 @@
+"use strict";
+
+const _ = require('lodash');
+
+const R = require('ramda');
+
+const os = require('os');
+
+const ospath = require('ospath');
+
+const crypto = require('crypto');
+
+const la = require('lazy-ass');
+
+const is = require('check-more-types');
+
+const tty = require('tty');
+
+const path = require('path');
+
+const isCi = require('is-ci');
+
+const execa = require('execa');
+
+const getos = require('getos');
+
+const chalk = require('chalk');
+
+const Promise = require('bluebird');
+
+const cachedir = require('cachedir');
+
+const logSymbols = require('log-symbols');
+
+const executable = require('executable');
+
+const {
+  stripIndent
+} = require('common-tags');
+
+const supportsColor = require('supports-color');
+
+const isInstalledGlobally = require('is-installed-globally');
+
+const pkg = require(path.join(__dirname, '..', 'package.json'));
+
+const logger = require('./logger');
+
+const debug = require('debug')('cypress:cli');
+
+const fs = require('./fs');
+
+const issuesUrl = 'https://github.com/cypress-io/cypress/issues';
+const getosAsync = Promise.promisify(getos);
+/**
+ * Returns SHA512 of a file
+ *
+ * Implementation lifted from https://github.com/sindresorhus/hasha
+ * but without bringing that dependency (since hasha is Node v8+)
+ */
+
+const getFileChecksum = filename => {
+  la(is.unemptyString(filename), 'expected filename', filename);
+
+  const hashStream = () => {
+    const s = crypto.createHash('sha512');
+    s.setEncoding('hex');
+    return s;
+  };
+
+  return new Promise((resolve, reject) => {
+    const stream = fs.createReadStream(filename);
+    stream.on('error', reject).pipe(hashStream()).on('error', reject).on('finish', function () {
+      resolve(this.read());
+    });
+  });
+};
+
+const getFileSize = filename => {
+  la(is.unemptyString(filename), 'expected filename', filename);
+  return fs.statAsync(filename).get('size');
+};
+
+const isBrokenGtkDisplayRe = /Gtk: cannot open display/;
+
+const stringify = val => {
+  return _.isObject(val) ? JSON.stringify(val) : val;
+};
+
+function normalizeModuleOptions(options = {}) {
+  return _.mapValues(options, stringify);
+}
+/**
+ * Returns true if the platform is Linux. We do a lot of different
+ * stuff on Linux (like Xvfb) and it helps to has readable code
+ */
+
+
+const isLinux = () => {
+  return os.platform() === 'linux';
+};
+/**
+   * If the DISPLAY variable is set incorrectly, when trying to spawn
+   * Cypress executable we get an error like this:
+  ```
+  [1005:0509/184205.663837:WARNING:browser_main_loop.cc(258)] Gtk: cannot open display: 99
+  ```
+   */
+
+
+const isBrokenGtkDisplay = str => {
+  return isBrokenGtkDisplayRe.test(str);
+};
+
+const isPossibleLinuxWithIncorrectDisplay = () => {
+  return isLinux() && process.env.DISPLAY;
+};
+
+const logBrokenGtkDisplayWarning = () => {
+  debug('Cypress exited due to a broken gtk display because of a potential invalid DISPLAY env... retrying after starting Xvfb'); // if we get this error, we are on Linux and DISPLAY is set
+
+  logger.warn(stripIndent`
+
+    ${logSymbols.warning} Warning: Cypress failed to start.
+
+    This is likely due to a misconfigured DISPLAY environment variable.
+
+    DISPLAY was set to: "${process.env.DISPLAY}"
+
+    Cypress will attempt to fix the problem and rerun.
+  `);
+  logger.warn();
+};
+
+function stdoutLineMatches(expectedLine, stdout) {
+  const lines = stdout.split('\n').map(R.trim);
+  const lineMatches = R.equals(expectedLine);
+  return lines.some(lineMatches);
+}
+/**
+ * Confirms if given value is a valid CYPRESS_INTERNAL_ENV value. Undefined values
+ * are valid, because the system can set the default one.
+ *
+ * @param {string} value
+ * @example util.isValidCypressInternalEnvValue(process.env.CYPRESS_INTERNAL_ENV)
+ */
+
+
+function isValidCypressInternalEnvValue(value) {
+  if (_.isUndefined(value)) {
+    // will get default value
+    return true;
+  } // names of config environments, see "packages/server/config/app.yml"
+
+
+  const names = ['development', 'test', 'staging', 'production'];
+  return _.includes(names, value);
+}
+/**
+ * Confirms if given value is a non-production CYPRESS_INTERNAL_ENV value.
+ * Undefined values are valid, because the system can set the default one.
+ *
+ * @param {string} value
+ * @example util.isNonProductionCypressInternalEnvValue(process.env.CYPRESS_INTERNAL_ENV)
+ */
+
+
+function isNonProductionCypressInternalEnvValue(value) {
+  return !_.isUndefined(value) && value !== 'production';
+}
+/**
+ * Prints NODE_OPTIONS using debug() module, but only
+ * if DEBUG=cypress... is set
+ */
+
+
+function printNodeOptions(log = debug) {
+  if (!log.enabled) {
+    return;
+  }
+
+  if (process.env.NODE_OPTIONS) {
+    log('NODE_OPTIONS=%s', process.env.NODE_OPTIONS);
+  } else {
+    log('NODE_OPTIONS is not set');
+  }
+}
+/**
+ * Removes double quote characters
+ * from the start and end of the given string IF they are both present
+ *
+ * @param {string} str Input string
+ * @returns {string} Trimmed string or the original string if there are no double quotes around it.
+ * @example
+  ```
+  dequote('"foo"')
+  // returns string 'foo'
+  dequote('foo')
+  // returns string 'foo'
+  ```
+ */
+
+
+const dequote = str => {
+  la(is.string(str), 'expected a string to remove double quotes', str);
+
+  if (str.length > 1 && str[0] === '"' && str[str.length - 1] === '"') {
+    return str.substr(1, str.length - 2);
+  }
+
+  return str;
+};
+
+const parseOpts = opts => {
+  opts = _.pick(opts, 'browser', 'cachePath', 'cacheList', 'cacheClear', 'cachePrune', 'ciBuildId', 'config', 'configFile', 'cypressVersion', 'destination', 'detached', 'dev', 'exit', 'env', 'force', 'global', 'group', 'headed', 'headless', 'key', 'path', 'parallel', 'port', 'project', 'quiet', 'reporter', 'reporterOptions', 'record', 'runProject', 'spec', 'tag');
+
+  if (opts.exit) {
+    opts = _.omit(opts, 'exit');
+  } // some options might be quoted - which leads to unexpected results
+  // remove double quotes from certain options
+
+
+  const removeQuotes = {
+    group: dequote,
+    ciBuildId: dequote
+  };
+  const cleanOpts = R.evolve(removeQuotes, opts);
+  debug('parsed cli options %o', cleanOpts);
+  return cleanOpts;
+};
+/**
+ * Copy of packages/server/lib/browsers/utils.ts
+ * because we need same functionality in CLI to show the path :(
+ */
+
+
+const getApplicationDataFolder = (...paths) => {
+  const {
+    env
+  } = process; // allow overriding the app_data folder
+
+  const folder = env.CYPRESS_KONFIG_ENV || env.CYPRESS_INTERNAL_ENV || 'development';
+  const PRODUCT_NAME = pkg.productName || pkg.name;
+  const OS_DATA_PATH = ospath.data();
+  const ELECTRON_APP_DATA_PATH = path.join(OS_DATA_PATH, PRODUCT_NAME);
+  const p = path.join(ELECTRON_APP_DATA_PATH, 'cy', folder, ...paths);
+  return p;
+};
+
+const util = {
+  normalizeModuleOptions,
+  parseOpts,
+  isValidCypressInternalEnvValue,
+  isNonProductionCypressInternalEnvValue,
+  printNodeOptions,
+
+  isCi() {
+    return isCi;
+  },
+
+  getEnvOverrides(options = {}) {
+    return _.chain({}).extend(util.getEnvColors()).extend(util.getForceTty()).omitBy(_.isUndefined) // remove undefined values
+    .mapValues(value => {
+      // stringify to 1 or 0
+      return value ? '1' : '0';
+    }).extend(util.getOriginalNodeOptions(options)).value();
+  },
+
+  getOriginalNodeOptions(options) {
+    if (process.env.NODE_OPTIONS) {
+      return {
+        ORIGINAL_NODE_OPTIONS: process.env.NODE_OPTIONS
+      };
+    }
+
+    return {};
+  },
+
+  getForceTty() {
+    return {
+      FORCE_STDIN_TTY: util.isTty(process.stdin.fd),
+      FORCE_STDOUT_TTY: util.isTty(process.stdout.fd),
+      FORCE_STDERR_TTY: util.isTty(process.stderr.fd)
+    };
+  },
+
+  getEnvColors() {
+    const sc = util.supportsColor();
+    return {
+      FORCE_COLOR: sc,
+      DEBUG_COLORS: sc,
+      MOCHA_COLORS: sc ? true : undefined
+    };
+  },
+
+  isTty(fd) {
+    return tty.isatty(fd);
+  },
+
+  supportsColor() {
+    // if we've been explictly told not to support
+    // color then turn this off
+    if (process.env.NO_COLOR) {
+      return false;
+    } // https://github.com/cypress-io/cypress/issues/1747
+    // always return true in CI providers
+
+
+    if (process.env.CI) {
+      return true;
+    } // ensure that both stdout and stderr support color
+
+
+    return Boolean(supportsColor.stdout) && Boolean(supportsColor.stderr);
+  },
+
+  cwd() {
+    return process.cwd();
+  },
+
+  pkgVersion() {
+    return pkg.version;
+  },
+
+  exit(code) {
+    process.exit(code);
+  },
+
+  logErrorExit1(err) {
+    logger.error(err.message);
+    process.exit(1);
+  },
+
+  dequote,
+
+  titleize(...args) {
+    // prepend first arg with space
+    // and pad so that all messages line up
+    args[0] = _.padEnd(` ${args[0]}`, 24); // get rid of any falsy values
+
+    args = _.compact(args);
+    return chalk.blue(...args);
+  },
+
+  calculateEta(percent, elapsed) {
+    // returns the number of seconds remaining
+    // if we're at 100% already just return 0
+    if (percent === 100) {
+      return 0;
+    } // take the percentage and divide by one
+    // and multiple that against elapsed
+    // subtracting what's already elapsed
+
+
+    return elapsed * (1 / (percent / 100)) - elapsed;
+  },
+
+  convertPercentToPercentage(num) {
+    // convert a percent with values between 0 and 1
+    // with decimals, so that it is between 0 and 100
+    // and has no decimal places
+    return Math.round(_.isFinite(num) ? num * 100 : 0);
+  },
+
+  secsRemaining(eta) {
+    // calculate the seconds reminaing with no decimal places
+    return (_.isFinite(eta) ? eta / 1000 : 0).toFixed(0);
+  },
+
+  setTaskTitle(task, title, renderer) {
+    // only update the renderer title when not running in CI
+    if (renderer === 'default' && task.title !== title) {
+      task.title = title;
+    }
+  },
+
+  isInstalledGlobally() {
+    return isInstalledGlobally;
+  },
+
+  isSemver(str) {
+    return /^(\d+\.)?(\d+\.)?(\*|\d+)$/.test(str);
+  },
+
+  isExecutableAsync(filePath) {
+    return Promise.resolve(executable(filePath));
+  },
+
+  isLinux,
+
+  getOsVersionAsync() {
+    return Promise.try(() => {
+      if (isLinux()) {
+        return getosAsync().then(osInfo => {
+          return [osInfo.dist, osInfo.release].join(' - ');
+        }).catch(() => {
+          return os.release();
+        });
+      }
+
+      return os.release();
+    });
+  },
+
+  getPlatformInfo() {
+    return util.getOsVersionAsync().then(version => {
+      return stripIndent`
+        Platform: ${os.platform()} (${version})
+        Cypress Version: ${util.pkgVersion()}
+      `;
+    });
+  },
+
+  // attention:
+  // when passing relative path to NPM post install hook, the current working
+  // directory is set to the `node_modules/cypress` folder
+  // the user is probably passing relative path with respect to root package folder
+  formAbsolutePath(filename) {
+    if (path.isAbsolute(filename)) {
+      return filename;
+    }
+
+    return path.join(process.cwd(), '..', '..', filename);
+  },
+
+  getEnv(varName, trim) {
+    la(is.unemptyString(varName), 'expected environment variable name, not', varName);
+    const configVarName = `npm_config_${varName}`;
+    const packageConfigVarName = `npm_package_config_${varName}`;
+    let result;
+
+    if (process.env.hasOwnProperty(varName)) {
+      debug(`Using ${varName} from environment variable`);
+      result = process.env[varName];
+    } else if (process.env.hasOwnProperty(configVarName)) {
+      debug(`Using ${varName} from npm config`);
+      result = process.env[configVarName];
+    } else if (process.env.hasOwnProperty(packageConfigVarName)) {
+      debug(`Using ${varName} from package.json config`);
+      result = process.env[packageConfigVarName];
+    } // environment variables are often set double quotes to escape characters
+    // and on Windows it can lead to weird things: for example
+    //  set FOO="C:\foo.txt" && node -e "console.log('>>>%s<<<', process.env.FOO)"
+    // will print
+    //    >>>"C:\foo.txt" <<<
+    // see https://github.com/cypress-io/cypress/issues/4506#issuecomment-506029942
+    // so for sanity sake we should first trim whitespace characters and remove
+    // double quotes around environment strings if the caller is expected to
+    // use this environment string as a file path
+
+
+    return trim ? dequote(_.trim(result)) : result;
+  },
+
+  getCacheDir() {
+    return cachedir('Cypress');
+  },
+
+  isPostInstall() {
+    return process.env.npm_lifecycle_event === 'postinstall';
+  },
+
+  exec: execa,
+  stdoutLineMatches,
+  issuesUrl,
+  isBrokenGtkDisplay,
+  logBrokenGtkDisplayWarning,
+  isPossibleLinuxWithIncorrectDisplay,
+
+  getGitHubIssueUrl(number) {
+    la(is.positive(number), 'github issue should be a positive number', number);
+    la(_.isInteger(number), 'github issue should be an integer', number);
+    return `${issuesUrl}/${number}`;
+  },
+
+  getFileChecksum,
+  getFileSize,
+  getApplicationDataFolder
+};
+module.exports = util;

node_modules/cypress/package.json

@@ -0,0 +1,117 @@
+{
+  "_from": "cypress",
+  "_id": "cypress@8.3.1",
+  "_inBundle": false,
+  "_integrity": "sha512-1v6pfx+/5cXhaT5T6QKOvnkawmEHWHLiVzm3MYMoQN1fkX2Ma1C32STd3jBStE9qT5qPSTILjGzypVRxCBi40g==",
+  "_location": "/cypress",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "cypress",
+    "name": "cypress",
+    "escapedName": "cypress",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#DEV:/",
+    "#USER"
+  ],
+  "_resolved": "https://registry.npmjs.org/cypress/-/cypress-8.3.1.tgz",
+  "_shasum": "c6760dbb907df2570b0e1ac235fa31c30f9260a6",
+  "_spec": "cypress",
+  "_where": "/home/simon/Documents/lifen-autotest/cypress_app",
+  "bin": {
+    "cypress": "bin/cypress"
+  },
+  "bugs": {
+    "url": "https://github.com/cypress-io/cypress/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@cypress/request": "^2.88.6",
+    "@cypress/xvfb": "^1.2.4",
+    "@types/node": "^14.14.31",
+    "@types/sinonjs__fake-timers": "^6.0.2",
+    "@types/sizzle": "^2.3.2",
+    "arch": "^2.2.0",
+    "blob-util": "^2.0.2",
+    "bluebird": "^3.7.2",
+    "cachedir": "^2.3.0",
+    "chalk": "^4.1.0",
+    "check-more-types": "^2.24.0",
+    "cli-cursor": "^3.1.0",
+    "cli-table3": "~0.6.0",
+    "commander": "^5.1.0",
+    "common-tags": "^1.8.0",
+    "dayjs": "^1.10.4",
+    "debug": "^4.3.2",
+    "enquirer": "^2.3.6",
+    "eventemitter2": "^6.4.3",
+    "execa": "4.1.0",
+    "executable": "^4.1.1",
+    "extract-zip": "2.0.1",
+    "figures": "^3.2.0",
+    "fs-extra": "^9.1.0",
+    "getos": "^3.2.1",
+    "is-ci": "^3.0.0",
+    "is-installed-globally": "~0.4.0",
+    "lazy-ass": "^1.6.0",
+    "listr2": "^3.8.3",
+    "lodash": "^4.17.21",
+    "log-symbols": "^4.0.0",
+    "minimist": "^1.2.5",
+    "ospath": "^1.2.2",
+    "pretty-bytes": "^5.6.0",
+    "ramda": "~0.27.1",
+    "request-progress": "^3.0.0",
+    "supports-color": "^8.1.1",
+    "tmp": "~0.2.1",
+    "untildify": "^4.0.0",
+    "url": "^0.11.0",
+    "yauzl": "^2.10.0"
+  },
+  "deprecated": false,
+  "description": "Cypress.io end to end testing tool",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "index.js",
+    "types/**/*.d.ts",
+    "types/net-stubbing.ts"
+  ],
+  "homepage": "https://github.com/cypress-io/cypress",
+  "keywords": [
+    "automation",
+    "browser",
+    "cypress",
+    "cypress.io",
+    "e2e",
+    "end-to-end",
+    "integration",
+    "mocks",
+    "runner",
+    "spies",
+    "stubs",
+    "test",
+    "testing"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "cypress",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cypress-io/cypress.git"
+  },
+  "scripts": {
+    "postinstall": "node index.js --exec install",
+    "size": "t=\"$(npm pack .)\"; wc -c \"${t}\"; tar tvf \"${t}\"; rm \"${t}\";"
+  },
+  "types": "types",
+  "version": "8.3.1"
+}

node_modules/cypress/types/cy-blob-util.d.ts

@@ -0,0 +1,13 @@
+// Shim definition to export a namespace. Cypress is actually a global module
+// so import/export isn't allowed there. We import here and define a global module
+// so that Cypress can get and use the Blob type
+
+// tslint:disable-next-line:no-implicit-dependencies
+import * as blobUtil from 'blob-util'
+
+export = BlobUtil
+export as namespace BlobUtil
+
+declare namespace BlobUtil {
+  type BlobUtilStatic = typeof blobUtil
+}

node_modules/cypress/types/cy-bluebird.d.ts

@@ -0,0 +1,11 @@
+// Shim definition to export a namespace. Cypress is actually a global module
+// so import/export isn't allowed there. We import here and define a global module
+// so that Cypress can get and use the Blob type
+import BluebirdStatic = require('./bluebird')
+
+export = Bluebird
+export as namespace Bluebird
+
+declare namespace Bluebird {
+  type BluebirdStatic = typeof BluebirdStatic
+}

node_modules/cypress/types/cy-chai.d.ts

@@ -0,0 +1,10 @@
+// Shim definition to export a namespace. Cypress is actually a global module
+// so import/export isn't allowed there. We import here and define a global module
+/// <reference path="./chai/index.d.ts" />
+declare namespace Chai {
+  interface Include {
+    html(html: string): Assertion
+    text(text: string): Assertion
+    value(text: string): Assertion
+  }
+}

node_modules/cypress/types/cy-http.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file should be deleted as soon as the serever
+ * TODO: delete this file when ResolvedDevServerConfig.server is converted to closeServer
+ */
+
+/// <reference types="node" />
+import * as cyUtilsHttp from 'http'
+export = cyUtilsHttp
+/**
+ * namespace created to bridge nodeJs.http typings so that
+ * we can type http Server in CT
+ */
+export as namespace cyUtilsHttp

node_modules/cypress/types/cy-minimatch.d.ts

@@ -0,0 +1,96 @@
+// I was trying to avoid relying on "import" of actual module from "minimatch"
+// because it would not work in test project, and the only reliable way
+// to get around type errors finally was to copy the minimal minimatch function
+// definition from "minimatch/index.d.ts" here and just keep it in our code
+
+export = Minimatch
+export as namespace Minimatch
+
+interface MinimatchOptions {
+  /**
+   * Dump a ton of stuff to stderr.
+   *
+   * @default false
+   */
+  debug?: boolean
+
+  /**
+   * Do not expand {a,b} and {1..3} brace sets.
+   *
+   * @default false
+   */
+  nobrace?: boolean
+
+  /**
+   * Disable ** matching against multiple folder names.
+   *
+   * @default false
+   */
+  noglobstar?: boolean
+
+  /**
+   * Allow patterns to match filenames starting with a period,
+   * even if the pattern does not explicitly have a period in that spot.
+   *
+   * @default false
+   */
+  dot?: boolean
+
+  /**
+   * Disable "extglob" style patterns like +(a|b).
+   *
+   * @default false
+   */
+  noext?: boolean
+
+  /**
+   * Perform a case-insensitive match.
+   *
+   * @default false
+   */
+  nocase?: boolean
+
+  /**
+   * When a match is not found by minimatch.match,
+   * return a list containing the pattern itself if this option is set.
+   * Otherwise, an empty list is returned if there are no matches.
+   *
+   * @default false
+   */
+  nonull?: boolean
+
+  /**
+   * If set, then patterns without slashes will be matched against
+   * the basename of the path if it contains slashes.
+   *
+   * @default false
+   */
+  matchBase?: boolean
+
+  /**
+   * Suppress the behavior of treating #
+   * at the start of a pattern as a comment.
+   *
+   * @default false
+   */
+  nocomment?: boolean
+
+  /**
+   * Suppress the behavior of treating a leading ! character as negation.
+   *
+   * @default false
+   */
+  nonegate?: boolean
+
+  /**
+   * Returns from negate expressions the same as if they were not negated.
+   * (Ie, true on a hit, false on a miss.)
+   *
+   * @default false
+   */
+  flipNegate?: boolean
+}
+
+declare namespace Minimatch {
+  function minimatch(target: string, pattern: string, options?: MinimatchOptions): boolean
+}

node_modules/cypress/types/cypress-eventemitter.d.ts

@@ -0,0 +1,29 @@
+// Cypress, cy, Log inherits EventEmitter.
+type EventEmitter2 = import("eventemitter2").EventEmitter2
+
+interface EventEmitter extends EventEmitter2 {
+  proxyTo: (cy: Cypress.cy) => null
+  emitMap: (eventName: string, args: any[]) => Array<(...args: any[]) => any>
+  emitThen: (eventName: string, args: any[]) => Bluebird.BluebirdStatic
+}
+
+// Copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/events.d.ts
+// to avoid type conflict.
+interface NodeEventEmitter {
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this
+  on(event: string | symbol, listener: (...args: any[]) => void): this
+  once(event: string | symbol, listener: (...args: any[]) => void): this
+  removeListener(event: string | symbol, listener: (...args: any[]) => void): this
+  off(event: string | symbol, listener: (...args: any[]) => void): this
+  removeAllListeners(event?: string | symbol): this
+  setMaxListeners(n: number): this
+  getMaxListeners(): number
+  listeners(event: string | symbol): Array<(...args: any[]) => void>
+  rawListeners(event: string | symbol): Array<(...args: any[]) => void>
+  emit(event: string | symbol, ...args: any[]): boolean
+  listenerCount(type: string | symbol): number
+  // Added in Node 6...
+  prependListener(event: string | symbol, listener: (...args: any[]) => void): this
+  prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this
+  eventNames(): Array<string | symbol>
+}

node_modules/cypress/types/cypress-expect.d.ts

@@ -0,0 +1,3 @@
+// Cypress adds chai expect and assert to global
+declare const expect: Chai.ExpectStatic
+declare const assert: Chai.AssertStatic

node_modules/cypress/types/cypress-global-vars.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Global variables `cy` added by Cypress with all API commands.
+ * @see https://on.cypress.io/api
+ *
+```
+cy.get('button').click()
+cy.get('.result').contains('Expected text')
+```
+ */
+declare const cy: Cypress.cy & EventEmitter
+
+/**
+ * Global variable `Cypress` holds common utilities and constants.
+ * @see https://on.cypress.io/api
+ *
+```
+Cypress.config("pageLoadTimeout") // => 60000
+Cypress.version // => "1.4.0"
+Cypress._ // => Lodash _
+```
+ */
+declare const Cypress: Cypress.Cypress & EventEmitter

node_modules/cypress/types/cypress-npm-api.d.ts

@@ -0,0 +1,385 @@
+//
+// Cypress NPM api type declarations
+// https://on.cypress.io/module-api
+// https://github.com/cypress-io/cypress/issues/2141
+//
+// in the future the NPM module itself will be in TypeScript
+// but for now describe it as an ambient module
+
+declare namespace CypressCommandLine {
+  type HookName = 'before' | 'beforeEach' | 'afterEach' | 'after'
+
+  interface TestError {
+    name: string
+    message: string
+    stack: string
+  }
+  /**
+   * All options that one can pass to "cypress.run"
+   * @see https://on.cypress.io/module-api#cypress-run
+   * @example
+    ```
+    const cypress = require('cypress')
+    cypress.run({
+      reporter: 'junit',
+      browser: 'chrome',
+      config: {
+        baseUrl: 'http://localhost:8080',
+        chromeWebSecurity: false,
+      },
+      env: {
+        foo: 'bar',
+        baz: 'quux',
+      }
+    })
+    ```
+   */
+  interface CypressRunOptions extends CypressCommonOptions {
+    /**
+     * Specify different browser to run tests in, either by name or by filesystem path
+    */
+    browser: string
+    /**
+     * Specify a unique identifier for a run to enable grouping or parallelization
+     */
+    ciBuildId: string
+    /**
+     * Group recorded tests together under a single run name
+     */
+    group: string
+    /**
+     * Tag string for the recorded run, like "production,nightly"
+     */
+    tag: string
+    /**
+     * Display the browser instead of running headlessly
+     */
+    headed: boolean
+    /**
+     * Hide the browser instead of running headed
+     */
+    headless: boolean
+    /**
+     * Specify your secret record key
+     */
+    key: string
+    /**
+     * Keep Cypress open after all tests run
+     */
+    noExit: boolean
+    /**
+     * Run recorded specs in parallel across multiple machines
+     */
+    parallel: boolean
+    /**
+     * Override default port
+     */
+    port: number
+    /**
+     * Run quietly, using only the configured reporter
+     */
+    quiet: boolean
+    /**
+     * Whether to record the test run
+     */
+    record: boolean
+    /**
+     * Specify a mocha reporter
+     */
+    reporter: string
+    /**
+     * Specify mocha reporter options
+     */
+    reporterOptions: any
+    /**
+     * Specify the specs to run
+     */
+    spec: string
+  }
+
+  /**
+   * All options that one can pass to "cypress.open"
+   * @see https://on.cypress.io/module-api#cypress-open
+   * @example
+    ```
+    const cypress = require('cypress')
+    cypress.open({
+      env: {
+        username: 'Joe Doe',
+        email: 'joe@acme.co'
+      },
+      project: '~/demos/my-project'
+    })
+    ```
+   */
+  interface CypressOpenOptions extends CypressCommonOptions {
+    /**
+     * Specify a filesystem path to a custom browser
+     */
+    browser: string
+    /**
+     * Open Cypress in detached mode
+     */
+    detached: boolean
+    /**
+     * Run in global mode
+     */
+    global: boolean
+    /**
+     * Override default port
+     */
+    port: number
+  }
+
+  /**
+   * Options available for `cypress.open` and `cypress.run`
+   */
+  interface CypressCommonOptions {
+    /**
+     * Specify configuration
+     */
+    config: Cypress.ConfigOptions
+    /**
+     * Path to the config file to be used.
+     *
+     * If `false` is passed, no config file will be used.
+     *
+     * @default "cypress.json"
+     */
+    configFile: string | false
+    /**
+     * Specify environment variables.
+     * TODO: isn't this duplicate of config.env?!
+     */
+    env: object
+    /**
+     * Path to a specific project
+     */
+    project: string
+    /**
+     * Specify the type of tests to execute.
+     * @default "e2e"
+     */
+    testingType: Cypress.TestingType
+  }
+
+  // small utility types to better express meaning of other types
+  type dateTimeISO = string
+  type ms = number
+  type pixels = number
+
+  /**
+   * Cypress single test result
+   */
+  interface TestResult {
+    title: string[]
+    state: string
+    body: string
+     /**
+     * Error string as it's presented in console if the test fails
+     */
+    displayError: string | null
+    attempts: AttemptResult[]
+  }
+
+  interface AttemptResult {
+    state: string
+    error: TestError | null
+    startedAt: dateTimeISO
+    duration: ms
+    videoTimestamp: ms
+    screenshots: ScreenshotInformation[]
+  }
+
+  /**
+   * Information about a single "before", "beforeEach", "afterEach" and "after" hook.
+  */
+  interface HookInformation {
+    hookName: HookName
+    title: string[]
+    body: string
+  }
+
+  /**
+   * Information about a single screenshot.
+   */
+  interface ScreenshotInformation {
+    name: string
+    takenAt: dateTimeISO
+    /**
+     * Absolute path to the saved image
+     */
+    path: string
+    height: pixels
+    width: pixels
+  }
+
+  /**
+   * Cypress test run result for a single spec.
+  */
+  interface RunResult {
+    /**
+     * Accurate test results collected by Cypress.
+     */
+    stats: {
+      suites: number
+      tests: number
+      passes: number
+      pending: number
+      skipped: number
+      failures: number
+      startedAt: dateTimeISO
+      endedAt: dateTimeISO
+      duration: ms
+    }
+    /**
+     * Reporter name like "spec"
+     */
+    reporter: string
+    /**
+     * This is controlled by the reporter, and Cypress cannot guarantee
+     * the properties. Usually this object has suites, tests, passes, etc
+     */
+    reporterStats: object
+    hooks: HookInformation[]
+    tests: TestResult[]
+    error: string | null
+    video: string | null
+    /**
+     * information about the spec test file.
+    */
+    spec: {
+      /**
+       * filename like "spec.js"
+       */
+      name: string
+      /**
+       * name relative to the project root, like "cypress/integration/spec.js"
+      */
+      relative: string
+      /**
+       * resolved filename of the spec
+       */
+      absolute: string
+    }
+    shouldUploadVideo: boolean
+  }
+
+  /**
+   * Results returned by the test run.
+   * @see https://on.cypress.io/module-api
+   */
+  interface CypressRunResult {
+    status: 'finished'
+    startedTestsAt: dateTimeISO
+    endedTestsAt: dateTimeISO
+    totalDuration: ms
+    totalSuites: number
+    totalTests: number
+    totalFailed: number
+    totalPassed: number
+    totalPending: number
+    totalSkipped: number
+    /**
+     * If Cypress test run is being recorded, full url will be provided.
+     * @see https://on.cypress.io/dashboard-introduction
+     */
+    runUrl?: string
+    runs: RunResult[]
+    browserPath: string
+    browserName: string
+    browserVersion: string
+    osName: string
+    osVersion: string
+    cypressVersion: string
+    config: Cypress.ResolvedConfigOptions
+  }
+
+  /**
+     * If Cypress fails to run at all (for example, if there are no spec files to run),
+     * then it will return a CypressFailedRunResult. Check the failures attribute.
+     * @example
+      ```
+      const result = await cypress.run()
+      if (result.status === 'failed') {
+        console.error('failures %d', result.failures)
+        console.error(result.message)
+        process.exit(result.failures)
+      }
+      ```
+     *
+  **/
+  interface CypressFailedRunResult {
+    status: 'failed'
+    failures: number
+    message: string
+  }
+
+  /**
+   * Methods allow parsing given CLI arguments the same way Cypress CLI does it.
+   */
+  interface CypressCliParser {
+    /**
+     * Parses the given array of string arguments to "cypress run"
+     * just like Cypress CLI does it.
+     * @see https://on.cypress.io/module-api
+     * @example
+     *  const cypress = require('cypress')
+     *  const args = ['cypress', 'run', '--browser', 'chrome']
+     *  const options = await cypress.cli.parseRunArguments(args)
+     *  // options is {browser: 'chrome'}
+     *  // pass the options to cypress.run()
+     *  const results = await cypress.run(options)
+     */
+    parseRunArguments(args: string[]): Promise<Partial<CypressRunOptions>>
+  }
+}
+
+declare module 'cypress' {
+  /**
+   * Cypress NPM module interface.
+   * @see https://on.cypress.io/module-api
+   * @example
+    ```
+    const cypress = require('cypress')
+    cypress.run().then(results => ...)
+    ```
+  */
+  interface CypressNpmApi {
+    /**
+     * Execute a headless Cypress test run.
+     * @see https://on.cypress.io/module-api#cypress-run
+     * @example
+     ```
+     const cypress = require('cypress')
+     // runs all spec files matching a wildcard
+     cypress.run({
+       spec: 'cypress/integration/admin*-spec.js'
+     }).then(results => {
+       if (results.status === 'failed') {
+          // Cypress could not run
+        } else {
+          // inspect results object
+       }
+     })
+     ```
+     */
+    run(options?: Partial<CypressCommandLine.CypressRunOptions>): Promise<CypressCommandLine.CypressRunResult | CypressCommandLine.CypressFailedRunResult>
+    /**
+     * Opens Cypress GUI. Resolves with void when the
+     * GUI is closed.
+     * @see https://on.cypress.io/module-api#cypress-open
+     */
+    open(options?: Partial<CypressCommandLine.CypressOpenOptions>): Promise<void>
+
+    /**
+     * Utility functions for parsing CLI arguments the same way
+     * Cypress does
+     */
+    cli: CypressCommandLine.CypressCliParser
+  }
+
+  // export Cypress NPM module interface
+  const cypress: CypressNpmApi
+  export = cypress
+}

node_modules/cypress/types/cypress-type-helpers.d.ts

@@ -0,0 +1,2 @@
+// type helpers
+type Nullable<T> = T | null

node_modules/cypress/types/index.d.ts

@@ -0,0 +1,33 @@
+// Project: https://www.cypress.io
+// GitHub:  https://github.com/cypress-io/cypress
+// Definitions by: Gert Hengeveld <https://github.com/ghengeveld>
+//                 Mike Woudenberg <https://github.com/mikewoudenberg>
+//                 Robbert van Markus <https://github.com/rvanmarkus>
+//                 Nicholas Boll <https://github.com/nicholasboll>
+// TypeScript Version: 3.4
+// Updated by the Cypress team: https://www.cypress.io/about/
+
+/// <reference path="./cy-blob-util.d.ts" />
+/// <reference path="./cy-bluebird.d.ts" />
+/// <reference path="./cy-minimatch.d.ts" />
+/// <reference path="./cy-chai.d.ts" />
+/// <reference path="./lodash/index.d.ts" />
+/// <reference path="./sinon/index.d.ts" />
+/// <reference path="./sinon-chai/index.d.ts" />
+/// <reference path="./mocha/index.d.ts" />
+/// <reference path="./jquery/index.d.ts" />
+/// <reference path="./chai-jquery/index.d.ts" />
+
+// jQuery includes dependency "sizzle" that provides types
+// so we include it too in "node_modules/sizzle".
+// This way jQuery can load it using 'reference types="sizzle"' directive
+
+// load ambient declaration for "cypress" NPM module
+// hmm, how to load it better?
+/// <reference path="./cypress-npm-api.d.ts" />
+
+/// <reference path="./net-stubbing.ts" />
+/// <reference path="./cypress.d.ts" />
+/// <reference path="./cypress-global-vars.d.ts" />
+/// <reference path="./cypress-type-helpers.d.ts" />
+/// <reference path="./cypress-expect.d.ts" />

node_modules/cypress/types/jquery/index.d.ts

@@ -0,0 +1,34 @@
+// Type definitions for jquery 3.3
+// Project: https://jquery.com
+// Definitions by: Leonard Thieu <https://github.com/leonard-thieu>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Christian Hoffmeister <https://github.com/choffmeister>
+//                 Steve Fenton <https://github.com/Steve-Fenton>
+//                 Diullei Gomes <https://github.com/Diullei>
+//                 Tass Iliopoulos <https://github.com/tasoili>
+//                 Jason Swearingen <https://github.com/jasons-novaleaf>
+//                 Sean Hill <https://github.com/seanski>
+//                 Guus Goossens <https://github.com/Guuz>
+//                 Kelly Summerlin <https://github.com/ksummerlin>
+//                 Basarat Ali Syed <https://github.com/basarat>
+//                 Nicholas Wolverson <https://github.com/nwolverson>
+//                 Derek Cicerone <https://github.com/derekcicerone>
+//                 Andrew Gaspar <https://github.com/AndrewGaspar>
+//                 Seikichi Kondo <https://github.com/seikichi>
+//                 Benjamin Jackman <https://github.com/benjaminjackman>
+//                 Poul Sorensen <https://github.com/s093294>
+//                 Josh Strobl <https://github.com/JoshStrobl>
+//                 John Reilly <https://github.com/johnnyreilly>
+//                 Dick van den Brink <https://github.com/DickvdBrink>
+//                 Thomas Schulz <https://github.com/King2500>
+//                 Terry Mun <https://github.com/terrymun>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/// <reference types="sizzle" />
+/// <reference path="JQueryStatic.d.ts" />
+/// <reference path="JQuery.d.ts" />
+/// <reference path="misc.d.ts" />
+/// <reference path="legacy.d.ts" />
+
+export = jQuery;

node_modules/cypress/types/jquery/legacy.d.ts

@@ -0,0 +1,204 @@
+// tslint:disable:no-irregular-whitespace
+
+// tslint:disable-next-line:no-empty-interface
+interface JQueryCallback extends JQuery.Callbacks { }
+interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryEventConstructor extends JQuery.EventStatic { }
+interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryAjaxSettings extends JQuery.AjaxSettings { }
+interface JQueryAnimationOptions extends JQuery.EffectsOptions<Element> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryCoordinates extends JQuery.Coordinates { }
+interface JQueryGenericPromise<T> extends JQuery.Thenable<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryXHR extends JQuery.jqXHR { }
+interface JQueryPromise<T> extends JQuery.Promise<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQuerySerializeArrayElement extends JQuery.NameValuePair { }
+
+/**
+ * @deprecated ​ Deprecated since 1.9. See \`{@link https://api.jquery.com/jQuery.support/ }\`.
+ */
+// tslint:disable-next-line:no-empty-interface
+interface JQuerySupport extends JQuery.PlainObject { }
+
+// Legacy types that are not represented in the current type definitions are marked deprecated.
+
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Deferred.Callback }\` or \`{@link JQuery.Deferred.CallbackBase }\`.
+ */
+interface JQueryPromiseCallback<T> {
+    // tslint:disable-next-line:callable-types
+    (value?: T, ...args: any[]): void;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQueryStatic.param JQueryStatic&#91;'param'&#93;}\`.
+ */
+interface JQueryParam {
+    /**
+     * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request.
+     * @param obj An array or object to serialize.
+     * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization.
+     */
+    // tslint:disable-next-line:callable-types
+    (obj: any, traditional?: boolean): string;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface BaseJQueryEventObject extends Event {
+    /**
+     * The current DOM element within the event bubbling phase.
+     * @see \`{@link https://api.jquery.com/event.currentTarget/ }\`
+     */
+    currentTarget: Element;
+    /**
+     * An optional object of data passed to an event method when the current executing handler is bound.
+     * @see \`{@link https://api.jquery.com/event.data/ }\`
+     */
+    data: any;
+    /**
+     * The element where the currently-called jQuery event handler was attached.
+     * @see \`{@link https://api.jquery.com/event.delegateTarget/ }\`
+     */
+    delegateTarget: Element;
+    /**
+     * Returns whether event.preventDefault() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isDefaultPrevented/ }\`
+     */
+    isDefaultPrevented(): boolean;
+    /**
+     * Returns whether event.stopImmediatePropagation() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isImmediatePropagationStopped/ }\`
+     */
+    isImmediatePropagationStopped(): boolean;
+    /**
+     * Returns whether event.stopPropagation() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isPropagationStopped/ }\`
+     */
+    isPropagationStopped(): boolean;
+    /**
+     * The namespace specified when the event was triggered.
+     * @see \`{@link https://api.jquery.com/event.namespace/ }\`
+     */
+    namespace: string;
+    /**
+     * The browser's original Event object.
+     * @see \`{@link https://api.jquery.com/category/events/event-object/ }\`
+     */
+    originalEvent: Event;
+    /**
+     * If this method is called, the default action of the event will not be triggered.
+     * @see \`{@link https://api.jquery.com/event.preventDefault/ }\`
+     */
+    preventDefault(): any;
+    /**
+     * The other DOM element involved in the event, if any.
+     * @see \`{@link https://api.jquery.com/event.relatedTarget/ }\`
+     */
+    relatedTarget: Element;
+    /**
+     * The last value returned by an event handler that was triggered by this event, unless the value was undefined.
+     * @see \`{@link https://api.jquery.com/event.result/ }\`
+     */
+    result: any;
+    /**
+     * Keeps the rest of the handlers from being executed and prevents the event from bubbling up the DOM tree.
+     * @see \`{@link https://api.jquery.com/event.stopImmediatePropagation/ }\`
+     */
+    stopImmediatePropagation(): void;
+    /**
+     * Prevents the event from bubbling up the DOM tree, preventing any parent handlers from being notified of the event.
+     * @see \`{@link https://api.jquery.com/event.stopPropagation/ }\`
+     */
+    stopPropagation(): void;
+    /**
+     * The DOM element that initiated the event.
+     * @see \`{@link https://api.jquery.com/event.target/ }\`
+     */
+    target: Element;
+    /**
+     * The mouse position relative to the left edge of the document.
+     * @see \`{@link https://api.jquery.com/event.pageX/ }\`
+     */
+    pageX: number;
+    /**
+     * The mouse position relative to the top edge of the document.
+     * @see \`{@link https://api.jquery.com/event.pageY/ }\`
+     */
+    pageY: number;
+    /**
+     * For key or mouse events, this property indicates the specific key or button that was pressed.
+     * @see \`{@link https://api.jquery.com/event.which/ }\`
+     */
+    which: number;
+    /**
+     * Indicates whether the META key was pressed when the event fired.
+     * @see \`{@link https://api.jquery.com/event.metaKey/ }\`
+     */
+    metaKey: boolean;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryInputEventObject extends BaseJQueryEventObject {
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryMouseEventObject extends JQueryInputEventObject {
+    button: number;
+    clientX: number;
+    clientY: number;
+    offsetX: number;
+    offsetY: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryKeyEventObject extends JQueryInputEventObject {
+    /** @deprecated */
+    char: string;
+    /** @deprecated */
+    charCode: number;
+    key: string;
+    /** @deprecated */
+    keyCode: number;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryEventObject extends BaseJQueryEventObject, JQueryInputEventObject, JQueryMouseEventObject, JQueryKeyEventObject { }
+/**
+ * @deprecated ​ Deprecated.
+ */
+interface JQueryPromiseOperator<T, U> {
+    // tslint:disable-next-line:callable-types
+    (callback1: JQuery.TypeOrArray<JQueryPromiseCallback<T>>,
+     ...callbacksN: Array<JQuery.TypeOrArray<JQueryPromiseCallback<any>>>): JQueryPromise<U>;
+}
+/**
+ * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
+ */
+interface JQueryEasingFunction {
+    // tslint:disable-next-line:callable-types
+    (percent: number): number;
+}
+/**
+ * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
+ */
+interface JQueryEasingFunctions {
+    [name: string]: JQueryEasingFunction;
+    linear: JQueryEasingFunction;
+    swing: JQueryEasingFunction;
+}

node_modules/cypress/types/lodash/add.d.ts

@@ -0,0 +1,2 @@
+import { add } from "./index";
+export = add;

node_modules/cypress/types/lodash/after.d.ts

@@ -0,0 +1,2 @@
+import { after } from "./index";
+export = after;

node_modules/cypress/types/lodash/ary.d.ts

@@ -0,0 +1,2 @@
+import { ary } from "./index";
+export = ary;

node_modules/cypress/types/lodash/assign.d.ts

@@ -0,0 +1,2 @@
+import { assign } from "./index";
+export = assign;

node_modules/cypress/types/lodash/assignIn.d.ts

@@ -0,0 +1,2 @@
+import { assignIn } from "./index";
+export = assignIn;

node_modules/cypress/types/lodash/assignInWith.d.ts

@@ -0,0 +1,2 @@
+import { assignInWith } from "./index";
+export = assignInWith;

node_modules/cypress/types/lodash/assignWith.d.ts

@@ -0,0 +1,2 @@
+import { assignWith } from "./index";
+export = assignWith;

node_modules/cypress/types/lodash/at.d.ts

@@ -0,0 +1,2 @@
+import { at } from "./index";
+export = at;

node_modules/cypress/types/lodash/attempt.d.ts

@@ -0,0 +1,2 @@
+import { attempt } from "./index";
+export = attempt;

node_modules/cypress/types/lodash/before.d.ts

@@ -0,0 +1,2 @@
+import { before } from "./index";
+export = before;

node_modules/cypress/types/lodash/bind.d.ts

@@ -0,0 +1,2 @@
+import { bind } from "./index";
+export = bind;

node_modules/cypress/types/lodash/bindAll.d.ts

@@ -0,0 +1,2 @@
+import { bindAll } from "./index";
+export = bindAll;

node_modules/cypress/types/lodash/bindKey.d.ts

@@ -0,0 +1,2 @@
+import { bindKey } from "./index";
+export = bindKey;

node_modules/cypress/types/lodash/camelCase.d.ts

@@ -0,0 +1,2 @@
+import { camelCase } from "./index";
+export = camelCase;

node_modules/cypress/types/lodash/capitalize.d.ts

@@ -0,0 +1,2 @@
+import { capitalize } from "./index";
+export = capitalize;

node_modules/cypress/types/lodash/castArray.d.ts

@@ -0,0 +1,2 @@
+import { castArray } from "./index";
+export = castArray;

node_modules/cypress/types/lodash/ceil.d.ts

@@ -0,0 +1,2 @@
+import { ceil } from "./index";
+export = ceil;

node_modules/cypress/types/lodash/chain.d.ts

@@ -0,0 +1,2 @@
+import { chain } from "./index";
+export = chain;

node_modules/cypress/types/lodash/chunk.d.ts

@@ -0,0 +1,2 @@
+import { chunk } from "./index";
+export = chunk;

node_modules/cypress/types/lodash/clamp.d.ts

@@ -0,0 +1,2 @@
+import { clamp } from "./index";
+export = clamp;

node_modules/cypress/types/lodash/clone.d.ts

@@ -0,0 +1,2 @@
+import { clone } from "./index";
+export = clone;

node_modules/cypress/types/lodash/cloneDeep.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeep } from "./index";
+export = cloneDeep;

node_modules/cypress/types/lodash/cloneDeepWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeepWith } from "./index";
+export = cloneDeepWith;

node_modules/cypress/types/lodash/cloneWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneWith } from "./index";
+export = cloneWith;

node_modules/cypress/types/lodash/common/common.d.ts

@@ -0,0 +1,280 @@
+import _ = require("../index");
+// tslint:disable-next-line:strict-export-declare-modifiers
+type GlobalPartial<T> = Partial<T>;
+declare module "../index" {
+    type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+    type PartialObject<T> = GlobalPartial<T>;
+    type Many<T> = T | ReadonlyArray<T>;
+    type ImpChain<T> =
+        T extends { __trapAny: any } ? Collection<any> & Function<any> & Object<any> & Primitive<any> & String :
+        T extends null | undefined ? never :
+        T extends string | null | undefined ? String :
+        T extends (...args: any) => any ? Function<T> :
+        T extends List<infer U> | null | undefined ? Collection<U> :
+        T extends object | null | undefined ? Object<T> :
+        Primitive<T>;
+    type ExpChain<T> =
+        T extends { __trapAny: any } ? CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain :
+        T extends null | undefined ? never :
+        T extends string ? StringChain :
+        T extends string | null | undefined ? StringNullableChain :
+        T extends (...args: any) => any ? FunctionChain<T> :
+        T extends List<infer U> | null | undefined ? CollectionChain<U> :
+        T extends object | null | undefined ? ObjectChain<T> :
+        PrimitiveChain<T>;
+    interface LoDashStatic {
+        /**
+        * Creates a lodash object which wraps value to enable implicit method chain sequences.
+        * Methods that operate on and return arrays, collections, and functions can be chained together.
+        * Methods that retrieve a single value or may return a primitive value will automatically end the
+        * chain sequence and return the unwrapped value. Otherwise, the value must be unwrapped with value().
+        *
+        * Explicit chain sequences, which must be unwrapped with value(), may be enabled using _.chain.
+        *
+        * The execution of chained methods is lazy, that is, it's deferred until value() is
+        * implicitly or explicitly called.
+        *
+        * Lazy evaluation allows several methods to support shortcut fusion. Shortcut fusion
+        * is an optimization to merge iteratee calls; this avoids the creation of intermediate
+        * arrays and can greatly reduce the number of iteratee executions. Sections of a chain
+        * sequence qualify for shortcut fusion if the section is applied to an array and iteratees
+        * accept only one argument. The heuristic for whether a section qualifies for shortcut
+        * fusion is subject to change.
+        *
+        * Chaining is supported in custom builds as long as the value() method is directly or
+        * indirectly included in the build.
+        *
+        * In addition to lodash methods, wrappers have Array and String methods.
+        * The wrapper Array methods are:
+        * concat, join, pop, push, shift, sort, splice, and unshift.
+        * The wrapper String methods are:
+        * replace and split.
+        *
+        * The wrapper methods that support shortcut fusion are:
+        * at, compact, drop, dropRight, dropWhile, filter, find, findLast, head, initial, last,
+        * map, reject, reverse, slice, tail, take, takeRight, takeRightWhile, takeWhile, and toArray
+        *
+        * The chainable wrapper methods are:
+        * after, ary, assign, assignIn, assignInWith, assignWith, at, before, bind, bindAll, bindKey,
+        * castArray, chain, chunk, commit, compact, concat, conforms, constant, countBy, create,
+        * curry, debounce, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith,
+        * drop, dropRight, dropRightWhile, dropWhile, extend, extendWith, fill, filter, flatMap,
+        * flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, flow, flowRight,
+        * fromPairs, functions, functionsIn, groupBy, initial, intersection, intersectionBy, intersectionWith,
+        * invert, invertBy, invokeMap, iteratee, keyBy, keys, keysIn, map, mapKeys, mapValues,
+        * matches, matchesProperty, memoize, merge, mergeWith, method, methodOf, mixin, negate,
+        * nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, partial, partialRight,
+        * partition, pick, pickBy, plant, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt,
+        * push, range, rangeRight, rearg, reject, remove, rest, reverse, sampleSize, set, setWith,
+        * shuffle, slice, sort, sortBy, sortedUniq, sortedUniqBy, splice, spread, tail, take,
+        * takeRight, takeRightWhile, takeWhile, tap, throttle, thru, toArray, toPairs, toPairsIn,
+        * toPath, toPlainObject, transform, unary, union, unionBy, unionWith, uniq, uniqBy, uniqWith,
+        * unset, unshift, unzip, unzipWith, update, updateWith, values, valuesIn, without, wrap,
+        * xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, and zipWith.
+        *
+        * The wrapper methods that are not chainable by default are:
+        * add, attempt, camelCase, capitalize, ceil, clamp, clone, cloneDeep, cloneDeepWith, cloneWith,
+        * conformsTo, deburr, defaultTo, divide, each, eachRight, endsWith, eq, escape, escapeRegExp,
+        * every, find, findIndex, findKey, findLast, findLastIndex, findLastKey, first, floor, forEach,
+        * forEachRight, forIn, forInRight, forOwn, forOwnRight, get, gt, gte, has, hasIn, head,
+        * identity, includes, indexOf, inRange, invoke, isArguments, isArray, isArrayBuffer,
+        * isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith,
+        * isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN,
+        * isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp,
+        * isSafeInteger, isSet, isString, isUndefined, isTypedArray, isWeakMap, isWeakSet, join,
+        * kebabCase, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, max, maxBy, mean, meanBy,
+        * min, minBy, multiply, noConflict, noop, now, nth, pad, padEnd, padStart, parseInt, pop,
+        * random, reduce, reduceRight, repeat, result, round, runInContext, sample, shift, size,
+        * snakeCase, some, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy, startCase,
+        * startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy,
+        * template, times, toFinite, toInteger, toJSON, toLength, toLower, toNumber, toSafeInteger,
+        * toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase,
+        * upperFirst, value, and words.
+        **/
+        <TrapAny extends { __trapAny: any }>(value: TrapAny): Collection<any> & Function<any> & Object<any> & Primitive<any> & String;
+        <T extends null | undefined>(value: T): Primitive<T>;
+        (value: string | null | undefined): String;
+        <T extends (...args: any) => any>(value: T): Function<T>;
+        <T = any>(value: List<T> | null | undefined): Collection<T>;
+        <T extends object>(value: T | null | undefined): Object<T>;
+        <T>(value: T): Primitive<T>;
+        /**
+        * The semantic version number.
+        **/
+        VERSION: string;
+        /**
+        * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+        * (ERB). Change the following template settings to use alternative delimiters.
+        **/
+        templateSettings: TemplateSettings;
+    }
+    /**
+    * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+    * (ERB). Change the following template settings to use alternative delimiters.
+    **/
+    interface TemplateSettings {
+        /**
+        * The "escape" delimiter.
+        **/
+        escape?: RegExp;
+        /**
+        * The "evaluate" delimiter.
+        **/
+        evaluate?: RegExp;
+        /**
+        * An object to import into the template as local variables.
+        */
+        imports?: Dictionary<any>;
+        /**
+        * The "interpolate" delimiter.
+        */
+        interpolate?: RegExp;
+        /**
+        * Used to reference the data object in the template text.
+        */
+        variable?: string;
+    }
+    /**
+     * Creates a cache object to store key/value pairs.
+     */
+    interface MapCache {
+        /**
+         * Removes `key` and its value from the cache.
+         * @param key The key of the value to remove.
+         * @return Returns `true` if the entry was removed successfully, else `false`.
+         */
+        delete(key: any): boolean;
+        /**
+         * Gets the cached value for `key`.
+         * @param key The key of the value to get.
+         * @return Returns the cached value.
+         */
+        get(key: any): any;
+        /**
+         * Checks if a cached value for `key` exists.
+         * @param key The key of the entry to check.
+         * @return Returns `true` if an entry for `key` exists, else `false`.
+         */
+        has(key: any): boolean;
+        /**
+         * Sets `value` to `key` of the cache.
+         * @param key The key of the value to cache.
+         * @param value The value to cache.
+         * @return Returns the cache object.
+         */
+        set(key: any, value: any): this;
+        /**
+         * Removes all key-value entries from the map.
+         */
+        clear?: () => void;
+    }
+    interface MapCacheConstructor {
+        new (): MapCache;
+    }
+    interface Collection<T> {
+        pop(): T | undefined;
+        push(...items: T[]): this;
+        shift(): T | undefined;
+        sort(compareFn?: (a: T, b: T) => number): this;
+        splice(start: number, deleteCount?: number, ...items: T[]): this;
+        unshift(...items: T[]): this;
+    }
+    interface CollectionChain<T> {
+        pop(): ExpChain<T | undefined>;
+        push(...items: T[]): this;
+        shift(): ExpChain<T | undefined>;
+        sort(compareFn?: (a: T, b: T) => number): this;
+        splice(start: number, deleteCount?: number, ...items: T[]): this;
+        unshift(...items: T[]): this;
+    }
+    interface Function<T extends (...args: any) => any> extends LoDashImplicitWrapper<T> {
+    }
+    interface String extends LoDashImplicitWrapper<string> {
+    }
+    interface Object<T> extends LoDashImplicitWrapper<T> {
+    }
+    interface Collection<T> extends LoDashImplicitWrapper<T[]> {
+    }
+    interface Primitive<T> extends LoDashImplicitWrapper<T> {
+    }
+    interface FunctionChain<T extends (...args: any) => any> extends LoDashExplicitWrapper<T> {
+    }
+    interface StringChain extends LoDashExplicitWrapper<string> {
+    }
+    interface StringNullableChain extends LoDashExplicitWrapper<string | undefined> {
+    }
+    interface ObjectChain<T> extends LoDashExplicitWrapper<T> {
+    }
+    interface CollectionChain<T> extends LoDashExplicitWrapper<T[]> {
+    }
+    interface PrimitiveChain<T> extends LoDashExplicitWrapper<T> {
+    }
+    type NotVoid = unknown;
+    type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialShallow<T>;
+    type ArrayIterator<T, TResult> = (value: T, index: number, collection: T[]) => TResult;
+    type ListIterator<T, TResult> = (value: T, index: number, collection: List<T>) => TResult;
+    type ListIteratee<T> = ListIterator<T, NotVoid> | IterateeShorthand<T>;
+    type ListIterateeCustom<T, TResult> = ListIterator<T, TResult> | IterateeShorthand<T>;
+    type ListIteratorTypeGuard<T, S extends T> = (value: T, index: number, collection: List<T>) => value is S;
+    // Note: key should be string, not keyof T, because the actual object may contain extra properties that were not specified in the type.
+    type ObjectIterator<TObject, TResult> = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult;
+    type ObjectIteratee<TObject> = ObjectIterator<TObject, NotVoid> | IterateeShorthand<TObject[keyof TObject]>;
+    type ObjectIterateeCustom<TObject, TResult> = ObjectIterator<TObject, TResult> | IterateeShorthand<TObject[keyof TObject]>;
+    type ObjectIteratorTypeGuard<TObject, S extends TObject[keyof TObject]> = (value: TObject[keyof TObject], key: string, collection: TObject) => value is S;
+    type StringIterator<TResult> = (char: string, index: number, string: string) => TResult;
+    /** @deprecated Use MemoVoidArrayIterator or MemoVoidDictionaryIterator instead. */
+    type MemoVoidIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => void;
+    /** @deprecated Use MemoListIterator or MemoObjectIterator instead. */
+    type MemoIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => TResult;
+    type MemoListIterator<T, TResult, TList> = (prev: TResult, curr: T, index: number, list: TList) => TResult;
+    type MemoObjectIterator<T, TResult, TList> = (prev: TResult, curr: T, key: string, list: TList) => TResult;
+    type MemoIteratorCapped<T, TResult> = (prev: TResult, curr: T) => TResult;
+    type MemoIteratorCappedRight<T, TResult> = (curr: T, prev: TResult) => TResult;
+    type MemoVoidArrayIterator<T, TResult> = (acc: TResult, curr: T, index: number, arr: T[]) => void;
+    type MemoVoidDictionaryIterator<T, K extends string | number | symbol, TResult> = (acc: TResult, curr: T, key: K, dict: Record<K, T>) => void;
+    type MemoVoidIteratorCapped<T, TResult> = (acc: TResult, curr: T) => void;
+    type ValueIteratee<T> = ((value: T) => NotVoid) | IterateeShorthand<T>;
+    type ValueIterateeCustom<T, TResult> = ((value: T) => TResult) | IterateeShorthand<T>;
+    type ValueIteratorTypeGuard<T, S extends T> = (value: T) => value is S;
+    type ValueKeyIteratee<T> = ((value: T, key: string) => NotVoid) | IterateeShorthand<T>;
+    type ValueKeyIterateeTypeGuard<T, S extends T> = (value: T, key: string) => value is S;
+    type Comparator<T> = (a: T, b: T) => boolean;
+    type Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
+    type PropertyName = string | number | symbol;
+    type PropertyPath = Many<PropertyName>;
+    /** Common interface between Arrays and jQuery objects */
+    type List<T> = ArrayLike<T>;
+    interface Dictionary<T> {
+        [index: string]: T;
+    }
+    interface NumericDictionary<T> {
+        [index: number]: T;
+    }
+    // Crazy typedef needed get _.omit to work properly with Dictionary and NumericDictionary
+    type AnyKindOfDictionary =
+        | Dictionary<unknown>
+        | NumericDictionary<unknown>;
+    type PartialShallow<T> = {
+        [P in keyof T]?: T[P] extends object ? object : T[P]
+    };
+    // For backwards compatibility
+    type LoDashImplicitArrayWrapper<T> = LoDashImplicitWrapper<T[]>;
+    type LoDashImplicitNillableArrayWrapper<T> = LoDashImplicitWrapper<T[] | null | undefined>;
+    type LoDashImplicitObjectWrapper<T> = LoDashImplicitWrapper<T>;
+    type LoDashImplicitNillableObjectWrapper<T> = LoDashImplicitWrapper<T | null | undefined>;
+    type LoDashImplicitNumberArrayWrapper = LoDashImplicitWrapper<number[]>;
+    type LoDashImplicitStringWrapper = LoDashImplicitWrapper<string>;
+    type LoDashExplicitArrayWrapper<T> = LoDashExplicitWrapper<T[]>;
+    type LoDashExplicitNillableArrayWrapper<T> = LoDashExplicitWrapper<T[] | null | undefined>;
+    type LoDashExplicitObjectWrapper<T> = LoDashExplicitWrapper<T>;
+    type LoDashExplicitNillableObjectWrapper<T> = LoDashExplicitWrapper<T | null | undefined>;
+    type LoDashExplicitNumberArrayWrapper = LoDashExplicitWrapper<number[]>;
+    type LoDashExplicitStringWrapper = LoDashExplicitWrapper<string>;
+    type DictionaryIterator<T, TResult> = ObjectIterator<Dictionary<T>, TResult>;
+    type DictionaryIteratee<T> = ObjectIteratee<Dictionary<T>>;
+    type DictionaryIteratorTypeGuard<T, S extends T> = ObjectIteratorTypeGuard<Dictionary<T>, S>;
+    // NOTE: keys of objects at run time are always strings, even when a NumericDictionary is being iterated.
+    type NumericDictionaryIterator<T, TResult> = (value: T, key: string, collection: NumericDictionary<T>) => TResult;
+    type NumericDictionaryIteratee<T> = NumericDictionaryIterator<T, NotVoid> | IterateeShorthand<T>;
+    type NumericDictionaryIterateeCustom<T, TResult> = NumericDictionaryIterator<T, TResult> | IterateeShorthand<T>;
+}

node_modules/cypress/types/lodash/common/date.d.ts

@@ -0,0 +1,23 @@
+import _ = require("../index");
+declare module "../index" {
+    interface LoDashStatic {
+        /*
+         * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC).
+         *
+         * @return The number of milliseconds.
+         */
+        now(): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.now
+         */
+        now(): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.now
+         */
+        now(): PrimitiveChain<number>;
+    }
+}

node_modules/cypress/types/lodash/common/math.d.ts

@@ -0,0 +1,405 @@
+import _ = require("../index");
+declare module "../index" {
+    interface LoDashStatic {
+        /**
+         * Adds two numbers.
+         *
+         * @param augend The first number to add.
+         * @param addend The second number to add.
+         * @return Returns the sum.
+         */
+        add(augend: number, addend: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.add
+         */
+        add(addend: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.add
+         */
+        add(addend: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded up to precision.
+         *
+         * @param n The number to round up.
+         * @param precision The precision to round up to.
+         * @return Returns the rounded up number.
+         */
+        ceil(n: number, precision?: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.ceil
+         */
+        ceil(precision?: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.ceil
+         */
+        ceil(precision?: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+        * Divide two numbers.
+        *
+        * @param dividend The first number in a division.
+        * @param divisor The second number in a division.
+        * @returns Returns the quotient.
+         */
+        divide(dividend: number, divisor: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.divide
+         */
+        divide(divisor: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.divide
+         */
+        divide(divisor: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded down to precision.
+         *
+         * @param n The number to round down.
+         * @param precision The precision to round down to.
+         * @return Returns the rounded down number.
+         */
+        floor(n: number, precision?: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.floor
+         */
+        floor(precision?: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.floor
+         */
+        floor(precision?: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+          * Computes the maximum value of `array`. If `array` is empty or falsey
+          * `undefined` is returned.
+          *
+          * @category Math
+          * @param array The array to iterate over.
+          * @returns Returns the maximum value.
+         */
+        max<T>(collection: List<T> | null | undefined): T | undefined;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.max
+         */
+        max(): T | undefined;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.max
+         */
+        max(): ExpChain<T | undefined>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.max` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the criterion by which
+         * the value is ranked. The iteratee is invoked with one argument: (value).
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @param iteratee The iteratee invoked per element.
+         * @returns Returns the maximum value.
+         * @example
+         *
+         * var objects = [{ 'n': 1 }, { 'n': 2 }];
+         *
+         * _.maxBy(objects, function(o) { return o.a; });
+         * // => { 'n': 2 }
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.maxBy(objects, 'n');
+         * // => { 'n': 2 }
+         */
+        maxBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.maxBy
+         */
+        maxBy(iteratee?: ValueIteratee<T>): T | undefined;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.maxBy
+         */
+        maxBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Computes the mean of the values in `array`.
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @returns Returns the mean.
+         * @example
+         *
+         * _.mean([4, 2, 8, 6]);
+         * // => 5
+         */
+        mean(collection: List<any> | null | undefined): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.mean
+         */
+        mean(): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.mean
+         */
+        mean(): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Computes the mean of the provided properties of the objects in the `array`
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @param iteratee The iteratee invoked per element.
+         * @returns Returns the mean.
+         * @example
+         *
+         * _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n');
+         * // => 5
+         */
+        meanBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): number;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.meanBy
+         */
+        meanBy(iteratee?: ValueIteratee<T>): number;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.meanBy
+         */
+        meanBy(iteratee?: ValueIteratee<T>): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Computes the minimum value of `array`. If `array` is empty or falsey
+         * `undefined` is returned.
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @returns Returns the minimum value.
+         */
+        min<T>(collection: List<T> | null | undefined): T | undefined;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.min
+         */
+        min(): T | undefined;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.min
+         */
+        min(): ExpChain<T | undefined>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.min` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the criterion by which
+         * the value is ranked. The iteratee is invoked with one argument: (value).
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @param iteratee The iteratee invoked per element.
+         * @returns Returns the minimum value.
+         * @example
+         *
+         * var objects = [{ 'n': 1 }, { 'n': 2 }];
+         *
+         * _.minBy(objects, function(o) { return o.a; });
+         * // => { 'n': 1 }
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.minBy(objects, 'n');
+         * // => { 'n': 1 }
+         */
+        minBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.minBy
+         */
+        minBy(iteratee?: ValueIteratee<T>): T | undefined;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.minBy
+         */
+        minBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Multiply two numbers.
+         * @param multiplier The first number in a multiplication.
+         * @param multiplicand The second number in a multiplication.
+         * @returns Returns the product.
+         */
+        multiply(multiplier: number, multiplicand: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.multiply
+         */
+        multiply(multiplicand: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.multiply
+         */
+        multiply(multiplicand: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded to precision.
+         *
+         * @param n The number to round.
+         * @param precision The precision to round to.
+         * @return Returns the rounded number.
+         */
+        round(n: number, precision?: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.round
+         */
+        round(precision?: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.round
+         */
+        round(precision?: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Subtract two numbers.
+         *
+         * @category Math
+         * @param minuend The first number in a subtraction.
+         * @param subtrahend The second number in a subtraction.
+         * @returns Returns the difference.
+         * @example
+         *
+         * _.subtract(6, 4);
+         * // => 2
+         */
+        subtract(minuend: number, subtrahend: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.subtract
+         */
+        subtract(subtrahend: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.subtract
+         */
+        subtract(subtrahend: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Computes the sum of the values in `array`.
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @returns Returns the sum.
+         * @example
+         *
+         * _.sum([4, 2, 8, 6]);
+         * // => 20
+         */
+        sum(collection: List<any> | null | undefined): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.sum
+         */
+        sum(): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.sum
+         */
+        sum(): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.sum` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the value to be summed.
+         * The iteratee is invoked with one argument: (value).
+         *
+         * @category Math
+         * @param array The array to iterate over.
+         * @param [iteratee=_.identity] The iteratee invoked per element.
+         * @returns Returns the sum.
+         * @example
+         *
+         * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
+         *
+         * _.sumBy(objects, function(o) { return o.n; });
+         * // => 20
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.sumBy(objects, 'n');
+         * // => 20
+         */
+        sumBy<T>(collection: List<T> | null | undefined, iteratee?: ((value: T) => number) | string): number;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee?: ((value: T) => number) | string): number;
+    }
+    interface CollectionChain<T> {
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee?: ((value: T) => number) | string): PrimitiveChain<number>;
+    }
+}

node_modules/cypress/types/lodash/common/number.d.ts

@@ -0,0 +1,131 @@
+import _ = require("../index");
+declare module "../index" {
+    // clamp
+    interface LoDashStatic {
+        /**
+         * Clamps `number` within the inclusive `lower` and `upper` bounds.
+         *
+         * @category Number
+         * @param number The number to clamp.
+         * @param [lower] The lower bound.
+         * @param upper The upper bound.
+         * @returns Returns the clamped number.
+         * @example
+         *
+         * _.clamp(-10, -5, 5);
+         * // => -5
+         *
+         * _.clamp(10, -5, 5);
+         * // => 5
+         * Clamps `number` within the inclusive `lower` and `upper` bounds.
+         *
+         * @category Number
+         * @param number The number to clamp.
+         * @param [lower] The lower bound.
+         * @param upper The upper bound.
+         * @returns Returns the clamped number.
+         * @example
+         *
+         * _.clamp(-10, -5, 5);
+         * // => -5
+         *
+         * _.clamp(10, -5, 5);
+         */
+        clamp(number: number, lower: number, upper: number): number;
+        /**
+         * @see _.clamp
+         */
+        clamp(number: number, upper: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.clamp
+         */
+        clamp(lower: number, upper: number): number;
+        /**
+         * @see _.clamp
+         */
+        clamp(upper: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.clamp
+         */
+        clamp(lower: number, upper: number): PrimitiveChain<number>;
+        /**
+         * @see _.clamp
+         */
+        clamp(upper: number): PrimitiveChain<number>;
+    }
+    // inRange
+    interface LoDashStatic {
+        /**
+         * Checks if n is between start and up to but not including, end. If end is not specified it’s set to start
+         * with start then set to 0.
+         *
+         * @param n The number to check.
+         * @param start The start of the range.
+         * @param end The end of the range.
+         * @return Returns true if n is in the range, else false.
+         */
+        inRange(n: number, start: number, end?: number): boolean;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.inRange
+         */
+        inRange(start: number, end?: number): boolean;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.inRange
+         */
+        inRange(start: number, end?: number): PrimitiveChain<boolean>;
+    }
+    // random
+    interface LoDashStatic {
+        /**
+         * Produces a random number between min and max (inclusive). If only one argument is provided a number between
+         * 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point
+         * number is returned instead of an integer.
+         *
+         * @param min The minimum possible value.
+         * @param max The maximum possible value.
+         * @param floating Specify returning a floating-point number.
+         * @return Returns the random number.
+         */
+        random(floating?: boolean): number;
+        /**
+         * @see _.random
+         */
+        random(max: number, floating?: boolean): number;
+        /**
+         * @see _.random
+         */
+        random(min: number, max: number, floating?: boolean): number;
+        /**
+         * @see _.random
+         */
+        random(min: number, index: string | number, guard: object): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.random
+         */
+        random(floating?: boolean): number;
+        /**
+         * @see _.random
+         */
+        random(max: number, floating?: boolean): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.random
+         */
+        random(floating?: boolean): PrimitiveChain<number>;
+        /**
+         * @see _.random
+         */
+        random(max: number, floating?: boolean): PrimitiveChain<number>;
+    }
+}

node_modules/cypress/types/lodash/common/seq.d.ts

@@ -0,0 +1,210 @@
+import _ = require("../index");
+declare module "../index" {
+    // chain
+    interface LoDashStatic {
+        /**
+         * Creates a lodash object that wraps value with explicit method chaining enabled.
+         *
+         * @param value The value to wrap.
+         * @return Returns the new lodash wrapper instance.
+         */
+        chain<TrapAny extends { __lodashAnyHack: any }>(value: TrapAny): CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain;
+        /**
+         * @see _.chain
+         */
+        chain<T extends null | undefined>(value: T): PrimitiveChain<T>;
+        /**
+         * @see _.chain
+         */
+        chain(value: string): StringChain;
+        /**
+         * @see _.chain
+         */
+        chain(value: string | null | undefined): StringNullableChain;
+        /**
+         * @see _.chain
+         */
+        chain<T extends (...args: any[]) => any>(value: T): FunctionChain<T>;
+        /**
+         * @see _.chain
+         */
+        chain<T = any>(value: List<T> | null | undefined): CollectionChain<T>;
+        /**
+         * @see _.chain
+         */
+        chain<T extends object>(value: T | null | undefined): ObjectChain<T>;
+        /**
+         * @see _.chain
+         */
+        chain<T>(value: T): PrimitiveChain<T>;
+    }
+    interface Collection<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): CollectionChain<T>;
+    }
+    interface String {
+        /**
+         * @see _.chain
+         */
+        chain(): StringChain;
+    }
+    interface Object<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): ObjectChain<T>;
+    }
+    interface Primitive<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): PrimitiveChain<T>;
+    }
+    interface Function<T extends (...args: any) => any> {
+        /**
+         * @see _.chain
+         */
+        chain(): FunctionChain<T>;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.chain
+         */
+        chain(): this;
+    }
+    // prototype.commit
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.commit
+         */
+        commit(): this;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.commit
+         */
+        commit(): this;
+    }
+    // prototype.plant
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.plant
+         */
+        plant(value: unknown): this;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.plant
+         */
+        plant(value: unknown): this;
+    }
+    // prototype.reverse
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.reverse
+         */
+        reverse(): this;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.reverse
+         */
+        reverse(): this;
+    }
+    // prototype.toJSON
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.toJSON
+         */
+        toJSON(): TValue;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.toJSON
+         */
+        toJSON(): TValue;
+    }
+    // prototype.toString
+    interface LoDashWrapper<TValue> {
+        /**
+         * @see _.toString
+         */
+        toString(): string;
+    }
+    // prototype.value
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.value
+         */
+        value(): TValue;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.value
+         */
+        value(): TValue;
+    }
+    // prototype.valueOf
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.valueOf
+         */
+        valueOf(): TValue;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.valueOf
+         */
+        valueOf(): TValue;
+    }
+    // tap
+    interface LoDashStatic {
+        /**
+         * This method invokes interceptor and returns value. The interceptor is invoked with one
+         * argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations
+         * on intermediate results within the chain.
+         *
+         * @param value The value to provide to interceptor.
+         * @param interceptor The function to invoke.
+         * @return Returns value.
+         */
+        tap<T>(value: T, interceptor: (value: T) => void): T;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.tap
+         */
+        tap(interceptor: (value: TValue) => void): this;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.tap
+         */
+        tap(interceptor: (value: TValue) => void): this;
+    }
+    // thru
+    interface LoDashStatic {
+        /**
+         * This method is like _.tap except that it returns the result of interceptor.
+         *
+         * @param value The value to provide to interceptor.
+         * @param interceptor The function to invoke.
+         * @return Returns the result of interceptor.
+         */
+        thru<T, TResult>(value: T, interceptor: (value: T) => TResult): TResult;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.thru
+         */
+        thru<TResult>(interceptor: (value: TValue) => TResult): ImpChain<TResult>;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.thru
+         */
+        thru<TResult>(interceptor: (value: TValue) => TResult): ExpChain<TResult>;
+    }
+}

node_modules/cypress/types/lodash/common/string.d.ts

@@ -0,0 +1,788 @@
+import _ = require("../index");
+declare module "../index" {
+    interface LoDashStatic {
+        /**
+         * Converts string to camel case.
+         *
+         * @param string The string to convert.
+         * @return Returns the camel cased string.
+         */
+        camelCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.camelCase
+         */
+        camelCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.camelCase
+         */
+        camelCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts the first character of string to upper case and the remaining to lower case.
+         *
+         * @param string The string to capitalize.
+         * @return Returns the capitalized string.
+         */
+        capitalize(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.capitalize
+         */
+        capitalize(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.capitalize
+         */
+        capitalize(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
+         * diacritical marks.
+         *
+         * @param string The string to deburr.
+         * @return Returns the deburred string.
+         */
+        deburr(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.deburr
+         */
+        deburr(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.deburr
+         */
+        deburr(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Checks if string ends with the given target string.
+         *
+         * @param string The string to search.
+         * @param target The string to search for.
+         * @param position The position to search from.
+         * @return Returns true if string ends with target, else false.
+         */
+        endsWith(string?: string, target?: string, position?: number): boolean;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.endsWith
+         */
+        endsWith(target?: string, position?: number): boolean;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.endsWith
+         */
+        endsWith(target?: string, position?: number): PrimitiveChain<boolean>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities.
+         *
+         * Note: No other characters are escaped. To escape additional characters use a third-party library like he.
+         *
+         * hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML
+         * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s
+         * article (under "semi-related fun fact") for more details.
+         *
+         * Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59,
+         * #102, #108, and #133 of the HTML5 Security Cheatsheet for more details.
+         *
+         * When working with HTML you should always quote attribute values to reduce XSS vectors.
+         *
+         * @param string The string to escape.
+         * @return Returns the escaped string.
+         */
+        escape(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.escape
+         */
+        escape(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.escape
+         */
+        escape(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]",
+         * "{", "}", and "|" in string.
+         *
+         * @param string The string to escape.
+         * @return Returns the escaped string.
+         */
+        escapeRegExp(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.escapeRegExp
+         */
+        escapeRegExp(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.escapeRegExp
+         */
+        escapeRegExp(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts string to kebab case.
+         *
+         * @param string The string to convert.
+         * @return Returns the kebab cased string.
+         */
+        kebabCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.kebabCase
+         */
+        kebabCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.kebabCase
+         */
+        kebabCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as space separated words, to lower case.
+         *
+         * @param string The string to convert.
+         * @return Returns the lower cased string.
+         */
+        lowerCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.lowerCase
+         */
+        lowerCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.lowerCase
+         */
+        lowerCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts the first character of `string` to lower case.
+         *
+         * @param string The string to convert.
+         * @return Returns the converted string.
+         */
+        lowerFirst(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.lowerFirst
+         */
+        lowerFirst(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.lowerFirst
+         */
+        lowerFirst(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
+         * they can’t be evenly divided by length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        pad(string?: string, length?: number, chars?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.pad
+         */
+        pad(length?: number, chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.pad
+         */
+        pad(length?: number, chars?: string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
+         * length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        padEnd(string?: string, length?: number, chars?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.padEnd
+         */
+        padEnd(length?: number, chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.padEnd
+         */
+        padEnd(length?: number, chars?: string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
+         * length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        padStart(string?: string, length?: number, chars?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.padStart
+         */
+        padStart(length?: number, chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.padStart
+         */
+        padStart(length?: number, chars?: string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
+         * unless value is a hexadecimal, in which case a radix of 16 is used.
+         *
+         * Note: This method aligns with the ES5 implementation of parseInt.
+         *
+         * @param string The string to convert.
+         * @param radix The radix to interpret value by.
+         * @return Returns the converted integer.
+         */
+        parseInt(string: string, radix?: number): number;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.parseInt
+         */
+        parseInt(radix?: number): number;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.parseInt
+         */
+        parseInt(radix?: number): PrimitiveChain<number>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Repeats the given string n times.
+         *
+         * @param string The string to repeat.
+         * @param n The number of times to repeat the string.
+         * @return Returns the repeated string.
+         */
+        repeat(string?: string, n?: number): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.repeat
+         */
+        repeat(n?: number): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.repeat
+         */
+        repeat(n?: number): StringChain;
+    }
+    type ReplaceFunction = (match: string, ...args: any[]) => string;
+
+    interface LoDashStatic {
+        /**
+         * Replaces matches for pattern in string with replacement.
+         *
+         * Note: This method is based on String#replace.
+         *
+         * @return Returns the modified string.
+         */
+        replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string;
+        /**
+         * @see _.replace
+         */
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.replace
+         */
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
+        /**
+         * @see _.replace
+         */
+        replace(replacement: ReplaceFunction | string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.replace
+         */
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): StringChain;
+        /**
+         * @see _.replace
+         */
+        replace(replacement: ReplaceFunction | string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts string to snake case.
+         *
+         * @param string The string to convert.
+         * @return Returns the snake cased string.
+         */
+        snakeCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.snakeCase
+         */
+        snakeCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.snakeCase
+         */
+        snakeCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Splits string by separator.
+         *
+         * Note: This method is based on String#split.
+         *
+         * @param string The string to split.
+         * @param separator The separator pattern to split by.
+         * @param limit The length to truncate results to.
+         * @return Returns the new array of string segments.
+         */
+        split(string: string | null | undefined, separator?: RegExp | string, limit?: number): string[];
+        /**
+         * @see _.split
+         */
+        split(string: string | null | undefined, index: string | number, guard: object): string[];
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.split
+         */
+        split(separator?: RegExp | string, limit?: number): Collection<string>;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.split
+         */
+        split(separator?: RegExp | string, limit?: number): CollectionChain<string>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts string to start case.
+         *
+         * @param string The string to convert.
+         * @return Returns the start cased string.
+         */
+        startCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.startCase
+         */
+        startCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.startCase
+         */
+        startCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Checks if string starts with the given target string.
+         *
+         * @param string The string to search.
+         * @param target The string to search for.
+         * @param position The position to search from.
+         * @return Returns true if string starts with target, else false.
+         */
+        startsWith(string?: string, target?: string, position?: number): boolean;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.startsWith
+         */
+        startsWith(target?: string, position?: number): boolean;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.startsWith
+         */
+        startsWith(target?: string, position?: number): PrimitiveChain<boolean>;
+    }
+
+    interface TemplateOptions extends TemplateSettings {
+        /**
+         * @see _.sourceURL
+         */
+        sourceURL?: string;
+    }
+    interface TemplateExecutor {
+        (data?: object): string;
+        /**
+         * @see _.source
+         */
+        source: string;
+    }
+    interface LoDashStatic {
+        /**
+         * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
+         * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate"
+         * delimiters. Data properties may be accessed as free variables in the template. If a setting object is
+         * provided it takes precedence over _.templateSettings values.
+         *
+         * Note: In the development build _.template utilizes
+         * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier
+         * debugging.
+         *
+         * For more information on precompiling templates see
+         * [lodash's custom builds documentation](https://lodash.com/custom-builds).
+         *
+         * For more information on Chrome extension sandboxes see
+         * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
+         *
+         * @param string The template string.
+         * @param options The options object.
+         * @param options.escape The HTML "escape" delimiter.
+         * @param options.evaluate The "evaluate" delimiter.
+         * @param options.imports An object to import into the template as free variables.
+         * @param options.interpolate The "interpolate" delimiter.
+         * @param options.sourceURL The sourceURL of the template's compiled source.
+         * @param options.variable The data object variable name.
+         * @return Returns the compiled template function.
+         */
+        template(string?: string, options?: TemplateOptions): TemplateExecutor;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.template
+         */
+        template(options?: TemplateOptions): TemplateExecutor;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.template
+         */
+        template(options?: TemplateOptions): FunctionChain<TemplateExecutor>;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as a whole, to lower case.
+         *
+         * @param string The string to convert.
+         * @return Returns the lower cased string.
+         */
+        toLower(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.toLower
+         */
+        toLower(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.toLower
+         */
+        toLower(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as a whole, to upper case.
+         *
+         * @param string The string to convert.
+         * @return Returns the upper cased string.
+         */
+        toUpper(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.toUpper
+         */
+        toUpper(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.toUpper
+         */
+        toUpper(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Removes leading and trailing whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trim(string?: string, chars?: string): string;
+        /**
+         * @see _.trim
+         */
+        trim(string: string, index: string | number, guard: object): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.trim
+         */
+        trim(chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.trim
+         */
+        trim(chars?: string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Removes trailing whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trimEnd(string?: string, chars?: string): string;
+        /**
+         * @see _.trimEnd
+         */
+        trimEnd(string: string, index: string | number, guard: object): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.trimEnd
+         */
+        trimEnd(chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.trimEnd
+         */
+        trimEnd(chars?: string): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Removes leading whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trimStart(string?: string, chars?: string): string;
+        /**
+         * @see _.trimStart
+         */
+        trimStart(string: string, index: string | number, guard: object): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.trimStart
+         */
+        trimStart(chars?: string): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.trimStart
+         */
+        trimStart(chars?: string): StringChain;
+    }
+
+    interface TruncateOptions {
+        /**
+         * @see _.length
+         */
+        length?: number;
+        /**
+         * @see _.omission
+         */
+        omission?: string;
+        /**
+         * @see _.separator
+         */
+        separator?: string | RegExp;
+    }
+    interface LoDashStatic {
+        /**
+         * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
+         * string are replaced with the omission string which defaults to "…".
+         *
+         * @param string The string to truncate.
+         * @param options The options object or maximum string length.
+         * @return Returns the truncated string.
+         */
+        truncate(string?: string, options?: TruncateOptions): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.truncate
+         */
+        truncate(options?: TruncateOptions): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.truncate
+         */
+        truncate(options?: TruncateOptions): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * The inverse of _.escape; this method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;, and &#96;
+         * in string to their corresponding characters.
+         *
+         * Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library
+         * like he.
+         *
+         * @param string The string to unescape.
+         * @return Returns the unescaped string.
+         */
+        unescape(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.unescape
+         */
+        unescape(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.unescape
+         */
+        unescape(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as space separated words, to upper case.
+         *
+         * @param string The string to convert.
+         * @return Returns the upper cased string.
+         */
+        upperCase(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.upperCase
+         */
+        upperCase(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.upperCase
+         */
+        upperCase(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Converts the first character of `string` to upper case.
+         *
+         * @param string The string to convert.
+         * @return Returns the converted string.
+         */
+        upperFirst(string?: string): string;
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.upperFirst
+         */
+        upperFirst(): string;
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.upperFirst
+         */
+        upperFirst(): StringChain;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Splits `string` into an array of its words.
+         *
+         * @param string The string to inspect.
+         * @param pattern The pattern to match words.
+         * @return Returns the words of `string`.
+         */
+        words(string?: string, pattern?: string | RegExp): string[];
+        /**
+         * @see _.words
+         */
+        words(string: string, index: string | number, guard: object): string[];
+    }
+    interface LoDashImplicitWrapper<TValue> {
+        /**
+         * @see _.words
+         */
+        words(pattern?: string | RegExp): string[];
+    }
+    interface LoDashExplicitWrapper<TValue> {
+        /**
+         * @see _.words
+         */
+        words(pattern?: string | RegExp): CollectionChain<string>;
+    }
+}

node_modules/cypress/types/lodash/compact.d.ts

@@ -0,0 +1,2 @@
+import { compact } from "./index";
+export = compact;

node_modules/cypress/types/lodash/concat.d.ts

@@ -0,0 +1,2 @@
+import { concat } from "./index";
+export = concat;

node_modules/cypress/types/lodash/cond.d.ts

@@ -0,0 +1,2 @@
+import { cond } from "./index";
+export = cond;

node_modules/cypress/types/lodash/conformsTo.d.ts

@@ -0,0 +1,2 @@
+import { conformsTo } from "./index";
+export = conformsTo;

node_modules/cypress/types/lodash/constant.d.ts

@@ -0,0 +1,2 @@
+import { constant } from "./index";
+export = constant;

node_modules/cypress/types/lodash/countBy.d.ts

@@ -0,0 +1,2 @@
+import { countBy } from "./index";
+export = countBy;

node_modules/cypress/types/lodash/create.d.ts

@@ -0,0 +1,2 @@
+import { create } from "./index";
+export = create;

node_modules/cypress/types/lodash/curry.d.ts

@@ -0,0 +1,2 @@
+import { curry } from "./index";
+export = curry;

node_modules/cypress/types/lodash/curryRight.d.ts

@@ -0,0 +1,2 @@
+import { curryRight } from "./index";
+export = curryRight;

node_modules/cypress/types/lodash/debounce.d.ts

@@ -0,0 +1,2 @@
+import { debounce } from "./index";
+export = debounce;

node_modules/cypress/types/lodash/deburr.d.ts

@@ -0,0 +1,2 @@
+import { deburr } from "./index";
+export = deburr;

node_modules/cypress/types/lodash/defaultTo.d.ts

@@ -0,0 +1,2 @@
+import { defaultTo } from "./index";
+export = defaultTo;

node_modules/cypress/types/lodash/defaults.d.ts

@@ -0,0 +1,2 @@
+import { defaults } from "./index";
+export = defaults;

node_modules/cypress/types/lodash/defaultsDeep.d.ts

@@ -0,0 +1,2 @@
+import { defaultsDeep } from "./index";
+export = defaultsDeep;

node_modules/cypress/types/lodash/defer.d.ts

@@ -0,0 +1,2 @@
+import { defer } from "./index";
+export = defer;

node_modules/cypress/types/lodash/delay.d.ts

@@ -0,0 +1,2 @@
+import { delay } from "./index";
+export = delay;

node_modules/cypress/types/lodash/difference.d.ts

@@ -0,0 +1,2 @@
+import { difference } from "./index";
+export = difference;

node_modules/cypress/types/lodash/differenceBy.d.ts

@@ -0,0 +1,2 @@
+import { differenceBy } from "./index";
+export = differenceBy;

node_modules/cypress/types/lodash/differenceWith.d.ts

@@ -0,0 +1,2 @@
+import { differenceWith } from "./index";
+export = differenceWith;