Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/.npmignore

@@ -0,0 +1,4 @@
+**/__mocks__/**
+**/__tests__/**
+src
+yarn.lock

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/ExpectationFailed.js

@@ -0,0 +1,13 @@
+"use strict"; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+class ExpectationFailed extends Error {}
+
+module.exports = ExpectationFailed;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/assert-support.js

@@ -0,0 +1,136 @@
+'use strict';var _require =
+
+
+
+
+
+
+
+
+
+
+
+require('jest-matcher-utils');const printReceived = _require.printReceived,printExpected = _require.printExpected; /**
+                                                                                                                    * Copyright (c) 2017-present, Facebook, Inc. All rights reserved.
+                                                                                                                    *
+                                                                                                                    * This source code is licensed under the BSD-style license found in the
+                                                                                                                    * LICENSE file in the root directory of this source tree. An additional grant
+                                                                                                                    * of patent rights can be found in the PATENTS file in the same directory.
+                                                                                                                    *
+                                                                                                                    * 
+                                                                                                                    */const chalk = require('chalk');const diff = require('jest-diff');
+
+
+
+
+
+const assertOperatorsMap = {
+  '!=': 'notEqual',
+  '!==': 'notStrictEqual',
+  '==': 'equal',
+  '===': 'strictEqual' };
+
+
+const humanReadableOperators = {
+  deepEqual: 'to deeply equal',
+  deepStrictEqual: 'to deeply and strictly equal',
+  notDeepEqual: 'not to deeply equal',
+  notDeepStrictEqual: 'not to deeply and strictly equal' };
+
+
+const getOperatorName = (operator, stack) => {
+  if (typeof operator === 'string') {
+    return assertOperatorsMap[operator] || operator;
+  }
+  if (stack.match('.doesNotThrow')) {
+    return 'doesNotThrow';
+  }
+  if (stack.match('.throws')) {
+    return 'throws';
+  }
+  return '';
+};
+
+const operatorMessage = (operator, negator) =>
+typeof operator === 'string' ?
+operator.startsWith('!') || operator.startsWith('=') ?
+`${negator ? 'not ' : ''}to be (operator: ${operator}):\n` :
+`${humanReadableOperators[operator] || operator} to:\n` :
+'';
+
+const assertThrowingMatcherHint = operatorName => {
+  return (
+    chalk.dim('assert') +
+    chalk.dim('.' + operatorName + '(') +
+    chalk.red('function') +
+    chalk.dim(')'));
+
+};
+
+const assertMatcherHint = (operator, operatorName) => {
+  let message =
+  chalk.dim('assert') +
+  chalk.dim('.' + operatorName + '(') +
+  chalk.red('received') +
+  chalk.dim(', ') +
+  chalk.green('expected') +
+  chalk.dim(')');
+
+  if (operator === '==') {
+    message +=
+    ' or ' +
+    chalk.dim('assert') +
+    chalk.dim('(') +
+    chalk.red('received') +
+    chalk.dim(') ');
+  }
+
+  return message;
+};
+
+function assertionErrorMessage(error, options) {const
+  expected = error.expected,actual = error.actual,message = error.message,operator = error.operator,stack = error.stack;
+  const diffString = diff(expected, actual, options);
+  const negator =
+  typeof operator === 'string' && (
+  operator.startsWith('!') || operator.startsWith('not'));
+  const hasCustomMessage = !error.generatedMessage;
+  const operatorName = getOperatorName(operator, stack);
+
+  if (operatorName === 'doesNotThrow') {
+    return (
+      assertThrowingMatcherHint(operatorName) +
+      '\n\n' +
+      chalk.reset(`Expected the function not to throw an error.\n`) +
+      chalk.reset(`Instead, it threw:\n`) +
+      `  ${printReceived(actual)}` +
+      chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
+      stack.replace(/AssertionError(.*)/g, ''));
+
+  }
+
+  if (operatorName === 'throws') {
+    return (
+      assertThrowingMatcherHint(operatorName) +
+      '\n\n' +
+      chalk.reset(`Expected the function to throw an error.\n`) +
+      chalk.reset(`But it didn't throw anything.`) +
+      chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
+      stack.replace(/AssertionError(.*)/g, ''));
+
+  }
+
+  return (
+    assertMatcherHint(operator, operatorName) +
+    '\n\n' +
+    chalk.reset(`Expected value ${operatorMessage(operator, negator)}`) +
+    `  ${printExpected(expected)}\n` +
+    chalk.reset(`Received:\n`) +
+    `  ${printReceived(actual)}` +
+    chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') + (
+    diffString ? `\n\nDifference:\n\n${diffString}` : '') +
+    stack.replace(/AssertionError(.*)/g, ''));
+
+}
+
+module.exports = assertionErrorMessage;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/expectationResultFactory.js

@@ -0,0 +1,68 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+function messageFormatter(_ref) {let error = _ref.error,message = _ref.message,passed = _ref.passed;
+  if (passed) {
+    return 'Passed.';
+  }
+  if (message) {
+    return message;
+  }
+  if (!error) {
+    return '';
+  }
+  return error.message && error.name ?
+  `${error.name}: ${error.message}` :
+  `${error.toString()} thrown`;
+}
+
+function stackFormatter(options, errorMessage) {
+  if (options.passed) {
+    return '';
+  }var _ref2 =
+  options.error || new Error(errorMessage);const stack = _ref2.stack;
+  return stack;
+}
+
+
+
+
+
+
+
+
+
+
+function expectationResultFactory(options) {
+  const message = messageFormatter(options);
+  const stack = stackFormatter(options, message);
+
+  if (options.passed) {
+    return {
+      error: options.error,
+      matcherName: options.matcherName,
+      message,
+      passed: options.passed,
+      stack };
+
+  }
+
+  return {
+    actual: options.actual,
+    error: options.error,
+    expected: options.expected,
+    matcherName: options.matcherName,
+    message,
+    passed: options.passed,
+    stack };
+
+}
+
+module.exports = expectationResultFactory;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/index.js

@@ -0,0 +1,128 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const path = require('path'); /**
+                               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                               *
+                               * This source code is licensed under the BSD-style license found in the
+                               * LICENSE file in the root directory of this source tree. An additional grant
+                               * of patent rights can be found in the PATENTS file in the same directory.
+                               *
+                               * 
+                               */const JasmineReporter = require('./reporter');const jasmineAsync = require('./jasmine-async');const JASMINE = require.resolve('./jasmine/jasmine-light.js');function jasmine2(
+globalConfig,
+config,
+environment,
+runtime,
+testPath)
+{
+  const reporter = new JasmineReporter(
+  globalConfig,
+  config,
+  environment,
+  testPath);
+
+  const jasmineFactory = runtime.requireInternalModule(JASMINE);
+  const jasmine = jasmineFactory.create();
+
+  const env = jasmine.getEnv();
+  const jasmineInterface = jasmineFactory.interface(jasmine, env);
+  Object.assign(environment.global, jasmineInterface);
+  env.addReporter(jasmineInterface.jsApiReporter);
+
+  jasmineAsync.install(environment.global);
+
+  environment.global.test = environment.global.it;
+  environment.global.it.only = environment.global.fit;
+  environment.global.it.skip = environment.global.xit;
+  environment.global.xtest = environment.global.xit;
+  environment.global.describe.skip = environment.global.xdescribe;
+  environment.global.describe.only = environment.global.fdescribe;
+
+  env.beforeEach(() => {
+    if (config.resetModules) {
+      runtime.resetModules();
+    }
+
+    if (config.clearMocks) {
+      runtime.clearAllMocks();
+    }
+
+    if (config.resetMocks) {
+      runtime.resetAllMocks();
+    }
+
+    if (config.timers === 'fake') {
+      environment.fakeTimers.useFakeTimers();
+    }
+  });
+
+  env.addReporter(reporter);
+
+  runtime.requireInternalModule(path.resolve(__dirname, './jest-expect.js'))({
+    expand: globalConfig.expand });
+
+
+  const snapshotState = runtime.requireInternalModule(
+  path.resolve(__dirname, './setup-jest-globals.js'))(
+  {
+    config,
+    globalConfig,
+    localRequire: runtime.requireModule.bind(runtime),
+    testPath });
+
+
+  if (config.setupTestFrameworkScriptFile) {
+    runtime.requireModule(config.setupTestFrameworkScriptFile);
+  }
+
+  if (globalConfig.testNamePattern) {
+    const testNameRegex = new RegExp(globalConfig.testNamePattern, 'i');
+    env.specFilter = spec => testNameRegex.test(spec.getFullName());
+  }
+
+  runtime.requireModule(testPath);
+  env.execute();
+  return reporter.
+  getResults().
+  then(results => addSnapshotData(results, snapshotState));
+}
+
+const addSnapshotData = (results, snapshotState) => {
+  results.testResults.forEach((_ref) => {let fullName = _ref.fullName,status = _ref.status;
+    if (status === 'pending' || status === 'failed') {
+      // if test is skipped or failed, we don't want to mark
+      // its snapshots as obsolete.
+      snapshotState.markSnapshotsAsCheckedForTest(fullName);
+    }
+  });
+
+  const uncheckedCount = snapshotState.getUncheckedCount();
+  if (uncheckedCount) {
+    snapshotState.removeUncheckedKeys();
+  }
+
+  const status = snapshotState.save();
+  results.snapshot.fileDeleted = status.deleted;
+  results.snapshot.added = snapshotState.added;
+  results.snapshot.matched = snapshotState.matched;
+  results.snapshot.unmatched = snapshotState.unmatched;
+  results.snapshot.updated = snapshotState.updated;
+  results.snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+  return results;
+};
+
+module.exports = jasmine2;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine-async.js

@@ -0,0 +1,127 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function isPromise(obj) {
+  return obj && typeof obj.then === 'function';
+} /**
+   * Copyright (c) 2014, Facebook, Inc. All rights reserved.
+   *
+   * This source code is licensed under the BSD-style license found in the
+   * LICENSE file in the root directory of this source tree. An additional grant
+   * of patent rights can be found in the PATENTS file in the same directory.
+   *
+   * 
+   */ /**
+       * This module adds ability to test async promise code with jasmine by
+       * returning a promise from `it/test` and `before/afterEach/All` blocks.
+       */function promisifyLifeCycleFunction(originalFn, env) {return function (fn, timeout) {if (!fn) {return originalFn.call(env);}const hasDoneCallback = fn.length > 0;if (hasDoneCallback) {// Jasmine will handle it
+      return originalFn.call(env, fn, timeout);
+    }
+
+    // We make *all* functions async and run `done` right away if they
+    // didn't return a promise.
+    const asyncFn = function (done) {
+      const returnValue = fn.call({});
+
+      if (isPromise(returnValue)) {
+        returnValue.then(done, done.fail);
+      } else {
+        done();
+      }
+    };
+
+    return originalFn.call(env, asyncFn, timeout);
+  };
+}
+
+// Similar to promisifyLifeCycleFunction but throws an error
+// when the return value is neither a Promise nor `undefined`
+function promisifyIt(originalFn, env) {
+  return function (specName, fn, timeout) {
+    if (!fn) {
+      const spec = originalFn.call(env, specName);
+      spec.pend('not implemented');
+      return spec;
+    }
+
+    const hasDoneCallback = fn.length > 0;
+
+    if (hasDoneCallback) {
+      return originalFn.call(env, specName, fn, timeout);
+    }
+
+    const asyncFn = function (done) {
+      const returnValue = fn.call({});
+
+      if (isPromise(returnValue)) {
+        returnValue.then(done, done.fail);
+      } else if (returnValue === undefined) {
+        done();
+      } else {
+        done.fail(
+        new Error(
+        'Jest: `it` and `test` must return either a Promise or undefined.'));
+
+
+      }
+    };
+
+    return originalFn.call(env, specName, asyncFn, timeout);
+  };
+}
+
+function makeConcurrent(originalFn, env) {
+  return function (specName, fn, timeout) {
+    if (env != null && !env.specFilter({ getFullName: () => specName || '' })) {
+      return originalFn.call(env, specName, () => Promise.resolve(), timeout);
+    }
+
+    let promise;
+
+    try {
+      promise = fn();
+      if (!isPromise(promise)) {
+        throw new Error(
+        `Jest: concurrent test "${specName}" must return a Promise.`);
+
+      }
+    } catch (error) {
+      return originalFn.call(env, specName, () => Promise.reject(error));
+    }
+
+    return originalFn.call(env, specName, () => promise, timeout);
+  };
+}
+
+function install(global) {
+  const jasmine = global.jasmine;
+
+  const env = jasmine.getEnv();
+  env.it = promisifyIt(env.it, env);
+  env.fit = promisifyIt(env.fit, env);
+  global.it.concurrent = makeConcurrent(env.it, env);
+  global.it.concurrent.only = makeConcurrent(env.fit, env);
+  global.it.concurrent.skip = makeConcurrent(env.xit, env);
+  global.fit.concurrent = makeConcurrent(env.fit);
+  env.afterAll = promisifyLifeCycleFunction(env.afterAll, env);
+  env.afterEach = promisifyLifeCycleFunction(env.afterEach, env);
+  env.beforeAll = promisifyLifeCycleFunction(env.beforeAll, env);
+  env.beforeEach = promisifyLifeCycleFunction(env.beforeEach, env);
+}
+
+module.exports = {
+  install };

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/CallTracker.js

@@ -0,0 +1,81 @@
+"use strict"; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+function CallTracker() {
+  let calls = [];
+
+  this.track = function (context) {
+    calls.push(context);
+  };
+
+  this.any = function () {
+    return !!calls.length;
+  };
+
+  this.count = function () {
+    return calls.length;
+  };
+
+  this.argsFor = function (index) {
+    const call = calls[index];
+    return call ? call.args : [];
+  };
+
+  this.all = function () {
+    return calls;
+  };
+
+  this.allArgs = function () {
+    const callArgs = [];
+    for (let i = 0; i < calls.length; i++) {
+      callArgs.push(calls[i].args);
+    }
+
+    return callArgs;
+  };
+
+  this.first = function () {
+    return calls[0];
+  };
+
+  this.mostRecent = function () {
+    return calls[calls.length - 1];
+  };
+
+  this.reset = function () {
+    calls = [];
+  };
+}
+
+module.exports = CallTracker;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/Env.js

@@ -0,0 +1,477 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+/* eslint-disable sort-keys */
+
+const queueRunner = require('../queueRunner');
+const treeProcessor = require('../treeProcessor');
+
+module.exports = function (j$) {
+  function Env(options) {
+    options = options || {};
+
+    const self = this;
+
+    let totalSpecsDefined = 0;
+
+    let catchExceptions = true;
+
+    const realSetTimeout = global.setTimeout;
+    const realClearTimeout = global.clearTimeout;
+
+    const runnableResources = {};
+
+    let currentSpec = null;
+    const currentlyExecutingSuites = [];
+    let currentDeclarationSuite = null;
+    let throwOnExpectationFailure = false;
+    let random = false;
+    let seed = null;
+
+    const currentSuite = function () {
+      return currentlyExecutingSuites[currentlyExecutingSuites.length - 1];
+    };
+
+    const currentRunnable = function () {
+      return currentSpec || currentSuite();
+    };
+
+    const reporter = new j$.ReportDispatcher([
+    'jasmineStarted',
+    'jasmineDone',
+    'suiteStarted',
+    'suiteDone',
+    'specStarted',
+    'specDone']);
+
+
+    this.specFilter = function () {
+      return true;
+    };
+
+    let nextSpecId = 0;
+    const getNextSpecId = function () {
+      return 'spec' + nextSpecId++;
+    };
+
+    let nextSuiteId = 0;
+    const getNextSuiteId = function () {
+      return 'suite' + nextSuiteId++;
+    };
+
+    const defaultResourcesForRunnable = function (id, parentRunnableId) {
+      const resources = { spies: [] };
+
+      runnableResources[id] = resources;
+    };
+
+    const clearResourcesForRunnable = function (id) {
+      spyRegistry.clearSpies();
+      delete runnableResources[id];
+    };
+
+    const beforeAndAfterFns = function (suite) {
+      return function () {
+        let afters = [];
+        let befores = [];
+
+        while (suite) {
+          befores = befores.concat(suite.beforeFns);
+          afters = afters.concat(suite.afterFns);
+
+          suite = suite.parentSuite;
+        }
+
+        return {
+          befores: befores.reverse(),
+          afters };
+
+      };
+    };
+
+    const getSpecName = function (spec, suite) {
+      const fullName = [spec.description];
+      const suiteFullName = suite.getFullName();
+
+      if (suiteFullName !== '') {
+        fullName.unshift(suiteFullName);
+      }
+
+      return fullName.join(' ');
+    };
+
+    this.catchExceptions = function (value) {
+      catchExceptions = !!value;
+      return catchExceptions;
+    };
+
+    this.catchingExceptions = function () {
+      return catchExceptions;
+    };
+
+    this.throwOnExpectationFailure = function (value) {
+      throwOnExpectationFailure = !!value;
+    };
+
+    this.throwingExpectationFailures = function () {
+      return throwOnExpectationFailure;
+    };
+
+    this.randomizeTests = function (value) {
+      random = !!value;
+    };
+
+    this.randomTests = function () {
+      return random;
+    };
+
+    this.seed = function (value) {
+      if (value) {
+        seed = value;
+      }
+      return seed;
+    };
+
+    function queueRunnerFactory(options) {
+      options.clearTimeout = realClearTimeout;
+      options.fail = self.fail;
+      options.setTimeout = realSetTimeout;
+      return queueRunner(options);
+    }
+
+    const topSuite = new j$.Suite({
+      id: getNextSuiteId() });
+
+    defaultResourcesForRunnable(topSuite.id);
+    currentDeclarationSuite = topSuite;
+
+    this.topSuite = function () {
+      return topSuite;
+    };
+
+    this.execute = function (runnablesToRun) {
+      if (!runnablesToRun) {
+        if (focusedRunnables.length) {
+          runnablesToRun = focusedRunnables;
+        } else {
+          runnablesToRun = [topSuite.id];
+        }
+      }
+
+      reporter.jasmineStarted({
+        totalSpecsDefined });
+
+
+      currentlyExecutingSuites.push(topSuite);
+
+      treeProcessor({
+        nodeComplete(suite) {
+          if (!suite.disabled) {
+            clearResourcesForRunnable(suite.id);
+          }
+          currentlyExecutingSuites.pop();
+          reporter.suiteDone(suite.getResult());
+        },
+        nodeStart(suite) {
+          currentlyExecutingSuites.push(suite);
+          defaultResourcesForRunnable(suite.id, suite.parentSuite.id);
+          reporter.suiteStarted(suite.result);
+        },
+        queueRunnerFactory,
+        runnableIds: runnablesToRun,
+        tree: topSuite }).
+      then(() => {
+        clearResourcesForRunnable(topSuite.id);
+        currentlyExecutingSuites.pop();
+        reporter.jasmineDone({
+          failedExpectations: topSuite.result.failedExpectations });
+
+      });
+    };
+
+    this.addReporter = function (reporterToAdd) {
+      reporter.addReporter(reporterToAdd);
+    };
+
+    this.provideFallbackReporter = function (reporterToAdd) {
+      reporter.provideFallbackReporter(reporterToAdd);
+    };
+
+    this.clearReporters = function () {
+      reporter.clearReporters();
+    };
+
+    const spyRegistry = new j$.SpyRegistry({
+      currentSpies() {
+        if (!currentRunnable()) {
+          throw new Error(
+          'Spies must be created in a before function or a spec');
+
+        }
+        return runnableResources[currentRunnable().id].spies;
+      } });
+
+
+    this.allowRespy = function (allow) {
+      spyRegistry.allowRespy(allow);
+    };
+
+    this.spyOn = function () {
+      return spyRegistry.spyOn.apply(spyRegistry, arguments);
+    };
+
+    const suiteFactory = function (description) {
+      const suite = new j$.Suite({
+        id: getNextSuiteId(),
+        description,
+        parentSuite: currentDeclarationSuite,
+        throwOnExpectationFailure });
+
+
+      return suite;
+    };
+
+    this.describe = function (description, specDefinitions) {
+      const suite = suiteFactory(description);
+      if (specDefinitions.length > 0) {
+        throw new Error('describe does not expect any arguments');
+      }
+      if (currentDeclarationSuite.markedPending) {
+        suite.pend();
+      }
+      addSpecsToSuite(suite, specDefinitions);
+      return suite;
+    };
+
+    this.xdescribe = function (description, specDefinitions) {
+      const suite = suiteFactory(description);
+      suite.pend();
+      addSpecsToSuite(suite, specDefinitions);
+      return suite;
+    };
+
+    const focusedRunnables = [];
+
+    this.fdescribe = function (description, specDefinitions) {
+      const suite = suiteFactory(description);
+      suite.isFocused = true;
+
+      focusedRunnables.push(suite.id);
+      unfocusAncestor();
+      addSpecsToSuite(suite, specDefinitions);
+
+      return suite;
+    };
+
+    function addSpecsToSuite(suite, specDefinitions) {
+      const parentSuite = currentDeclarationSuite;
+      parentSuite.addChild(suite);
+      currentDeclarationSuite = suite;
+
+      let declarationError = null;
+      try {
+        specDefinitions.call(suite);
+      } catch (e) {
+        declarationError = e;
+      }
+
+      if (declarationError) {
+        self.it('encountered a declaration exception', () => {
+          throw declarationError;
+        });
+      }
+
+      currentDeclarationSuite = parentSuite;
+    }
+
+    function findFocusedAncestor(suite) {
+      while (suite) {
+        if (suite.isFocused) {
+          return suite.id;
+        }
+        suite = suite.parentSuite;
+      }
+
+      return null;
+    }
+
+    function unfocusAncestor() {
+      const focusedAncestor = findFocusedAncestor(currentDeclarationSuite);
+      if (focusedAncestor) {
+        for (let i = 0; i < focusedRunnables.length; i++) {
+          if (focusedRunnables[i] === focusedAncestor) {
+            focusedRunnables.splice(i, 1);
+            break;
+          }
+        }
+      }
+    }
+
+    const specFactory = function (description, fn, suite, timeout) {
+      totalSpecsDefined++;
+      const spec = new j$.Spec({
+        id: getNextSpecId(),
+        beforeAndAfterFns: beforeAndAfterFns(suite),
+        resultCallback: specResultCallback,
+        getSpecName(spec) {
+          return getSpecName(spec, suite);
+        },
+        onStart: specStarted,
+        description,
+        queueRunnerFactory,
+        userContext() {
+          return suite.clonedSharedUserContext();
+        },
+        queueableFn: {
+          fn,
+          timeout() {
+            return timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
+          } },
+
+        throwOnExpectationFailure });
+
+
+      if (!self.specFilter(spec)) {
+        spec.disable();
+      }
+
+      return spec;
+
+      function specResultCallback(result) {
+        clearResourcesForRunnable(spec.id);
+        currentSpec = null;
+        reporter.specDone(result);
+      }
+
+      function specStarted(spec) {
+        currentSpec = spec;
+        defaultResourcesForRunnable(spec.id, suite.id);
+        reporter.specStarted(spec.result);
+      }
+    };
+
+    this.it = function (description, fn, timeout) {
+      const spec = specFactory(
+      description,
+      fn,
+      currentDeclarationSuite,
+      timeout);
+
+      if (currentDeclarationSuite.markedPending) {
+        spec.pend();
+      }
+      currentDeclarationSuite.addChild(spec);
+      return spec;
+    };
+
+    this.xit = function () {
+      const spec = this.it.apply(this, arguments);
+      spec.pend('Temporarily disabled with xit');
+      return spec;
+    };
+
+    this.fit = function (description, fn, timeout) {
+      const spec = specFactory(
+      description,
+      fn,
+      currentDeclarationSuite,
+      timeout);
+
+      currentDeclarationSuite.addChild(spec);
+      focusedRunnables.push(spec.id);
+      unfocusAncestor();
+      return spec;
+    };
+
+    this.beforeEach = function (beforeEachFunction, timeout) {
+      currentDeclarationSuite.beforeEach({
+        fn: beforeEachFunction,
+        timeout() {
+          return timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
+        } });
+
+    };
+
+    this.beforeAll = function (beforeAllFunction, timeout) {
+      currentDeclarationSuite.beforeAll({
+        fn: beforeAllFunction,
+        timeout() {
+          return timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
+        } });
+
+    };
+
+    this.afterEach = function (afterEachFunction, timeout) {
+      currentDeclarationSuite.afterEach({
+        fn: afterEachFunction,
+        timeout() {
+          return timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
+        } });
+
+    };
+
+    this.afterAll = function (afterAllFunction, timeout) {
+      currentDeclarationSuite.afterAll({
+        fn: afterAllFunction,
+        timeout() {
+          return timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
+        } });
+
+    };
+
+    this.pending = function (message) {
+      let fullMessage = j$.Spec.pendingSpecExceptionMessage;
+      if (message) {
+        fullMessage += message;
+      }
+      throw fullMessage;
+    };
+
+    this.fail = function (error) {
+      let message = 'Failed';
+      if (error) {
+        message += ': ';
+        message += error.message || error;
+      }
+
+      currentRunnable().addExpectationResult(false, {
+        matcherName: '',
+        passed: false,
+        expected: '',
+        actual: '',
+        message,
+        error: error && error.message ? error : null });
+
+    };
+  }
+
+  return Env;
+};

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/JsApiReporter.js

@@ -0,0 +1,112 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+const noopTimer = {
+  start() {},
+  elapsed() {
+    return 0;
+  } };
+
+
+function JsApiReporter(options) {
+  const timer = options.timer || noopTimer;
+  let status = 'loaded';
+
+  this.started = false;
+  this.finished = false;
+  this.runDetails = {};
+
+  this.jasmineStarted = function () {
+    this.started = true;
+    status = 'started';
+    timer.start();
+  };
+
+  let executionTime;
+
+  this.jasmineDone = function (runDetails) {
+    this.finished = true;
+    this.runDetails = runDetails;
+    executionTime = timer.elapsed();
+    status = 'done';
+  };
+
+  this.status = function () {
+    return status;
+  };
+
+  const suites = [];
+  const suites_hash = {};
+
+  this.suiteStarted = function (result) {
+    suites_hash[result.id] = result;
+  };
+
+  this.suiteDone = function (result) {
+    storeSuite(result);
+  };
+
+  this.suiteResults = function (index, length) {
+    return suites.slice(index, index + length);
+  };
+
+  function storeSuite(result) {
+    suites.push(result);
+    suites_hash[result.id] = result;
+  }
+
+  this.suites = function () {
+    return suites_hash;
+  };
+
+  const specs = [];
+
+  this.specDone = function (result) {
+    specs.push(result);
+  };
+
+  this.specResults = function (index, length) {
+    return specs.slice(index, index + length);
+  };
+
+  this.specs = function () {
+    return specs;
+  };
+
+  this.executionTime = function () {
+    return executionTime;
+  };
+}
+
+module.exports = JsApiReporter;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/ReportDispatcher.js

@@ -0,0 +1,77 @@
+"use strict"; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+function ReportDispatcher(methods) {
+  const dispatchedMethods = methods || [];
+
+  for (let i = 0; i < dispatchedMethods.length; i++) {
+    const method = dispatchedMethods[i];
+    this[method] = function (m) {
+      return function () {
+        dispatch(m, arguments);
+      };
+    }(method);
+  }
+
+  let reporters = [];
+  let fallbackReporter = null;
+
+  this.addReporter = function (reporter) {
+    reporters.push(reporter);
+  };
+
+  this.provideFallbackReporter = function (reporter) {
+    fallbackReporter = reporter;
+  };
+
+  this.clearReporters = function () {
+    reporters = [];
+  };
+
+  return this;
+
+  function dispatch(method, args) {
+    if (reporters.length === 0 && fallbackReporter !== null) {
+      reporters.push(fallbackReporter);
+    }
+    for (let i = 0; i < reporters.length; i++) {
+      const reporter = reporters[i];
+      if (reporter[method]) {
+        reporter[method].apply(reporter, args);
+      }
+    }
+  }
+}
+
+module.exports = ReportDispatcher;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/Spec.js

@@ -0,0 +1,203 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+const ExpectationFailed = require('../ExpectationFailed');
+const expectationResultFactory = require('../expectationResultFactory');
+
+function Spec(attrs) {
+  this.resultCallback = attrs.resultCallback || function () {};
+  this.id = attrs.id;
+  this.description = attrs.description || '';
+  this.queueableFn = attrs.queueableFn;
+  this.beforeAndAfterFns =
+  attrs.beforeAndAfterFns ||
+  function () {
+    return { befores: [], afters: [] };
+  };
+  this.userContext =
+  attrs.userContext ||
+  function () {
+    return {};
+  };
+  this.onStart = attrs.onStart || function () {};
+  this.getSpecName =
+  attrs.getSpecName ||
+  function () {
+    return '';
+  };
+  this.queueRunnerFactory = attrs.queueRunnerFactory || function () {};
+  this.throwOnExpectationFailure = !!attrs.throwOnExpectationFailure;
+
+  this.result = {
+    id: this.id,
+    description: this.description,
+    fullName: this.getFullName(),
+    failedExpectations: [],
+    passedExpectations: [],
+    pendingReason: '' };
+
+}
+
+Spec.prototype.addExpectationResult = function (passed, data, isError) {
+  const expectationResult = expectationResultFactory(data);
+  if (passed) {
+    this.result.passedExpectations.push(expectationResult);
+  } else {
+    this.result.failedExpectations.push(expectationResult);
+
+    if (this.throwOnExpectationFailure && !isError) {
+      throw new ExpectationFailed();
+    }
+  }
+};
+
+Spec.prototype.execute = function (onComplete, enabled) {
+  const self = this;
+
+  this.onStart(this);
+
+  if (!this.isExecutable() || this.markedPending || enabled === false) {
+    complete(enabled);
+    return;
+  }
+
+  const fns = this.beforeAndAfterFns();
+  const allFns = fns.befores.concat(this.queueableFn).concat(fns.afters);
+
+  this.queueRunnerFactory({
+    queueableFns: allFns,
+    onException() {
+      self.onException.apply(self, arguments);
+    },
+    userContext: this.userContext() }).
+  then(() => complete(true));
+
+  function complete(enabledAgain) {
+    self.result.status = self.status(enabledAgain);
+    self.resultCallback(self.result);
+
+    if (onComplete) {
+      onComplete();
+    }
+  }
+};
+
+Spec.prototype.onException = function onException(error) {
+  if (Spec.isPendingSpecException(error)) {
+    this.pend(extractCustomPendingMessage(error));
+    return;
+  }
+
+  if (error instanceof ExpectationFailed) {
+    return;
+  }
+
+  if (error instanceof require('assert').AssertionError) {
+    const assertionErrorMessage = require('../assert-support');
+    error = assertionErrorMessage(error, { expand: this.expand });
+  }
+
+  this.addExpectationResult(
+  false,
+  {
+    matcherName: '',
+    passed: false,
+    expected: '',
+    actual: '',
+    error },
+
+  true);
+
+};
+
+Spec.prototype.disable = function () {
+  this.disabled = true;
+};
+
+Spec.prototype.pend = function (message) {
+  this.markedPending = true;
+  if (message) {
+    this.result.pendingReason = message;
+  }
+};
+
+Spec.prototype.getResult = function () {
+  this.result.status = this.status();
+  return this.result;
+};
+
+Spec.prototype.status = function (enabled) {
+  if (this.disabled || enabled === false) {
+    return 'disabled';
+  }
+
+  if (this.markedPending) {
+    return 'pending';
+  }
+
+  if (this.result.failedExpectations.length > 0) {
+    return 'failed';
+  } else {
+    return 'passed';
+  }
+};
+
+Spec.prototype.isExecutable = function () {
+  return !this.disabled;
+};
+
+Spec.prototype.getFullName = function () {
+  return this.getSpecName(this);
+};
+
+const extractCustomPendingMessage = function (e) {
+  const fullMessage = e.toString();
+  const boilerplateStart = fullMessage.indexOf(
+  Spec.pendingSpecExceptionMessage);
+
+  const boilerplateEnd =
+  boilerplateStart + Spec.pendingSpecExceptionMessage.length;
+
+  return fullMessage.substr(boilerplateEnd);
+};
+
+Spec.pendingSpecExceptionMessage = '=> marked Pending';
+
+Spec.isPendingSpecException = function (e) {
+  return !!(e &&
+  e.toString &&
+  e.toString().indexOf(Spec.pendingSpecExceptionMessage) !== -1);
+};
+
+module.exports = Spec;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/SpyRegistry.js

@@ -0,0 +1,149 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+const CallTracker = require('./CallTracker');
+const createSpy = require('./createSpy');
+const SpyStrategy = require('./SpyStrategy');
+
+const formatErrorMsg = function () {
+  function generateErrorMsg(domain, usage) {
+    const usageDefinition = usage ? '\nUsage: ' + usage : '';
+
+    return function errorMsg(msg) {
+      return domain + ' : ' + msg + usageDefinition;
+    };
+  }
+
+  return generateErrorMsg;
+};
+
+function isSpy(putativeSpy) {
+  if (!putativeSpy) {
+    return false;
+  }
+  return (
+    putativeSpy.and instanceof SpyStrategy &&
+    putativeSpy.calls instanceof CallTracker);
+
+}
+
+const getErrorMsg = formatErrorMsg('<spyOn>', 'spyOn(<object>, <methodName>)');
+
+function SpyRegistry(options) {
+  options = options || {};
+  const currentSpies =
+  options.currentSpies ||
+  function () {
+    return [];
+  };
+
+  this.allowRespy = function (allow) {
+    this.respy = allow;
+  };
+
+  this.spyOn = function (obj, methodName) {
+    if (obj === void 0) {
+      throw new Error(
+      getErrorMsg(
+      'could not find an object to spy upon for ' + methodName + '()'));
+
+
+    }
+
+    if (methodName === void 0) {
+      throw new Error(getErrorMsg('No method name supplied'));
+    }
+
+    if (obj[methodName] === void 0) {
+      throw new Error(getErrorMsg(methodName + '() method does not exist'));
+    }
+
+    if (obj[methodName] && isSpy(obj[methodName])) {
+      if (this.respy) {
+        return obj[methodName];
+      } else {
+        throw new Error(
+        getErrorMsg(methodName + ' has already been spied upon'));
+
+      }
+    }
+
+    let descriptor;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(obj, methodName);
+    } catch (e) {
+      // IE 8 doesn't support `definePropery` on non-DOM nodes
+    }
+
+    if (descriptor && !(descriptor.writable || descriptor.set)) {
+      throw new Error(
+      getErrorMsg(methodName + ' is not declared writable or has no setter'));
+
+    }
+
+    const originalMethod = obj[methodName];
+    const spiedMethod = createSpy(methodName, originalMethod);
+    let restoreStrategy;
+
+    if (Object.prototype.hasOwnProperty.call(obj, methodName)) {
+      restoreStrategy = function () {
+        obj[methodName] = originalMethod;
+      };
+    } else {
+      restoreStrategy = function () {
+        if (!delete obj[methodName]) {
+          obj[methodName] = originalMethod;
+        }
+      };
+    }
+
+    currentSpies().push({
+      restoreObjectToOriginalState: restoreStrategy });
+
+
+    obj[methodName] = spiedMethod;
+
+    return spiedMethod;
+  };
+
+  this.clearSpies = function () {
+    const spies = currentSpies();
+    for (let i = spies.length - 1; i >= 0; i--) {
+      const spyEntry = spies[i];
+      spyEntry.restoreObjectToOriginalState();
+    }
+  };
+}
+
+module.exports = SpyRegistry;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/SpyStrategy.js

@@ -0,0 +1,95 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+function SpyStrategy(options) {
+  options = options || {};
+
+  const identity = options.name || 'unknown';
+  const originalFn = options.fn || function () {};
+  const getSpy = options.getSpy || function () {};
+  let plan = function () {};
+
+  this.identity = function () {
+    return identity;
+  };
+
+  this.exec = function () {
+    return plan.apply(this, arguments);
+  };
+
+  this.callThrough = function () {
+    plan = originalFn;
+    return getSpy();
+  };
+
+  this.returnValue = function (value) {
+    plan = function () {
+      return value;
+    };
+    return getSpy();
+  };
+
+  this.returnValues = function () {
+    const values = Array.prototype.slice.call(arguments);
+    plan = function () {
+      return values.shift();
+    };
+    return getSpy();
+  };
+
+  this.throwError = function (something) {
+    const error = something instanceof Error ? something : new Error(something);
+    plan = function () {
+      throw error;
+    };
+    return getSpy();
+  };
+
+  this.callFake = function (fn) {
+    if (typeof fn !== 'function') {
+      throw new Error(
+      'Argument passed to callFake should be a function, got ' + fn);
+
+    }
+    plan = fn;
+    return getSpy();
+  };
+
+  this.stub = function (fn) {
+    plan = function () {};
+    return getSpy();
+  };
+}
+
+module.exports = SpyStrategy;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/Suite.js

@@ -0,0 +1,192 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+const ExpectationFailed = require('../ExpectationFailed');
+const expectationResultFactory = require('../expectationResultFactory');
+
+function Suite(attrs) {
+  this.id = attrs.id;
+  this.parentSuite = attrs.parentSuite;
+  this.description = attrs.description;
+  this.throwOnExpectationFailure = !!attrs.throwOnExpectationFailure;
+
+  this.beforeFns = [];
+  this.afterFns = [];
+  this.beforeAllFns = [];
+  this.afterAllFns = [];
+  this.disabled = false;
+
+  this.children = [];
+
+  this.result = {
+    id: this.id,
+    description: this.description,
+    fullName: this.getFullName(),
+    failedExpectations: [] };
+
+}
+
+Suite.prototype.getFullName = function () {
+  const fullName = [];
+  for (
+  let parentSuite = this;
+  parentSuite;
+  parentSuite = parentSuite.parentSuite)
+  {
+    if (parentSuite.parentSuite) {
+      fullName.unshift(parentSuite.description);
+    }
+  }
+  return fullName.join(' ');
+};
+
+Suite.prototype.disable = function () {
+  this.disabled = true;
+};
+
+Suite.prototype.pend = function (message) {
+  this.markedPending = true;
+};
+
+Suite.prototype.beforeEach = function (fn) {
+  this.beforeFns.unshift(fn);
+};
+
+Suite.prototype.beforeAll = function (fn) {
+  this.beforeAllFns.push(fn);
+};
+
+Suite.prototype.afterEach = function (fn) {
+  this.afterFns.unshift(fn);
+};
+
+Suite.prototype.afterAll = function (fn) {
+  this.afterAllFns.unshift(fn);
+};
+
+Suite.prototype.addChild = function (child) {
+  this.children.push(child);
+};
+
+Suite.prototype.status = function () {
+  if (this.disabled) {
+    return 'disabled';
+  }
+
+  if (this.markedPending) {
+    return 'pending';
+  }
+
+  if (this.result.failedExpectations.length > 0) {
+    return 'failed';
+  } else {
+    return 'finished';
+  }
+};
+
+Suite.prototype.isExecutable = function () {
+  return !this.disabled;
+};
+
+Suite.prototype.canBeReentered = function () {
+  return this.beforeAllFns.length === 0 && this.afterAllFns.length === 0;
+};
+
+Suite.prototype.getResult = function () {
+  this.result.status = this.status();
+  return this.result;
+};
+
+Suite.prototype.sharedUserContext = function () {
+  if (!this.sharedContext) {
+    this.sharedContext = {};
+  }
+
+  return this.sharedContext;
+};
+
+Suite.prototype.clonedSharedUserContext = function () {
+  return this.sharedUserContext();
+};
+
+Suite.prototype.onException = function () {
+  if (arguments[0] instanceof ExpectationFailed) {
+    return;
+  }
+
+  if (isAfterAll(this.children)) {
+    const data = {
+      matcherName: '',
+      passed: false,
+      expected: '',
+      actual: '',
+      error: arguments[0] };
+
+    this.result.failedExpectations.push(expectationResultFactory(data));
+  } else {
+    for (let i = 0; i < this.children.length; i++) {
+      const child = this.children[i];
+      child.onException.apply(child, arguments);
+    }
+  }
+};
+
+Suite.prototype.addExpectationResult = function () {
+  if (isAfterAll(this.children) && isFailure(arguments)) {
+    const data = arguments[1];
+    this.result.failedExpectations.push(expectationResultFactory(data));
+    if (this.throwOnExpectationFailure) {
+      throw new ExpectationFailed();
+    }
+  } else {
+    for (let i = 0; i < this.children.length; i++) {
+      const child = this.children[i];
+      try {
+        child.addExpectationResult.apply(child, arguments);
+      } catch (e) {
+        // keep going
+      }
+    }
+  }
+};
+
+function isAfterAll(children) {
+  return children && children[0].result.status;
+}
+
+function isFailure(args) {
+  return !args[0];
+}
+
+module.exports = Suite;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/Timer.js

@@ -0,0 +1,56 @@
+"use strict"; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* eslint-disable sort-keys */
+
+const defaultNow = function (Date) {
+  return function () {
+    return new Date().getTime();
+  };
+}(Date);
+
+function Timer(options) {
+  options = options || {};
+
+  const now = options.now || defaultNow;
+  let startTime;
+
+  this.start = function () {
+    startTime = now();
+  };
+
+  this.elapsed = function () {
+    return now() - startTime;
+  };
+}
+
+module.exports = Timer;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/createSpy.js

@@ -0,0 +1,76 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               */
+// This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+/* eslint-disable sort-keys */
+
+const CallTracker = require('./CallTracker');
+const SpyStrategy = require('./SpyStrategy');
+
+function createSpy(name, originalFn) {
+  const spyStrategy = new SpyStrategy({
+    name,
+    fn: originalFn,
+    getSpy() {
+      return spy;
+    } });
+
+  const callTracker = new CallTracker();
+  const spy = function () {
+    const callData = {
+      object: this,
+      args: Array.prototype.slice.apply(arguments) };
+
+
+    callTracker.track(callData);
+    const returnValue = spyStrategy.exec.apply(this, arguments);
+    callData.returnValue = returnValue;
+
+    return returnValue;
+  };
+
+  for (const prop in originalFn) {
+    if (prop === 'and' || prop === 'calls') {
+      throw new Error(
+      "Jasmine spies would overwrite the 'and' and 'calls' properties " +
+      'on the object being spied upon');
+
+    }
+
+    spy[prop] = originalFn[prop];
+  }
+
+  spy.and = spyStrategy;
+  spy.calls = callTracker;
+
+  return spy;
+}
+
+module.exports = createSpy;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jasmine/jasmine-light.js

@@ -0,0 +1,131 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const createSpy = require('./createSpy'); /**
+                                           * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                           *
+                                           * This source code is licensed under the BSD-style license found in the
+                                           * LICENSE file in the root directory of this source tree. An additional grant
+                                           * of patent rights can be found in the PATENTS file in the same directory.
+                                           *
+                                           */ // This file is a heavily modified fork of Jasmine. Original license:
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/ /* eslint-disable sort-keys */const Env = require('./Env');const JsApiReporter = require('./JsApiReporter');const ReportDispatcher = require('./ReportDispatcher');const Spec = require('./Spec');const SpyRegistry = require('./SpyRegistry');const Suite = require('./Suite');const Timer = require('./Timer');exports.create = function () {const j$ = {};j$.DEFAULT_TIMEOUT_INTERVAL = 5000;j$.getEnv = function (options) {const env = j$.currentEnv_ = j$.currentEnv_ || new j$.Env(options); //jasmine. singletons in here (setTimeout blah blah).
+    return env;};j$.createSpy = createSpy;j$.Env = Env(j$);j$.JsApiReporter = JsApiReporter;j$.ReportDispatcher = ReportDispatcher;j$.Spec = Spec;j$.SpyRegistry = SpyRegistry;j$.Suite = Suite;j$.Timer = Timer;j$.version = '2.5.2-light';return j$;};
+
+exports.interface = function (jasmine, env) {
+  const jasmineInterface = {
+    describe(description, specDefinitions) {
+      return env.describe(description, specDefinitions);
+    },
+
+    xdescribe(description, specDefinitions) {
+      return env.xdescribe(description, specDefinitions);
+    },
+
+    fdescribe(description, specDefinitions) {
+      return env.fdescribe(description, specDefinitions);
+    },
+
+    it() {
+      return env.it.apply(env, arguments);
+    },
+
+    xit() {
+      return env.xit.apply(env, arguments);
+    },
+
+    fit() {
+      return env.fit.apply(env, arguments);
+    },
+
+    beforeEach() {
+      return env.beforeEach.apply(env, arguments);
+    },
+
+    afterEach() {
+      return env.afterEach.apply(env, arguments);
+    },
+
+    beforeAll() {
+      return env.beforeAll.apply(env, arguments);
+    },
+
+    afterAll() {
+      return env.afterAll.apply(env, arguments);
+    },
+
+    pending() {
+      return env.pending.apply(env, arguments);
+    },
+
+    fail() {
+      return env.fail.apply(env, arguments);
+    },
+
+    spyOn(obj, methodName) {
+      return env.spyOn(obj, methodName);
+    },
+
+    jsApiReporter: new jasmine.JsApiReporter({
+      timer: new jasmine.Timer() }),
+
+
+    jasmine };
+
+
+  return jasmineInterface;
+};

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/jest-expect.js

@@ -0,0 +1,60 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const expect = require('jest-matchers'); /**
+                                          * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                          *
+                                          * This source code is licensed under the BSD-style license found in the
+                                          * LICENSE file in the root directory of this source tree. An additional grant
+                                          * of patent rights can be found in the PATENTS file in the same directory.
+                                          *
+                                          * 
+                                          */var _require = require('jest-snapshot');const addSerializer = _require.addSerializer,toMatchSnapshot = _require.toMatchSnapshot,toThrowErrorMatchingSnapshot = _require.toThrowErrorMatchingSnapshot;
+
+
+
+
+
+
+module.exports = config => {
+  global.expect = expect;
+  expect.setState({
+    expand: config.expand });
+
+  expect.extend({ toMatchSnapshot, toThrowErrorMatchingSnapshot });
+  expect.addSnapshotSerializer = addSerializer;
+
+  const jasmine = global.jasmine;
+  jasmine.anything = expect.anything;
+  jasmine.any = expect.any;
+  jasmine.objectContaining = expect.objectContaining;
+  jasmine.arrayContaining = expect.arrayContaining;
+  jasmine.stringMatching = expect.stringMatching;
+
+  jasmine.addMatchers = jasmineMatchersObject => {
+    const jestMatchersObject = Object.create(null);
+    Object.keys(jasmineMatchersObject).forEach(name => {
+      jestMatchersObject[name] = function () {
+        const result = jasmineMatchersObject[name](jasmine.matchersUtil, null);
+        // if there is no 'negativeCompare', both should be handled by `compare`
+        const negativeCompare = result.negativeCompare || result.compare;
+
+        return this.isNot ?
+        negativeCompare.apply(null, arguments) :
+        result.compare.apply(null, arguments);
+      };
+    });
+
+    const expect = global.expect;
+    expect.extend(jestMatchersObject);
+  };
+};

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/p-timeout.js

@@ -0,0 +1,35 @@
+"use strict"; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+// A specialized version of `p-timeout` that does not touch globals.
+// It does not throw on timeout.
+function pTimeout(
+promise,
+ms,
+clearTimeout,
+setTimeout,
+onTimeout)
+{
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => resolve(onTimeout()), ms);
+    promise.then(
+    val => {
+      clearTimeout(timer);
+      resolve(val);
+    },
+    err => {
+      clearTimeout(timer);
+      reject(err);
+    });
+
+  });
+}
+
+module.exports = pTimeout;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/queueRunner.js

@@ -0,0 +1,64 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+const once = require('once');
+const pMap = require('p-map');
+const pTimeout = require('./p-timeout');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function queueRunner(options) {
+  const mapper = (_ref) => {let fn = _ref.fn,timeout = _ref.timeout;
+    const promise = new Promise(resolve => {
+      const next = once(resolve);
+      next.fail = function () {
+        options.fail.apply(null, arguments);
+        resolve();
+      };
+      try {
+        fn.call(options.userContext, next);
+      } catch (e) {
+        options.onException(e);
+        resolve();
+      }
+    });
+    if (!timeout) {
+      return promise;
+    }
+    return pTimeout(
+    promise,
+    timeout(),
+    options.clearTimeout,
+    options.setTimeout,
+    () => {
+      const error = new Error(
+      'Timeout - Async callback was not invoked within timeout specified ' +
+      'by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
+
+      options.onException(error);
+    });
+
+  };
+  return pMap(options.queueableFns, mapper, { concurrency: 1 });
+}
+
+module.exports = queueRunner;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/reporter.js

@@ -0,0 +1,176 @@
+'use strict';var _require =
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+require('jest-message-util');const formatResultsErrors = _require.formatResultsErrors; /**
+                                                                                        * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                                                        *
+                                                                                        * This source code is licensed under the BSD-style license found in the
+                                                                                        * LICENSE file in the root directory of this source tree. An additional grant
+                                                                                        * of patent rights can be found in the PATENTS file in the same directory.
+                                                                                        *
+                                                                                        * 
+                                                                                        */
+
+
+
+
+
+
+
+
+class Jasmine2Reporter {
+
+
+
+
+
+
+
+
+
+  constructor(
+  globalConfig,
+  config,
+  environment,
+  testPath)
+  {
+    this._globalConfig = globalConfig;
+    this._config = config;
+    this._testPath = testPath;
+    this._testResults = [];
+    this._currentSuites = [];
+    this._resolve = null;
+    this._resultsPromise = new Promise(resolve => this._resolve = resolve);
+    this._startTimes = new Map();
+  }
+
+  specStarted(spec) {
+    this._startTimes.set(spec.id, Date.now());
+  }
+
+  specDone(result) {
+    this._testResults.push(
+    this._extractSpecResults(result, this._currentSuites.slice(0)));
+
+  }
+
+  suiteStarted(suite) {
+    this._currentSuites.push(suite.description);
+  }
+
+  suiteDone() {
+    this._currentSuites.pop();
+  }
+
+  jasmineDone() {
+    let numFailingTests = 0;
+    let numPassingTests = 0;
+    let numPendingTests = 0;
+    const testResults = this._testResults;
+    testResults.forEach(testResult => {
+      if (testResult.status === 'failed') {
+        numFailingTests++;
+      } else if (testResult.status === 'pending') {
+        numPendingTests++;
+      } else {
+        numPassingTests++;
+      }
+    });
+
+    const testResult = {
+      console: null,
+      failureMessage: formatResultsErrors(
+      testResults,
+      this._config,
+      this._globalConfig,
+      this._testPath),
+
+      numFailingTests,
+      numPassingTests,
+      numPendingTests,
+      perfStats: {
+        end: 0,
+        start: 0 },
+
+      snapshot: {
+        added: 0,
+        fileDeleted: false,
+        matched: 0,
+        unchecked: 0,
+        unmatched: 0,
+        updated: 0 },
+
+      testFilePath: this._testPath,
+      testResults };
+
+
+    this._resolve(testResult);
+  }
+
+  getResults() {
+    return this._resultsPromise;
+  }
+
+  _addMissingMessageToStack(stack, message) {
+    // Some errors (e.g. Angular injection error) don't prepend error.message
+    // to stack, instead the first line of the stack is just plain 'Error'
+    const ERROR_REGEX = /^Error\s*\n/;
+    if (
+    stack &&
+    message &&
+    ERROR_REGEX.test(stack) &&
+    stack.indexOf(message) === -1)
+    {
+      return message + stack.replace(ERROR_REGEX, '\n');
+    }
+    return stack;
+  }
+
+  _extractSpecResults(
+  specResult,
+  ancestorTitles)
+  {
+    const start = this._startTimes.get(specResult.id);
+    const duration = start ? Date.now() - start : undefined;
+    const status = specResult.status === 'disabled' ?
+    'pending' :
+    specResult.status;
+    const results = {
+      ancestorTitles,
+      duration,
+      failureMessages: [],
+      fullName: specResult.fullName,
+      numPassingAsserts: 0, // Jasmine2 only returns an array of failed asserts.
+      status,
+      title: specResult.description };
+
+
+    specResult.failedExpectations.forEach(failed => {
+      const message = !failed.matcherName && failed.stack ?
+      this._addMissingMessageToStack(failed.stack, failed.message) :
+      failed.message || '';
+      results.failureMessages.push(message);
+    });
+
+    return results;
+  }}
+
+
+module.exports = Jasmine2Reporter;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/setup-jest-globals.js

@@ -0,0 +1,149 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */var _require =
+
+
+
+
+require('jest-matchers');const getState = _require.getState,setState = _require.setState;var _require2 =
+require('jest-snapshot');const SnapshotState = _require2.SnapshotState,addSerializer = _require2.addSerializer;var _require3 =
+
+
+
+
+
+require('jest-matcher-utils');const EXPECTED_COLOR = _require3.EXPECTED_COLOR,RECEIVED_COLOR = _require3.RECEIVED_COLOR,matcherHint = _require3.matcherHint,pluralize = _require3.pluralize;
+
+
+
+
+
+
+
+
+// Get suppressed errors form  jest-matchers that weren't throw during
+// test execution and add them to the test result, potentially failing
+// a passing test.
+const addSuppressedErrors = result => {var _getState =
+  getState();const suppressedErrors = _getState.suppressedErrors;
+  setState({ suppressedErrors: [] });
+  if (suppressedErrors.length) {
+    result.status = 'failed';
+
+    result.failedExpectations = suppressedErrors.map(error => ({
+      actual: '',
+      // passing error for custom test reporters
+      error,
+      expected: '',
+      message: error.message,
+      passed: false,
+      stack: error.stack }));
+
+  }
+};
+
+function addAssertionErrors(result) {var _getState2 =
+
+
+
+
+  getState();const assertionCalls = _getState2.assertionCalls,expectedAssertionsNumber = _getState2.expectedAssertionsNumber,isExpectingAssertions = _getState2.isExpectingAssertions;
+  setState({
+    assertionCalls: 0,
+    expectedAssertionsNumber: null });
+
+  if (
+  typeof expectedAssertionsNumber === 'number' &&
+  assertionCalls !== expectedAssertionsNumber)
+  {
+    const expected = EXPECTED_COLOR(
+    pluralize('assertion', expectedAssertionsNumber));
+
+    const message = new Error(
+    matcherHint('.assertions', '', String(expectedAssertionsNumber), {
+      isDirectExpectCall: true }) +
+
+    '\n\n' +
+    `Expected ${expected} to be called but only received ` +
+    RECEIVED_COLOR(pluralize('assertion call', assertionCalls || 0)) +
+    '.').
+    stack;
+    result.status = 'failed';
+    result.failedExpectations.push({
+      actual: assertionCalls,
+      expected: expectedAssertionsNumber,
+      message,
+      passed: false });
+
+  }
+  if (isExpectingAssertions && assertionCalls === 0) {
+    const expected = EXPECTED_COLOR('at least one assertion');
+    const received = RECEIVED_COLOR('received none');
+    const message = new Error(
+    matcherHint('.hasAssertions', '', '', {
+      isDirectExpectCall: true }) +
+
+    '\n\n' +
+    `Expected ${expected} to be called but ${received}.`).
+    stack;
+    result.status = 'failed';
+    result.failedExpectations.push({
+      actual: 'none',
+      expected: 'at least one',
+      message,
+      passed: false });
+
+  }
+}
+
+const patchJasmine = () => {
+  global.jasmine.Spec = (realSpec => {
+    const Spec = function Spec(attr) {
+      const resultCallback = attr.resultCallback;
+      attr.resultCallback = function (result) {
+        addSuppressedErrors(result);
+        addAssertionErrors(result);
+        resultCallback.call(attr, result);
+      };
+      const onStart = attr.onStart;
+      attr.onStart = context => {
+        setState({ currentTestName: context.getFullName() });
+        onStart && onStart.call(attr, context);
+      };
+      realSpec.call(this, attr);
+    };
+
+    Spec.prototype = realSpec.prototype;
+    for (const statics in realSpec) {
+      if (Object.prototype.hasOwnProperty.call(realSpec, statics)) {
+        Spec[statics] = realSpec[statics];
+      }
+    }
+    return Spec;
+  })(global.jasmine.Spec);
+};
+
+module.exports = (_ref) =>
+
+
+
+
+{let config = _ref.config,globalConfig = _ref.globalConfig,localRequire = _ref.localRequire,testPath = _ref.testPath;
+  // Jest tests snapshotSerializers in order preceding built-in serializers.
+  // Therefore, add in reverse because the last added is the first tested.
+  config.snapshotSerializers.concat().reverse().forEach(path => {
+    addSerializer(localRequire(path));
+  });
+  patchJasmine();const
+  expand = globalConfig.expand,updateSnapshot = globalConfig.updateSnapshot;
+  const snapshotState = new SnapshotState(testPath, { expand, updateSnapshot });
+  setState({ snapshotState, testPath });
+  // Return it back to the outer scope (test runner outside the VM).
+  return snapshotState;
+};

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/build/treeProcessor.js

@@ -0,0 +1,80 @@
+'use strict';function _asyncToGenerator(fn) {return function () {var gen = fn.apply(this, arguments);return new Promise(function (resolve, reject) {function step(key, arg) {try {var info = gen[key](arg);var value = info.value;} catch (error) {reject(error);return;}if (info.done) {resolve(value);} else {return Promise.resolve(value).then(function (value) {step("next", value);}, function (err) {step("throw", err);});}}return step("next");});};} /**
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                * This source code is licensed under the BSD-style license found in the
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                * LICENSE file in the root directory of this source tree. An additional grant
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                * of patent rights can be found in the PATENTS file in the same directory.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                * 
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function treeProcessor(options) {const
+
+  nodeComplete =
+
+
+
+
+  options.nodeComplete,nodeStart = options.nodeStart,queueRunnerFactory = options.queueRunnerFactory,runnableIds = options.runnableIds,tree = options.tree;
+
+  function isEnabled(node, parentEnabled) {
+    return parentEnabled || runnableIds.indexOf(node.id) !== -1;
+  }
+
+  return queueRunnerFactory({
+    onException: error => tree.onException(error),
+    queueableFns: wrapChildren(tree, isEnabled(tree, false)),
+    userContext: tree.sharedUserContext() });
+
+
+  function executeNode(node, parentEnabled) {
+    const enabled = isEnabled(node, parentEnabled);
+    if (!node.children) {
+      return {
+        fn(done) {
+          node.execute(done, enabled);
+        } };
+
+    }
+    return {
+      fn(done) {return _asyncToGenerator(function* () {
+          nodeStart(node);
+          yield queueRunnerFactory({
+            onException: function (error) {return node.onException(error);},
+            queueableFns: wrapChildren(node, enabled),
+            userContext: node.sharedUserContext() });
+
+          nodeComplete(node);
+          done();})();
+      } };
+
+  }
+
+  function wrapChildren(node, enabled) {
+    if (!node.children) {
+      throw new Error('`node.children` is not defined.');
+    }
+    const children = node.children.map(child => executeNode(child, enabled));
+    return node.beforeAllFns.concat(children).concat(node.afterAllFns);
+  }
+}
+
+module.exports = treeProcessor;

torrent-project/node_modules/react-scripts/node_modules/jest-jasmine2/package.json

@@ -0,0 +1,57 @@
+{
+  "_args": [
+    [
+      "jest-jasmine2@20.0.4",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "jest-jasmine2@20.0.4",
+  "_id": "jest-jasmine2@20.0.4",
+  "_inBundle": false,
+  "_integrity": "sha1-/MWxQReA2RHQQpAu8YWehS5g1eE=",
+  "_location": "/react-scripts/jest-jasmine2",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "jest-jasmine2@20.0.4",
+    "name": "jest-jasmine2",
+    "escapedName": "jest-jasmine2",
+    "rawSpec": "20.0.4",
+    "saveSpec": null,
+    "fetchSpec": "20.0.4"
+  },
+  "_requiredBy": [
+    "/react-scripts/jest-config",
+    "/react-scripts/jest/jest-cli"
+  ],
+  "_resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-20.0.4.tgz",
+  "_spec": "20.0.4",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "bugs": {
+    "url": "https://github.com/facebook/jest/issues"
+  },
+  "dependencies": {
+    "chalk": "^1.1.3",
+    "graceful-fs": "^4.1.11",
+    "jest-diff": "^20.0.3",
+    "jest-matcher-utils": "^20.0.3",
+    "jest-matchers": "^20.0.3",
+    "jest-message-util": "^20.0.3",
+    "jest-snapshot": "^20.0.3",
+    "once": "^1.4.0",
+    "p-map": "^1.1.1"
+  },
+  "devDependencies": {
+    "jest-runtime": "^20.0.4"
+  },
+  "homepage": "https://github.com/facebook/jest#readme",
+  "license": "BSD-3-Clause",
+  "main": "build/index.js",
+  "name": "jest-jasmine2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/jest.git"
+  },
+  "version": "20.0.4"
+}