Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

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

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

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/bin/jest-runtime.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * 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.
+ */
+
+if (process.env.NODE_ENV == null) {
+  process.env.NODE_ENV = 'test';
+}
+
+require('../build/cli').run();

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/build/ScriptTransformer.js

@@ -0,0 +1,415 @@
+'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 crypto = require('crypto');
+const path = require('path');
+const vm = require('vm');var _require =
+require('jest-util');const createDirectory = _require.createDirectory;
+const fs = require('graceful-fs');var _require2 =
+require('jest-haste-map');const getCacheFilePath = _require2.getCacheFilePath;
+const stableStringify = require('json-stable-stringify');
+const slash = require('slash');
+
+const VERSION = require('../package.json').version;
+const shouldInstrument = require('./shouldInstrument');
+
+
+
+
+
+
+
+
+
+const cache = new Map();
+const configToJsonMap = new Map();
+// Cache regular expressions to test whether the file needs to be preprocessed
+const ignoreCache = new WeakMap();
+
+class ScriptTransformer {
+
+
+
+
+  constructor(config) {
+    this._config = config;
+    this._transformCache = new Map();
+  }
+
+  _getCacheKey(
+  fileData,
+  filename,
+  instrument,
+  mapCoverage)
+  {
+    if (!configToJsonMap.has(this._config)) {
+      // We only need this set of config options that can likely influence
+      // cached output instead of all config options.
+      configToJsonMap.set(this._config, stableStringify(this._config));
+    }
+    const configString = configToJsonMap.get(this._config) || '';
+    const transformer = this._getTransformer(filename, this._config);
+
+    if (transformer && typeof transformer.getCacheKey === 'function') {
+      return transformer.getCacheKey(fileData, filename, configString, {
+        instrument });
+
+    } else {
+      return crypto.
+      createHash('md5').
+      update(fileData).
+      update(configString).
+      update(instrument ? 'instrument' : '').
+      update(mapCoverage ? 'mapCoverage' : '').
+      digest('hex');
+    }
+  }
+
+  _getFileCachePath(
+  filename,
+  content,
+  instrument,
+  mapCoverage)
+  {
+    const baseCacheDir = getCacheFilePath(
+    this._config.cacheDirectory,
+    'jest-transform-cache-' + this._config.name,
+    VERSION);
+
+    const cacheKey = this._getCacheKey(
+    content,
+    filename,
+    instrument,
+    mapCoverage);
+
+    // Create sub folders based on the cacheKey to avoid creating one
+    // directory with many files.
+    const cacheDir = path.join(baseCacheDir, cacheKey[0] + cacheKey[1]);
+    const cachePath = slash(
+    path.join(
+    cacheDir,
+    path.basename(filename, path.extname(filename)) + '_' + cacheKey));
+
+
+    createDirectory(cacheDir);
+
+    return cachePath;
+  }
+
+  _getTransformPath(filename) {
+    for (let i = 0; i < this._config.transform.length; i++) {
+      if (new RegExp(this._config.transform[i][0]).test(filename)) {
+        return this._config.transform[i][1];
+      }
+    }
+    return null;
+  }
+
+  _getTransformer(filename) {
+    let transform;
+    if (!this._config.transform || !this._config.transform.length) {
+      return null;
+    }
+
+    const transformPath = this._getTransformPath(filename);
+    if (transformPath) {
+      const transformer = this._transformCache.get(transformPath);
+      if (transformer != null) {
+        return transformer;
+      }
+
+      // $FlowFixMe
+      transform = require(transformPath);
+      if (typeof transform.process !== 'function') {
+        throw new TypeError(
+        'Jest: a transform must export a `process` function.');
+
+      }
+      if (typeof transform.createTransformer === 'function') {
+        transform = transform.createTransformer();
+      }
+      this._transformCache.set(transformPath, transform);
+    }
+    return transform;
+  }
+
+  _instrumentFile(filename, content) {
+    // Keeping these requires inside this function reduces a single run
+    // time by 2sec if not running in `--coverage` mode
+    const babel = require('babel-core');
+    const babelPluginIstanbul = require('babel-plugin-istanbul').default;
+
+    return babel.transform(content, {
+      auxiliaryCommentBefore: ' istanbul ignore next ',
+      babelrc: false,
+      filename,
+      plugins: [
+      [
+      babelPluginIstanbul,
+      {
+        // files outside `cwd` will not be instrumented
+        cwd: this._config.rootDir,
+        exclude: [],
+        useInlineSourceMaps: false }]],
+
+
+
+      retainLines: true }).
+    code;
+  }
+
+  transformSource(
+  filename,
+  content,
+  instrument,
+  mapCoverage)
+  {
+    const transform = this._getTransformer(filename);
+    const cacheFilePath = this._getFileCachePath(
+    filename,
+    content,
+    instrument,
+    mapCoverage);
+
+    let sourceMapPath = cacheFilePath + '.map';
+    // Ignore cache if `config.cache` is set (--no-cache)
+    let code = this._config.cache ?
+    readCacheFile(filename, cacheFilePath) :
+    null;
+
+    if (code) {
+      return {
+        code,
+        sourceMapPath };
+
+    }
+
+    let transformed = {
+      code: content,
+      map: null };
+
+
+    if (transform && shouldTransform(filename, this._config)) {
+      const processed = transform.process(content, filename, this._config, {
+        instrument });
+
+
+      if (typeof processed === 'string') {
+        transformed.code = processed;
+      } else {
+        transformed = processed;
+      }
+    }
+
+    if (mapCoverage) {
+      if (!transformed.map) {
+        const convert = require('convert-source-map');
+        const inlineSourceMap = convert.fromSource(transformed.code);
+        if (inlineSourceMap) {
+          transformed.map = inlineSourceMap.toJSON();
+        }
+      }
+    } else {
+      transformed.map = null;
+    }
+
+    // That means that the transform has a custom instrumentation
+    // logic and will handle it based on `config.collectCoverage` option
+    const transformDidInstrument = transform && transform.canInstrument;
+
+    if (!transformDidInstrument && instrument) {
+      code = this._instrumentFile(filename, transformed.code);
+    } else {
+      code = transformed.code;
+    }
+
+    if (instrument && transformed.map && mapCoverage) {
+      const sourceMapContent = typeof transformed.map === 'string' ?
+      transformed.map :
+      JSON.stringify(transformed.map);
+      writeCacheFile(sourceMapPath, sourceMapContent);
+    } else {
+      sourceMapPath = null;
+    }
+
+    writeCacheFile(cacheFilePath, code);
+
+    return {
+      code,
+      sourceMapPath };
+
+  }
+
+  _transformAndBuildScript(
+  filename,
+  options,
+  instrument,
+  fileSource)
+  {
+    const isInternalModule = !!(options && options.isInternalModule);
+    const content = stripShebang(
+    fileSource || fs.readFileSync(filename, 'utf8'));
+
+    let wrappedCode;
+    let sourceMapPath = null;
+    const willTransform =
+    !isInternalModule && (
+    shouldTransform(filename, this._config) || instrument);
+
+    try {
+      if (willTransform) {
+        const transformedSource = this.transformSource(
+        filename,
+        content,
+        instrument,
+        !!(options && options.mapCoverage));
+
+
+        wrappedCode = wrap(transformedSource.code);
+        sourceMapPath = transformedSource.sourceMapPath;
+      } else {
+        wrappedCode = wrap(content);
+      }
+
+      return {
+        script: new vm.Script(wrappedCode, { displayErrors: true, filename }),
+        sourceMapPath };
+
+    } catch (e) {
+      if (e.codeFrame) {
+        e.stack = e.codeFrame;
+      }
+
+      throw e;
+    }
+  }
+
+  transform(
+  filename,
+  options,
+  fileSource)
+  {
+    const instrument = shouldInstrument(filename, options, this._config);
+    const scriptCacheKey = getScriptCacheKey(
+    filename,
+    this._config,
+    instrument);
+
+    let result = cache.get(scriptCacheKey);
+    if (result) {
+      return result;
+    } else {
+      result = this._transformAndBuildScript(
+      filename,
+      options,
+      instrument,
+      fileSource);
+
+      cache.set(scriptCacheKey, result);
+      return result;
+    }
+  }}
+
+
+const removeFile = path => {
+  try {
+    fs.unlinkSync(path);
+  } catch (e) {}
+};
+
+const stripShebang = content => {
+  // If the file data starts with a shebang remove it. Leaves the empty line
+  // to keep stack trace line numbers correct.
+  if (content.startsWith('#!')) {
+    return content.replace(/^#!.*/, '');
+  } else {
+    return content;
+  }
+};
+
+const writeCacheFile = (cachePath, fileData) => {
+  try {
+    fs.writeFileSync(cachePath, fileData, 'utf8');
+  } catch (e) {
+    e.message =
+    'jest: failed to cache transform results in: ' +
+    cachePath +
+    '\nFailure message: ' +
+    e.message;
+    removeFile(cachePath);
+    throw e;
+  }
+};
+
+const readCacheFile = (filename, cachePath) => {
+  if (!fs.existsSync(cachePath)) {
+    return null;
+  }
+
+  let fileData;
+  try {
+    fileData = fs.readFileSync(cachePath, 'utf8');
+  } catch (e) {
+    e.message = 'jest: failed to read cache file: ' + cachePath;
+    removeFile(cachePath);
+    throw e;
+  }
+
+  if (fileData == null) {
+    // We must have somehow created the file but failed to write to it,
+    // let's delete it and retry.
+    removeFile(cachePath);
+  }
+  return fileData;
+};
+
+const getScriptCacheKey = (filename, config, instrument) => {
+  const mtime = fs.statSync(filename).mtime;
+  return filename + '_' + mtime.getTime() + (instrument ? '_instrumented' : '');
+};
+
+const shouldTransform = (filename, config) => {
+  if (!ignoreCache.has(config)) {
+    if (!config.transformIgnorePatterns) {
+      ignoreCache.set(config, null);
+    } else {
+      ignoreCache.set(
+      config,
+      new RegExp(config.transformIgnorePatterns.join('|')));
+
+    }
+  }
+
+  const ignoreRegexp = ignoreCache.get(config);
+  const isIgnored = ignoreRegexp ? ignoreRegexp.test(filename) : false;
+  return (
+    !!config.transform &&
+    !!config.transform.length && (
+    !config.transformIgnorePatterns.length || !isIgnored));
+
+};
+
+const wrap = content =>
+'({"' +
+ScriptTransformer.EVAL_RESULT_VARIABLE +
+'":function(module,exports,require,__dirname,__filename,global,jest){' +
+content +
+'\n}});';
+
+ScriptTransformer.EVAL_RESULT_VARIABLE = 'Object.<anonymous>';
+
+module.exports = ScriptTransformer;

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/build/cli/args.js

@@ -0,0 +1,44 @@
+'use strict'; /**
+               * 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.
+               *
+               * 
+               */
+
+const usage = 'Usage: $0 [--config=<pathToConfigFile>] <file>';
+
+const options = {
+  cache: {
+    default: true,
+    description: 'Whether to use the preprocessor cache. Disable ' +
+    'the cache using --no-cache.',
+    type: 'boolean' },
+
+  config: {
+    alias: 'c',
+    description: 'The path to a Jest config file.',
+    type: 'string' },
+
+  debug: {
+    description: 'Print debugging info about your jest config.',
+    type: 'boolean' },
+
+  version: {
+    alias: 'v',
+    description: 'Print the version and exit',
+    type: 'boolean' },
+
+  watchman: {
+    default: true,
+    description: 'Whether to use watchman for file crawling. Disable using ' +
+    '--no-watchman.',
+    type: 'boolean' } };
+
+
+
+module.exports = {
+  options,
+  usage };

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

@@ -0,0 +1,91 @@
+'use strict'; /**
+              * 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.
+              *
+              * 
+              */
+
+
+
+
+const os = require('os');
+const path = require('path');
+const chalk = require('chalk');
+const yargs = require('yargs');var _require =
+
+require('jest-util');const Console = _require.Console,setGlobal = _require.setGlobal,validateCLIOptions = _require.validateCLIOptions;var _require2 =
+require('jest-config');const readConfig = _require2.readConfig;
+const VERSION = require('../../package.json').version;
+const Runtime = require('../');
+const args = require('./args');
+
+function run(cliArgv, cliInfo) {
+  let argv;
+  if (cliArgv) {
+    argv = cliArgv;
+  } else {
+    argv = yargs.usage(args.usage).options(args.options).argv;
+
+    validateCLIOptions(argv, args.options);
+  }
+
+  if (argv.help) {
+    yargs.showHelp();
+    process.on('exit', () => process.exit(1));
+    return;
+  }
+
+  if (argv.version) {
+    console.log(`v${VERSION}\n`);
+    return;
+  }
+
+  if (!argv._.length) {
+    console.log('Please provide a path to a script. (See --help for details)');
+    process.on('exit', () => process.exit(1));
+    return;
+  }
+
+  const root = process.cwd();
+  const filePath = path.resolve(root, argv._[0]);
+
+  if (argv.debug) {
+    const info = cliInfo ? ', ' + cliInfo.join(', ') : '';
+    console.log(`Using Jest Runtime v${VERSION}${info}`);
+  }
+  const options = readConfig(argv, root);
+  const globalConfig = options.globalConfig;
+  // Always disable automocking in scripts.
+  const config = Object.assign({}, options.config, {
+    automock: false,
+    unmockedModulePathPatterns: null });
+
+  Runtime.createContext(config, {
+    maxWorkers: os.cpus().length - 1,
+    watchman: globalConfig.watchman }).
+
+  then(hasteMap => {
+    /* $FlowFixMe */
+    const Environment = require(config.testEnvironment);
+    const environment = new Environment(config);
+    setGlobal(
+    environment.global,
+    'console',
+    new Console(process.stdout, process.stderr));
+
+    environment.global.jestProjectConfig = config;
+    environment.global.jestGlobalConfig = globalConfig;
+
+    const runtime = new Runtime(config, environment, hasteMap.resolver);
+    runtime.requireModule(filePath);
+  }).
+  catch(e => {
+    console.error(chalk.red(e));
+    process.on('exit', () => process.exit(1));
+  });
+}
+
+exports.run = run;

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

@@ -0,0 +1,765 @@
+'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 HasteMap = require('jest-haste-map');const Resolver = require('jest-resolve');var _require = require('jest-util');const createDirectory = _require.createDirectory;var _require2 = require('jest-regex-util');const escapePathForRegex = _require2.escapePathForRegex;const fs = require('graceful-fs');const stripBOM = require('strip-bom');const ScriptTransformer = require('./ScriptTransformer');
+const shouldInstrument = require('./shouldInstrument');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const NODE_MODULES = path.sep + 'node_modules' + path.sep;
+const SNAPSHOT_EXTENSION = 'snap';
+
+const getModuleNameMapper = config => {
+  if (
+  Array.isArray(config.moduleNameMapper) &&
+  config.moduleNameMapper.length)
+  {
+    return config.moduleNameMapper.map((_ref) => {var _ref2 = _slicedToArray(_ref, 2);let regex = _ref2[0],moduleName = _ref2[1];
+      return { moduleName, regex: new RegExp(regex) };
+    });
+  }
+  return null;
+};
+
+const mockParentModule = {
+  exports: {},
+  filename: 'mock.js',
+  id: 'mockParent' };
+
+
+const unmockRegExpCache = new WeakMap();
+
+class Runtime {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  constructor(
+  config,
+  environment,
+  resolver,
+  cacheFS,
+  coverageOptions)
+  {
+    this._cacheFS = cacheFS || Object.create(null);
+    this._config = config;
+    this._coverageOptions = coverageOptions || {
+      collectCoverage: false,
+      collectCoverageFrom: [],
+      collectCoverageOnlyFrom: null,
+      mapCoverage: false };
+
+    this._currentlyExecutingModulePath = '';
+    this._environment = environment;
+    this._explicitShouldMock = Object.create(null);
+    this._internalModuleRegistry = Object.create(null);
+    this._isCurrentlyExecutingManualMock = null;
+    this._mockFactories = Object.create(null);
+    this._mockRegistry = Object.create(null);
+    this._moduleMocker = this._environment.moduleMocker;
+    this._moduleRegistry = Object.create(null);
+    this._resolver = resolver;
+    this._scriptTransformer = new ScriptTransformer(config);
+    this._shouldAutoMock = config.automock;
+    this._sourceMapRegistry = Object.create(null);
+    this._virtualMocks = Object.create(null);
+
+    this._mockMetaDataCache = Object.create(null);
+    this._shouldMockModuleCache = Object.create(null);
+    this._shouldUnmockTransitiveDependenciesCache = Object.create(null);
+    this._transitiveShouldMock = Object.create(null);
+
+    this._unmockList = unmockRegExpCache.get(config);
+    if (!this._unmockList && config.unmockedModulePathPatterns) {
+      this._unmockList = new RegExp(
+      config.unmockedModulePathPatterns.join('|'));
+
+      unmockRegExpCache.set(config, this._unmockList);
+    }
+
+    if (config.automock) {
+      config.setupFiles.forEach(filePath => {
+        if (filePath && filePath.includes(NODE_MODULES)) {
+          const moduleID = this._resolver.getModuleID(
+          this._virtualMocks,
+          filePath);
+
+          this._transitiveShouldMock[moduleID] = false;
+        }
+      });
+    }
+
+    this.resetModules();
+
+    if (config.setupFiles.length) {
+      for (let i = 0; i < config.setupFiles.length; i++) {
+        this.requireModule(config.setupFiles[i]);
+      }
+    }
+  }
+
+  static shouldInstrument(
+  filename,
+  options,
+  config)
+  {
+    return shouldInstrument(
+    filename,
+    {
+      collectCoverage: options.collectCoverage,
+      collectCoverageFrom: options.collectCoverageFrom,
+      collectCoverageOnlyFrom: options.collectCoverageOnlyFrom,
+      mapCoverage: options.mapCoverage },
+
+    config);
+
+  }
+
+  static createContext(
+  config,
+  options)
+
+
+
+
+
+  {
+    createDirectory(config.cacheDirectory);
+    const instance = Runtime.createHasteMap(config, {
+      console: options.console,
+      maxWorkers: options.maxWorkers,
+      resetCache: !config.cache,
+      watch: options.watch,
+      watchman: options.watchman });
+
+    return instance.build().then(
+    hasteMap => ({
+      config,
+      hasteFS: hasteMap.hasteFS,
+      moduleMap: hasteMap.moduleMap,
+      resolver: Runtime.createResolver(config, hasteMap.moduleMap) }),
+
+    error => {
+      throw error;
+    });
+
+  }
+
+  static createHasteMap(
+  config,
+  options)
+  {
+    const ignorePattern = new RegExp(
+    [config.cacheDirectory].concat(config.modulePathIgnorePatterns).join('|'));
+
+
+    return new HasteMap({
+      cacheDirectory: config.cacheDirectory,
+      console: options && options.console,
+      extensions: [SNAPSHOT_EXTENSION].concat(config.moduleFileExtensions),
+      hasteImplModulePath: config.haste.hasteImplModulePath,
+      ignorePattern,
+      maxWorkers: options && options.maxWorkers || 1,
+      mocksPattern: escapePathForRegex(path.sep + '__mocks__' + path.sep),
+      name: config.name,
+      platforms: config.haste.platforms || ['ios', 'android'],
+      providesModuleNodeModules: config.haste.providesModuleNodeModules,
+      resetCache: options && options.resetCache,
+      retainAllFiles: false,
+      roots: config.roots,
+      useWatchman: options && options.watchman,
+      watch: options && options.watch });
+
+  }
+
+  static createResolver(config, moduleMap) {
+    return new Resolver(moduleMap, {
+      browser: config.browser,
+      defaultPlatform: config.haste.defaultPlatform,
+      extensions: config.moduleFileExtensions.map(extension => '.' + extension),
+      hasCoreModules: true,
+      moduleDirectories: config.moduleDirectories,
+      moduleNameMapper: getModuleNameMapper(config),
+      modulePaths: config.modulePaths,
+      platforms: config.haste.platforms,
+      resolver: config.resolver });
+
+  }
+
+  static runCLI(args, info) {
+    return require('./cli').run(args, info);
+  }
+
+  static getCLIOptions() {
+    return require('./cli/args').options;
+  }
+
+  requireModule(
+  from,
+  moduleName,
+  options)
+  {
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    let modulePath;
+
+    const moduleRegistry = !options || !options.isInternalModule ?
+    this._moduleRegistry :
+    this._internalModuleRegistry;
+
+    // Some old tests rely on this mocking behavior. Ideally we'll change this
+    // to be more explicit.
+    const moduleResource = moduleName && this._resolver.getModule(moduleName);
+    const manualMock =
+    moduleName && this._resolver.getMockModule(from, moduleName);
+    if (
+    (!options || !options.isInternalModule) &&
+    !moduleResource &&
+    manualMock &&
+    manualMock !== this._isCurrentlyExecutingManualMock &&
+    this._explicitShouldMock[moduleID] !== false)
+    {
+      modulePath = manualMock;
+    }
+
+    if (moduleName && this._resolver.isCoreModule(moduleName)) {
+      // $FlowFixMe
+      return require(moduleName);
+    }
+
+    if (!modulePath) {
+      modulePath = this._resolveModule(from, moduleName);
+    }
+
+    if (!moduleRegistry[modulePath]) {
+      // We must register the pre-allocated module object first so that any
+      // circular dependencies that may arise while evaluating the module can
+      // be satisfied.
+      const localModule = {
+        exports: {},
+        filename: modulePath,
+        id: modulePath };
+
+      moduleRegistry[modulePath] = localModule;
+      if (path.extname(modulePath) === '.json') {
+        localModule.exports = this._environment.global.JSON.parse(
+        stripBOM(fs.readFileSync(modulePath, 'utf8')));
+
+      } else if (path.extname(modulePath) === '.node') {
+        // $FlowFixMe
+        localModule.exports = require(modulePath);
+      } else {
+        this._execModule(localModule, options);
+      }
+    }
+    return moduleRegistry[modulePath].exports;
+  }
+
+  requireInternalModule(from, to) {
+    return this.requireModule(from, to, { isInternalModule: true });
+  }
+
+  requireMock(from, moduleName) {
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+
+    if (this._mockRegistry[moduleID]) {
+      return this._mockRegistry[moduleID];
+    }
+
+    if (moduleID in this._mockFactories) {
+      return this._mockRegistry[moduleID] = this._mockFactories[moduleID]();
+    }
+
+    let manualMock = this._resolver.getMockModule(from, moduleName);
+    let modulePath;
+    if (manualMock) {
+      modulePath = this._resolveModule(from, manualMock);
+    } else {
+      modulePath = this._resolveModule(from, moduleName);
+
+      // If the actual module file has a __mocks__ dir sitting immediately next
+      // to it, look to see if there is a manual mock for this file.
+      //
+      // subDir1/MyModule.js
+      // subDir1/__mocks__/MyModule.js
+      // subDir2/MyModule.js
+      // subDir2/__mocks__/MyModule.js
+      //
+      // Where some other module does a relative require into each of the
+      // respective subDir{1,2} directories and expects a manual mock
+      // corresponding to that particular MyModule.js file.
+      const moduleDir = path.dirname(modulePath);
+      const moduleFileName = path.basename(modulePath);
+      const potentialManualMock = path.join(
+      moduleDir,
+      '__mocks__',
+      moduleFileName);
+
+      if (fs.existsSync(potentialManualMock)) {
+        manualMock = true;
+        modulePath = potentialManualMock;
+      }
+    }
+
+    if (manualMock) {
+      const localModule = {
+        exports: {},
+        filename: modulePath,
+        id: modulePath };
+
+      this._execModule(localModule);
+      this._mockRegistry[moduleID] = localModule.exports;
+    } else {
+      // Look for a real module to generate an automock from
+      this._mockRegistry[moduleID] = this._generateMock(from, moduleName);
+    }
+
+    return this._mockRegistry[moduleID];
+  }
+
+  requireModuleOrMock(from, moduleName) {
+    if (this._shouldMock(from, moduleName)) {
+      return this.requireMock(from, moduleName);
+    } else {
+      return this.requireModule(from, moduleName);
+    }
+  }
+
+  resetModules() {
+    this._mockRegistry = Object.create(null);
+    this._moduleRegistry = Object.create(null);
+
+    if (this._environment && this._environment.global) {
+      const envGlobal = this._environment.global;
+      Object.keys(envGlobal).forEach(key => {
+        const globalMock = envGlobal[key];
+        if (
+        typeof globalMock === 'object' && globalMock !== null ||
+        typeof globalMock === 'function')
+        {
+          globalMock._isMockFunction && globalMock.mockClear();
+        }
+      });
+
+      if (envGlobal.mockClearTimers) {
+        envGlobal.mockClearTimers();
+      }
+    }
+  }
+
+  getAllCoverageInfo() {
+    return this._environment.global.__coverage__;
+  }
+
+  getSourceMapInfo() {
+    return Object.keys(this._sourceMapRegistry).reduce((result, sourcePath) => {
+      if (fs.existsSync(this._sourceMapRegistry[sourcePath])) {
+        result[sourcePath] = this._sourceMapRegistry[sourcePath];
+      }
+      return result;
+    }, {});
+  }
+
+  setMock(
+  from,
+  moduleName,
+  mockFactory,
+  options)
+  {
+    if (options && options.virtual) {
+      const mockPath = this._resolver.getModulePath(from, moduleName);
+      this._virtualMocks[mockPath] = true;
+    }
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    this._explicitShouldMock[moduleID] = true;
+    this._mockFactories[moduleID] = mockFactory;
+  }
+
+  resetAllMocks() {
+    this._moduleMocker.resetAllMocks();
+  }
+
+  clearAllMocks() {
+    this._moduleMocker.clearAllMocks();
+  }
+
+  _resolveModule(from, to) {
+    return to ? this._resolver.resolveModule(from, to) : from;
+  }
+
+  _execModule(localModule, options) {
+    // If the environment was disposed, prevent this module from being executed.
+    if (!this._environment.global) {
+      return;
+    }
+
+    const isInternalModule = !!(options && options.isInternalModule);
+    const filename = localModule.filename;
+    const lastExecutingModulePath = this._currentlyExecutingModulePath;
+    this._currentlyExecutingModulePath = filename;
+    const origCurrExecutingManualMock = this._isCurrentlyExecutingManualMock;
+    this._isCurrentlyExecutingManualMock = filename;
+
+    const dirname = path.dirname(filename);
+    localModule.children = [];
+    localModule.parent = mockParentModule;
+    localModule.paths = this._resolver.getModulePaths(dirname);
+    localModule.require = this._createRequireImplementation(filename, options);
+
+    const transformedFile = this._scriptTransformer.transform(
+    filename,
+    {
+      collectCoverage: this._coverageOptions.collectCoverage,
+      collectCoverageFrom: this._coverageOptions.collectCoverageFrom,
+      collectCoverageOnlyFrom: this._coverageOptions.collectCoverageOnlyFrom,
+      isInternalModule,
+      mapCoverage: this._coverageOptions.mapCoverage },
+
+    this._cacheFS[filename]);
+
+
+    if (transformedFile.sourceMapPath) {
+      this._sourceMapRegistry[filename] = transformedFile.sourceMapPath;
+    }
+
+    const wrapper = this._environment.runScript(transformedFile.script)[
+    ScriptTransformer.EVAL_RESULT_VARIABLE];
+
+    wrapper.call(
+    localModule.exports, // module context
+    localModule, // module object
+    localModule.exports, // module exports
+    localModule.require, // require implementation
+    dirname, // __dirname
+    filename, // __filename
+    this._environment.global, // global object
+    this._createRuntimeFor(filename));
+
+
+    this._isCurrentlyExecutingManualMock = origCurrExecutingManualMock;
+    this._currentlyExecutingModulePath = lastExecutingModulePath;
+  }
+
+  _generateMock(from, moduleName) {
+    const modulePath = this._resolveModule(from, moduleName);
+
+    if (!(modulePath in this._mockMetaDataCache)) {
+      // This allows us to handle circular dependencies while generating an
+      // automock
+      this._mockMetaDataCache[modulePath] = this._moduleMocker.getMetadata(
+      {});
+
+
+      // In order to avoid it being possible for automocking to potentially
+      // cause side-effects within the module environment, we need to execute
+      // the module in isolation. This could cause issues if the module being
+      // mocked has calls into side-effectful APIs on another module.
+      const origMockRegistry = this._mockRegistry;
+      const origModuleRegistry = this._moduleRegistry;
+      this._mockRegistry = Object.create(null);
+      this._moduleRegistry = Object.create(null);
+
+      const moduleExports = this.requireModule(from, moduleName);
+
+      // Restore the "real" module/mock registries
+      this._mockRegistry = origMockRegistry;
+      this._moduleRegistry = origModuleRegistry;
+
+      const mockMetadata = this._moduleMocker.getMetadata(moduleExports);
+      if (mockMetadata == null) {
+        throw new Error(
+        `Failed to get mock metadata: ${modulePath}\n\n` +
+        `See: http://facebook.github.io/jest/docs/manual-mocks.html#content`);
+
+      }
+      this._mockMetaDataCache[modulePath] = mockMetadata;
+    }
+    return this._moduleMocker.generateFromMetadata(
+    this._mockMetaDataCache[modulePath]);
+
+  }
+
+  _shouldMock(from, moduleName) {
+    const mockPath = this._resolver.getModulePath(from, moduleName);
+    if (mockPath in this._virtualMocks) {
+      return true;
+    }
+
+    const explicitShouldMock = this._explicitShouldMock;
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    const key = from + path.delimiter + moduleID;
+
+    if (moduleID in explicitShouldMock) {
+      return explicitShouldMock[moduleID];
+    }
+
+    if (
+    !this._shouldAutoMock ||
+    this._resolver.isCoreModule(moduleName) ||
+    this._shouldUnmockTransitiveDependenciesCache[key])
+    {
+      return false;
+    }
+
+    if (moduleID in this._shouldMockModuleCache) {
+      return this._shouldMockModuleCache[moduleID];
+    }
+
+    let modulePath;
+    try {
+      modulePath = this._resolveModule(from, moduleName);
+    } catch (e) {
+      const manualMock = this._resolver.getMockModule(from, moduleName);
+      if (manualMock) {
+        this._shouldMockModuleCache[moduleID] = true;
+        return true;
+      }
+      throw e;
+    }
+
+    if (this._unmockList && this._unmockList.test(modulePath)) {
+      this._shouldMockModuleCache[moduleID] = false;
+      return false;
+    }
+
+    // transitive unmocking for package managers that store flat packages (npm3)
+    const currentModuleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from);
+
+    if (
+    this._transitiveShouldMock[currentModuleID] === false ||
+    from.includes(NODE_MODULES) &&
+    modulePath.includes(NODE_MODULES) && (
+    this._unmockList && this._unmockList.test(from) ||
+    explicitShouldMock[currentModuleID] === false))
+    {
+      this._transitiveShouldMock[moduleID] = false;
+      this._shouldUnmockTransitiveDependenciesCache[key] = true;
+      return false;
+    }
+
+    return this._shouldMockModuleCache[moduleID] = true;
+  }
+
+  _createRequireImplementation(from, options) {
+    const moduleRequire = options && options.isInternalModule ?
+    moduleName => this.requireInternalModule(from, moduleName) :
+    this.requireModuleOrMock.bind(this, from);
+    moduleRequire.cache = Object.create(null);
+    moduleRequire.extensions = Object.create(null);
+    moduleRequire.requireActual = this.requireModule.bind(this, from);
+    moduleRequire.requireMock = this.requireMock.bind(this, from);
+    moduleRequire.resolve = moduleName => this._resolveModule(from, moduleName);
+    return moduleRequire;
+  }
+
+  _createRuntimeFor(from) {
+    const disableAutomock = () => {
+      this._shouldAutoMock = false;
+      return runtime;
+    };
+    const enableAutomock = () => {
+      this._shouldAutoMock = true;
+      return runtime;
+    };
+    const unmock = moduleName => {
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = false;
+      return runtime;
+    };
+    const deepUnmock = moduleName => {
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = false;
+      this._transitiveShouldMock[moduleID] = false;
+      return runtime;
+    };
+    const mock = (
+    moduleName,
+    mockFactory,
+    options) =>
+    {
+      if (mockFactory !== undefined) {
+        return setMockFactory(moduleName, mockFactory, options);
+      }
+
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = true;
+      return runtime;
+    };
+    const setMockFactory = (moduleName, mockFactory, options) => {
+      this.setMock(from, moduleName, mockFactory, options);
+      return runtime;
+    };
+    const clearAllMocks = () => {
+      this.clearAllMocks();
+      return runtime;
+    };
+    const resetAllMocks = () => {
+      this.resetAllMocks();
+      return runtime;
+    };
+    const useFakeTimers = () => {
+      this._environment.fakeTimers.useFakeTimers();
+      return runtime;
+    };
+    const useRealTimers = () => {
+      this._environment.fakeTimers.useRealTimers();
+      return runtime;
+    };
+    const resetModules = () => {
+      this.resetModules();
+      return runtime;
+    };
+    const fn = this._moduleMocker.fn.bind(this._moduleMocker);
+    const spyOn = this._moduleMocker.spyOn.bind(this._moduleMocker);
+
+    const runtime = {
+      addMatchers: matchers =>
+      this._environment.global.jasmine.addMatchers(matchers),
+
+      autoMockOff: disableAutomock,
+      autoMockOn: enableAutomock,
+      clearAllMocks,
+      clearAllTimers: () => this._environment.fakeTimers.clearAllTimers(),
+      deepUnmock,
+      disableAutomock,
+      doMock: mock,
+      dontMock: unmock,
+      enableAutomock,
+      fn,
+      genMockFn: fn,
+      genMockFromModule: moduleName =>
+      this._generateMock(from, moduleName),
+      genMockFunction: fn,
+      isMockFunction: this._moduleMocker.isMockFunction,
+
+      mock,
+      resetAllMocks,
+      resetModuleRegistry: resetModules,
+      resetModules,
+
+      runAllImmediates: () => this._environment.fakeTimers.runAllImmediates(),
+      runAllTicks: () => this._environment.fakeTimers.runAllTicks(),
+      runAllTimers: () => this._environment.fakeTimers.runAllTimers(),
+      runOnlyPendingTimers: () =>
+      this._environment.fakeTimers.runOnlyPendingTimers(),
+      runTimersToTime: msToRun =>
+      this._environment.fakeTimers.runTimersToTime(msToRun),
+
+      setMock: (moduleName, mock) =>
+      setMockFactory(moduleName, () => mock),
+      spyOn,
+
+      unmock,
+
+      useFakeTimers,
+      useRealTimers };
+
+    return runtime;
+  }}
+
+
+Runtime.ScriptTransformer = ScriptTransformer;
+module.exports = Runtime;

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/build/shouldInstrument.js

@@ -0,0 +1,78 @@
+'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 path = require('path');var _require =
+require('jest-regex-util');const escapePathForRegex = _require.escapePathForRegex;
+const micromatch = require('micromatch');
+
+const MOCKS_PATTERN = new RegExp(
+escapePathForRegex(path.sep + '__mocks__' + path.sep));
+
+
+const shouldInstrument = (
+filename,
+options,
+config) =>
+{
+  if (!options.collectCoverage) {
+    return false;
+  }
+
+  if (config.testRegex && filename.match(config.testRegex)) {
+    return false;
+  }
+
+  if (
+  config.testMatch &&
+  config.testMatch.length &&
+  micromatch.any(filename, config.testMatch))
+  {
+    return false;
+  }
+
+  if (
+  // This configuration field contains an object in the form of:
+  // {'path/to/file.js': true}
+  options.collectCoverageOnlyFrom &&
+  !options.collectCoverageOnlyFrom[filename])
+  {
+    return false;
+  }
+
+  if (
+  // still cover if `only` is specified
+  !options.collectCoverageOnlyFrom &&
+  options.collectCoverageFrom &&
+  !micromatch(
+  [path.relative(config.rootDir, filename)],
+  options.collectCoverageFrom).
+  length)
+  {
+    return false;
+  }
+
+  if (
+  config.coveragePathIgnorePatterns &&
+  config.coveragePathIgnorePatterns.some(pattern => filename.match(pattern)))
+  {
+    return false;
+  }
+
+  if (MOCKS_PATTERN.test(filename)) {
+    return false;
+  }
+
+  return true;
+};
+
+module.exports = shouldInstrument;

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/node_modules/strip-bom/index.js

@@ -0,0 +1,14 @@
+'use strict';
+module.exports = x => {
+	if (typeof x !== 'string') {
+		throw new TypeError('Expected a string, got ' + typeof x);
+	}
+
+	// Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+	// conversion translates it to FEFF (UTF-16 BOM)
+	if (x.charCodeAt(0) === 0xFEFF) {
+		return x.slice(1);
+	}
+
+	return x;
+};

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/node_modules/strip-bom/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/node_modules/strip-bom/package.json

@@ -0,0 +1,75 @@
+{
+  "_args": [
+    [
+      "strip-bom@3.0.0",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "strip-bom@3.0.0",
+  "_id": "strip-bom@3.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=",
+  "_location": "/react-scripts/jest-runtime/strip-bom",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "strip-bom@3.0.0",
+    "name": "strip-bom",
+    "escapedName": "strip-bom",
+    "rawSpec": "3.0.0",
+    "saveSpec": null,
+    "fetchSpec": "3.0.0"
+  },
+  "_requiredBy": [
+    "/react-scripts/jest-runtime"
+  ],
+  "_resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+  "_spec": "3.0.0",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/sindresorhus/strip-bom/issues"
+  },
+  "description": "Strip UTF-8 byte order mark (BOM) from a string",
+  "devDependencies": {
+    "ava": "*",
+    "xo": "*"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/sindresorhus/strip-bom#readme",
+  "keywords": [
+    "strip",
+    "bom",
+    "byte",
+    "order",
+    "mark",
+    "unicode",
+    "utf8",
+    "utf-8",
+    "remove",
+    "delete",
+    "trim",
+    "text",
+    "string"
+  ],
+  "license": "MIT",
+  "name": "strip-bom",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sindresorhus/strip-bom.git"
+  },
+  "scripts": {
+    "test": "xo && ava"
+  },
+  "version": "3.0.0"
+}

torrent-project/node_modules/react-scripts/node_modules/jest-runtime/node_modules/strip-bom/readme.md

@@ -0,0 +1,36 @@
+# strip-bom [![Build Status](https://travis-ci.org/sindresorhus/strip-bom.svg?branch=master)](https://travis-ci.org/sindresorhus/strip-bom)
+
+> Strip UTF-8 [byte order mark](http://en.wikipedia.org/wiki/Byte_order_mark#UTF-8) (BOM) from a string
+
+From Wikipedia:
+
+> The Unicode Standard permits the BOM in UTF-8, but does not require nor recommend its use. Byte order has no meaning in UTF-8.
+
+
+## Install
+
+```
+$ npm install --save strip-bom
+```
+
+
+## Usage
+
+```js
+const stripBom = require('strip-bom');
+
+stripBom('\uFEFFunicorn');
+//=> 'unicorn'
+```
+
+
+## Related
+
+- [strip-bom-cli](https://github.com/sindresorhus/strip-bom-cli) - CLI for this module
+- [strip-bom-buf](https://github.com/sindresorhus/strip-bom-buf) - Buffer version of this module
+- [strip-bom-stream](https://github.com/sindresorhus/strip-bom-stream) - Stream version of this module
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

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

@@ -0,0 +1,66 @@
+{
+  "_args": [
+    [
+      "jest-runtime@20.0.4",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "jest-runtime@20.0.4",
+  "_id": "jest-runtime@20.0.4",
+  "_inBundle": false,
+  "_integrity": "sha1-osgCIZxCA/dU3xQE5JAYYWnRJNg=",
+  "_location": "/react-scripts/jest-runtime",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "jest-runtime@20.0.4",
+    "name": "jest-runtime",
+    "escapedName": "jest-runtime",
+    "rawSpec": "20.0.4",
+    "saveSpec": null,
+    "fetchSpec": "20.0.4"
+  },
+  "_requiredBy": [
+    "/react-scripts/jest/jest-cli"
+  ],
+  "_resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-20.0.4.tgz",
+  "_spec": "20.0.4",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "bin": {
+    "jest-runtime": "./bin/jest-runtime.js"
+  },
+  "bugs": {
+    "url": "https://github.com/facebook/jest/issues"
+  },
+  "dependencies": {
+    "babel-core": "^6.0.0",
+    "babel-jest": "^20.0.3",
+    "babel-plugin-istanbul": "^4.0.0",
+    "chalk": "^1.1.3",
+    "convert-source-map": "^1.4.0",
+    "graceful-fs": "^4.1.11",
+    "jest-config": "^20.0.4",
+    "jest-haste-map": "^20.0.4",
+    "jest-regex-util": "^20.0.3",
+    "jest-resolve": "^20.0.4",
+    "jest-util": "^20.0.3",
+    "json-stable-stringify": "^1.0.1",
+    "micromatch": "^2.3.11",
+    "strip-bom": "3.0.0",
+    "yargs": "^7.0.2"
+  },
+  "devDependencies": {
+    "jest-environment-jsdom": "^20.0.3",
+    "jest-environment-node": "^20.0.3"
+  },
+  "homepage": "https://github.com/facebook/jest#readme",
+  "license": "BSD-3-Clause",
+  "main": "build/index.js",
+  "name": "jest-runtime",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/jest.git"
+  },
+  "version": "20.0.4"
+}