Added logging, changed some directory structure

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/CONTRIBUTING.md

@@ -0,0 +1,52 @@
+# Contributing
+
+**`README.md` is a generated file. Do not edit it directly.** Edit the files inside `.README` instead.
+
+## Pre-Commit Hook
+
+When making a commit, the following Pre-Commit hooks run:
+
+* tests
+* lint
+* commit message validation (see "Commit Messages" below)
+
+## Commit Messages
+
+All commit messages must begin with one of the following prefixes:
+
+* `fix: `
+* `feat: `
+* `refactor: `
+* `docs: `
+* `chore: `
+
+The prefix is used to bump the correct segment of the version number automatically during deploy.
+
+## Tests
+
+Run them with `npm t`.
+
+## Lint
+
+Run with `npm run lint`.
+
+## Adding a Rule
+
+### Source & Tests
+
+1. Create a file in `tests/rules/assertions` named the `camelCase` version of your rule name with the following template:
+  * `export default { invalid: [], valid: [] }`
+2. Add your test file to `tests/index.js`
+3. Create a file in `src/rules` named the `camelCase` version  of your rule name
+4. Add your rule file to `src/index.js`
+
+### Adding Documentation
+
+1. Create new file in `./README/rules/[rule-name].md`.
+  * Use [./.README/rules/require-valid-file-annotation.md](./.README/rules/require-valid-file-annotation.md) as a template.
+  * Ensure that rule documentation document includes `<!-- assertions spaceAfterTypeColon -->` declaration.
+1. Update [./.README/README.md](/.README/README.md) to include the new rule.
+
+A CI service will build and publish the new documentation.
+
+Note: The section "The following patterns are considered problems:" and "The following patterns are not considered problems:" is **generated automatically** using the test cases.

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2015, Gajus Kuizinas (http://gajus.com/)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Gajus Kuizinas (http://gajus.com/) nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL ANUARY BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/bin/readmeAssertions.js

@@ -0,0 +1,88 @@
+/**
+ * This script is used to inline assertions into the README.md documents.
+ */
+
+import path from 'path';
+import fs from 'fs';
+import glob from 'glob';
+import _ from 'lodash';
+
+const formatCodeSnippet = (setup) => {
+  const paragraphs = [];
+
+  if (setup.options) {
+    paragraphs.push('// Options: ' + JSON.stringify(setup.options));
+  }
+
+  if (setup.settings) {
+    paragraphs.push('// Settings: ' + JSON.stringify(setup.settings));
+  }
+
+  paragraphs.push(setup.code);
+
+  if (setup.errors) {
+    setup.errors.forEach((message) => {
+      paragraphs.push('// Message: ' + message.message);
+    });
+  }
+
+  if (setup.rules) {
+    paragraphs.push('// Additional rules: ' + JSON.stringify(setup.rules));
+  }
+
+  return paragraphs.join('\n');
+};
+
+const getAssertions = () => {
+  const assertionFiles = glob.sync(path.resolve(__dirname, './../tests/rules/assertions/*.js'));
+
+  const assertionNames = _.map(assertionFiles, (filePath) => {
+    return path.basename(filePath, '.js');
+  });
+
+  const assertionCodes = _.map(assertionFiles, (filePath) => {
+    const codes = require(filePath); // eslint-disable-line global-require
+
+    return {
+      invalid: _.map(codes.invalid, formatCodeSnippet),
+      valid: _.map(codes.valid, formatCodeSnippet)
+    };
+  });
+
+  return _.zipObject(assertionNames, assertionCodes);
+};
+
+const updateDocuments = (assertions) => {
+  const readmeDocumentPath = path.join(__dirname, './../README.md');
+  let documentBody;
+
+  documentBody = fs.readFileSync(readmeDocumentPath, 'utf8');
+
+  documentBody = documentBody.replace(/<!-- assertions ([a-z]+?) -->/ig, (assertionsBlock) => {
+    let exampleBody;
+
+    const ruleName = assertionsBlock.match(/assertions ([a-z]+)/i)[1];
+
+    const ruleAssertions = assertions[ruleName];
+
+    if (!ruleAssertions) {
+      throw new Error('No assertions available for rule "' + ruleName + '".');
+    }
+
+    exampleBody = '';
+
+    if (ruleAssertions.invalid.length) {
+      exampleBody += 'The following patterns are considered problems:\n\n```js\n' + ruleAssertions.invalid.join('\n\n') + '\n```\n\n';
+    }
+
+    if (ruleAssertions.valid.length) {
+      exampleBody += 'The following patterns are not considered problems:\n\n```js\n' + ruleAssertions.valid.join('\n\n') + '\n```\n\n';
+    }
+
+    return exampleBody;
+  });
+
+  fs.writeFileSync(readmeDocumentPath, documentBody);
+};
+
+updateDocuments(getAssertions());

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/configs/recommended.json

@@ -0,0 +1,45 @@
+{
+  "parser": "babel-eslint",
+  "rules": {
+    "flowtype/boolean-style": [
+      2,
+      "boolean"
+    ],
+    "flowtype/define-flow-type": 1,
+    "flowtype/delimiter-dangle": 0,
+    "flowtype/generic-spacing": [
+      2,
+      "never"
+    ],
+    "flowtype/no-types-missing-file-annotation": 2,
+    "flowtype/no-weak-types": 0,
+    "flowtype/require-parameter-type": 0,
+    "flowtype/require-return-type": 0,
+    "flowtype/require-valid-file-annotation": 0,
+    "flowtype/semi": 0,
+    "flowtype/space-after-type-colon": [
+      2,
+      "always"
+    ],
+    "flowtype/space-before-generic-bracket": [
+      2,
+      "never"
+    ],
+    "flowtype/space-before-type-colon": [
+      2,
+      "never"
+    ],
+    "flowtype/type-id-match": 0,
+    "flowtype/union-intersection-spacing": [
+      2,
+      "always"
+    ],
+    "flowtype/use-flow-type": 1,
+    "flowtype/valid-syntax": 1
+  },
+  "settings": {
+    "flowtype": {
+      "onlyFilesWithFlowAnnotation": false
+    }
+  }
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/index.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _recommended = require('./configs/recommended.json');
+
+var _recommended2 = _interopRequireDefault(_recommended);
+
+var _booleanStyle = require('./rules/booleanStyle');
+
+var _booleanStyle2 = _interopRequireDefault(_booleanStyle);
+
+var _defineFlowType = require('./rules/defineFlowType');
+
+var _defineFlowType2 = _interopRequireDefault(_defineFlowType);
+
+var _delimiterDangle = require('./rules/delimiterDangle');
+
+var _delimiterDangle2 = _interopRequireDefault(_delimiterDangle);
+
+var _genericSpacing = require('./rules/genericSpacing');
+
+var _genericSpacing2 = _interopRequireDefault(_genericSpacing);
+
+var _noDupeKeys = require('./rules/noDupeKeys');
+
+var _noDupeKeys2 = _interopRequireDefault(_noDupeKeys);
+
+var _noMutableArray = require('./rules/noMutableArray');
+
+var _noMutableArray2 = _interopRequireDefault(_noMutableArray);
+
+var _noPrimitiveConstructorTypes = require('./rules/noPrimitiveConstructorTypes');
+
+var _noPrimitiveConstructorTypes2 = _interopRequireDefault(_noPrimitiveConstructorTypes);
+
+var _noTypesMissingFileAnnotation = require('./rules/noTypesMissingFileAnnotation');
+
+var _noTypesMissingFileAnnotation2 = _interopRequireDefault(_noTypesMissingFileAnnotation);
+
+var _noUnusedExpressions = require('./rules/noUnusedExpressions');
+
+var _noUnusedExpressions2 = _interopRequireDefault(_noUnusedExpressions);
+
+var _noWeakTypes = require('./rules/noWeakTypes');
+
+var _noWeakTypes2 = _interopRequireDefault(_noWeakTypes);
+
+var _objectTypeDelimiter = require('./rules/objectTypeDelimiter');
+
+var _objectTypeDelimiter2 = _interopRequireDefault(_objectTypeDelimiter);
+
+var _requireParameterType = require('./rules/requireParameterType');
+
+var _requireParameterType2 = _interopRequireDefault(_requireParameterType);
+
+var _requireReturnType = require('./rules/requireReturnType');
+
+var _requireReturnType2 = _interopRequireDefault(_requireReturnType);
+
+var _requireValidFileAnnotation = require('./rules/requireValidFileAnnotation');
+
+var _requireValidFileAnnotation2 = _interopRequireDefault(_requireValidFileAnnotation);
+
+var _requireVariableType = require('./rules/requireVariableType');
+
+var _requireVariableType2 = _interopRequireDefault(_requireVariableType);
+
+var _semi = require('./rules/semi');
+
+var _semi2 = _interopRequireDefault(_semi);
+
+var _sortKeys = require('./rules/sortKeys');
+
+var _sortKeys2 = _interopRequireDefault(_sortKeys);
+
+var _spaceAfterTypeColon = require('./rules/spaceAfterTypeColon');
+
+var _spaceAfterTypeColon2 = _interopRequireDefault(_spaceAfterTypeColon);
+
+var _spaceBeforeGenericBracket = require('./rules/spaceBeforeGenericBracket');
+
+var _spaceBeforeGenericBracket2 = _interopRequireDefault(_spaceBeforeGenericBracket);
+
+var _spaceBeforeTypeColon = require('./rules/spaceBeforeTypeColon');
+
+var _spaceBeforeTypeColon2 = _interopRequireDefault(_spaceBeforeTypeColon);
+
+var _typeIdMatch = require('./rules/typeIdMatch');
+
+var _typeIdMatch2 = _interopRequireDefault(_typeIdMatch);
+
+var _unionIntersectionSpacing = require('./rules/unionIntersectionSpacing');
+
+var _unionIntersectionSpacing2 = _interopRequireDefault(_unionIntersectionSpacing);
+
+var _useFlowType = require('./rules/useFlowType');
+
+var _useFlowType2 = _interopRequireDefault(_useFlowType);
+
+var _validSyntax = require('./rules/validSyntax');
+
+var _validSyntax2 = _interopRequireDefault(_validSyntax);
+
+var _utilities = require('./utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var rules = {
+  'boolean-style': _booleanStyle2.default,
+  'define-flow-type': _defineFlowType2.default,
+  'delimiter-dangle': _delimiterDangle2.default,
+  'generic-spacing': _genericSpacing2.default,
+  'no-dupe-keys': _noDupeKeys2.default,
+  'no-mutable-array': _noMutableArray2.default,
+  'no-primitive-constructor-types': _noPrimitiveConstructorTypes2.default,
+  'no-types-missing-file-annotation': _noTypesMissingFileAnnotation2.default,
+  'no-unused-expressions': _noUnusedExpressions2.default,
+  'no-weak-types': _noWeakTypes2.default,
+  'object-type-delimiter': _objectTypeDelimiter2.default,
+  'require-parameter-type': _requireParameterType2.default,
+  'require-return-type': _requireReturnType2.default,
+  'require-valid-file-annotation': _requireValidFileAnnotation2.default,
+  'require-variable-type': _requireVariableType2.default,
+  semi: _semi2.default,
+  'sort-keys': _sortKeys2.default,
+  'space-after-type-colon': _spaceAfterTypeColon2.default,
+  'space-before-generic-bracket': _spaceBeforeGenericBracket2.default,
+  'space-before-type-colon': _spaceBeforeTypeColon2.default,
+  'type-id-match': _typeIdMatch2.default,
+  'union-intersection-spacing': _unionIntersectionSpacing2.default,
+  'use-flow-type': _useFlowType2.default,
+  'valid-syntax': _validSyntax2.default
+};
+
+exports.default = {
+  configs: {
+    recommended: _recommended2.default
+  },
+  rules: _lodash2.default.mapValues(rules, function (rule, key) {
+    if (key === 'no-types-missing-file-annotation') {
+      return rule;
+    }
+
+    return _extends({}, rule, {
+      create: _lodash2.default.partial(_utilities.checkFlowFileAnnotation, rule.create)
+    });
+  }),
+  rulesConfig: {
+    'boolean-style': 0,
+    'define-flow-type': 0,
+    'delimiter-dangle': 0,
+    'generic-spacing': 0,
+    'no-dupe-keys': 0,
+    'no-mutable-array': 0,
+    'no-weak-types': 0,
+    'object-type-delimiter': 0,
+    'require-parameter-type': 0,
+    'require-return-type': 0,
+    'require-variable-type': 0,
+    semi: 0,
+    'sort-keys': 0,
+    'space-after-type-colon': 0,
+    'space-before-generic-bracket': 0,
+    'space-before-type-colon': 0,
+    'type-id-match': 0,
+    'union-intersection-spacing': 0,
+    'use-flow-type': 0,
+    'valid-syntax': 0
+  }
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/booleanStyle.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [{
+  enum: ['bool', 'boolean'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var longForm = (context.options[0] || 'boolean') === 'boolean';
+
+  return {
+    BooleanTypeAnnotation(node) {
+      var diff = node.end - node.start;
+
+      if (longForm && diff === 4) {
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node, 'boolean');
+          },
+          message: 'Use "boolean", not "bool"',
+          node
+        });
+      }
+
+      if (!longForm && diff !== 4) {
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node, 'bool');
+          },
+          message: 'Use "bool", not "boolean"',
+          node
+        });
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/defineFlowType.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [];
+
+var create = function create(context) {
+  var globalScope = void 0;
+
+  // do nearly the same thing that eslint does for config globals
+  // https://github.com/eslint/eslint/blob/v2.0.0/lib/eslint.js#L118-L194
+  var makeDefined = function makeDefined(ident) {
+    var ii = void 0;
+
+    // start from the right since we're going to remove items from the array
+    for (ii = globalScope.through.length - 1; ii >= 0; ii--) {
+      var ref = globalScope.through[ii];
+
+      if (ref.identifier.name === ident.name) {
+        // use "__defineGeneric" since we don't have a reference to "escope.Variable"
+        globalScope.__defineGeneric( // eslint-disable-line no-underscore-dangle
+        ident.name, globalScope.set, globalScope.variables);
+        var variable = globalScope.set.get(ident.name);
+
+        variable.writeable = false;
+        // "through" contains all references whose definition cannot be found
+        // so we need to update references and remove the ones that were added
+        globalScope.through.splice(ii, 1);
+        ref.resolved = variable;
+        variable.references.push(ref);
+      }
+    }
+  };
+
+  return {
+    ClassImplements(node) {
+      makeDefined(node.id);
+    },
+    GenericTypeAnnotation(node) {
+      if (node.id.type === 'Identifier') {
+        makeDefined(node.id);
+      } else if (node.id.type === 'QualifiedTypeIdentifier') {
+        var qid = void 0;
+
+        qid = node.id;
+        do {
+          qid = qid.qualification;
+        } while (qid.qualification);
+
+        makeDefined(qid);
+      }
+    },
+    InterfaceDeclaration(node) {
+      makeDefined(node.id);
+    },
+    Program() {
+      globalScope = context.getScope();
+    },
+    TypeParameterDeclaration(node) {
+      node.params.forEach(function (param) {
+        makeDefined(param);
+      });
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/delimiterDangle.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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"); } }; }();
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  enum: ['always', 'always-multiline', 'only-multiline', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var option = context.options[0] || 'never';
+  var sourceCode = context.getSourceCode();
+
+  var reporter = function reporter(node, message, fix) {
+    return function () {
+      context.report({
+        fix,
+        message,
+        node
+      });
+    };
+  };
+
+  var makeReporters = function makeReporters(node, tokenToFix) {
+    return {
+      dangle: reporter(node, 'Unexpected trailing delimiter', function (fixer) {
+        return fixer.replaceText(tokenToFix, '');
+      }),
+      noDangle: reporter(node, 'Missing trailing delimiter', function (fixer) {
+        return fixer.insertTextAfter(tokenToFix, ',');
+      })
+    };
+  };
+
+  var evaluate = function evaluate(node, lastChildNode) {
+    if (!lastChildNode) {
+      return;
+    }
+
+    var _sourceCode$getLastTo = sourceCode.getLastTokens(node, 2),
+        _sourceCode$getLastTo2 = _slicedToArray(_sourceCode$getLastTo, 2),
+        penultimateToken = _sourceCode$getLastTo2[0],
+        lastToken = _sourceCode$getLastTo2[1];
+
+    var isDangling = [';', ','].indexOf(penultimateToken.value) > -1;
+    var isMultiLine = penultimateToken.loc.start.line !== lastToken.loc.start.line;
+
+    var report = makeReporters(lastChildNode, penultimateToken);
+
+    if (option === 'always' && !isDangling) {
+      report.noDangle();
+
+      return;
+    }
+
+    if (option === 'never' && isDangling) {
+      report.dangle();
+
+      return;
+    }
+
+    if (option === 'always-multiline' && !isDangling && isMultiLine) {
+      report.noDangle();
+
+      return;
+    }
+
+    if (option === 'always-multiline' && isDangling && !isMultiLine) {
+      report.dangle();
+
+      return;
+    }
+
+    if (option === 'only-multiline' && isDangling && !isMultiLine) {
+      report.dangle();
+
+      return;
+    }
+  };
+
+  // required for reporting the correct position
+  var getLast = function getLast(property, indexer) {
+    if (!property) {
+      return indexer;
+    }
+
+    if (!indexer) {
+      return property;
+    }
+
+    if (property.loc.end.line > indexer.loc.end.line) {
+      return property;
+    }
+
+    if (indexer.loc.end.line > property.loc.end.line) {
+      return indexer;
+    }
+
+    if (property.loc.end.column > indexer.loc.end.column) {
+      return property;
+    }
+
+    return indexer;
+  };
+
+  return {
+    ObjectTypeAnnotation(node) {
+      evaluate(node, getLast(_lodash2.default.last(node.properties), _lodash2.default.last(node.indexers)));
+    },
+
+    TupleTypeAnnotation(node) {
+      evaluate(node, _lodash2.default.last(node.types));
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/genericSpacing.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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"); } }; }();
+
+var _utilities = require('./../utilities');
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var sourceCode = context.getSourceCode();
+
+  var never = (context.options[0] || 'never') === 'never';
+
+  return {
+    GenericTypeAnnotation(node) {
+      var types = node.typeParameters;
+
+      // Promise<foo>
+      // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
+      //         ^^^  GenericTypeAnnotation (without typeParameters)
+      if (!types) {
+        return;
+      }
+
+      var _sourceCode$getFirstT = sourceCode.getFirstTokens(types, 2),
+          _sourceCode$getFirstT2 = _slicedToArray(_sourceCode$getFirstT, 2),
+          opener = _sourceCode$getFirstT2[0],
+          firstInnerToken = _sourceCode$getFirstT2[1];
+
+      var _sourceCode$getLastTo = sourceCode.getLastTokens(types, 2),
+          _sourceCode$getLastTo2 = _slicedToArray(_sourceCode$getLastTo, 2),
+          lastInnerToken = _sourceCode$getLastTo2[0],
+          closer = _sourceCode$getLastTo2[1];
+
+      var spacesBefore = firstInnerToken.start - opener.end;
+      var spacesAfter = closer.start - lastInnerToken.end;
+
+      if (never) {
+        if (spacesBefore) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore),
+            message: 'There must be no space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
+
+        if (spacesAfter) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter),
+            message: 'There must be no space at end of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
+      } else {
+        if (spacesBefore > 1) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore - 1),
+            message: 'There must be one space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        } else if (spacesBefore === 0) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.addSpaceAfter(opener),
+            message: 'There must be a space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
+
+        if (spacesAfter > 1) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter - 1),
+            message: 'There must be one space at end of "{{name}}" generic type annotation',
+            node: types
+          });
+        } else if (spacesAfter === 0) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.addSpaceAfter(lastInnerToken),
+            message: 'There must be a space at end of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noDupeKeys.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash/');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [];
+
+var create = function create(context) {
+  var report = function report(node) {
+    context.report({
+      loc: node.loc,
+      message: 'Duplicate property.',
+      node
+    });
+  };
+
+  var analizeElement = function analizeElement(element) {
+    var type = element.type;
+
+    var value = void 0;
+
+    switch (type) {
+      case 'GenericTypeAnnotation':
+        value = element.id.name;
+        break;
+      case 'ObjectTypeAnnotation':
+        // eslint-disable-next-line no-use-before-define
+        value = builObjectStructure(element.properties);
+        break;
+      case 'TupleTypeAnnotation':
+        // eslint-disable-next-line no-use-before-define
+        value = buildArrayStructure(element.types);
+        break;
+      default:
+        value = element.value;
+        break;
+    }
+
+    return {
+      type,
+      value
+    };
+  };
+
+  var buildArrayStructure = function buildArrayStructure(elements) {
+    return _lodash2.default.map(elements, function (element) {
+      return analizeElement(element);
+    });
+  };
+
+  var builObjectStructure = function builObjectStructure(properties) {
+    return _lodash2.default.map(properties, function (property) {
+      var element = analizeElement(property.value);
+
+      return Object.assign(element, {
+        name: (0, _utilities.getParameterName)(property, context)
+      });
+    });
+  };
+
+  var checkForDuplicates = function checkForDuplicates(node) {
+    var haystack = [];
+
+    _lodash2.default.forEach(node.properties, function (identifierNode) {
+      var needle = { name: (0, _utilities.getParameterName)(identifierNode, context) };
+
+      if (identifierNode.value.type === 'FunctionTypeAnnotation') {
+        needle.args = _lodash2.default.map(identifierNode.value.params, function (param) {
+          return analizeElement(param.typeAnnotation);
+        });
+      }
+
+      var match = _lodash2.default.some(haystack, function (existingNeedle) {
+        return _lodash2.default.isEqual(existingNeedle, needle);
+      });
+
+      if (match) {
+        report(identifierNode);
+      } else {
+        haystack.push(needle);
+      }
+    });
+  };
+
+  return {
+    ObjectTypeAnnotation: checkForDuplicates
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noMutableArray.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [];
+
+var create = function create(context) {
+  return {
+    ArrayTypeAnnotation(node) {
+      context.report({
+        fix(fixer) {
+          var rawElementType = context.getSourceCode().getText(node.elementType);
+
+          return fixer.replaceText(node, '$ReadOnlyArray<' + rawElementType + '>');
+        },
+        message: 'Use "$ReadOnlyArray" instead of array shorthand notation',
+        node
+      });
+    },
+    GenericTypeAnnotation(node) {
+      if (node.id.name === 'Array') {
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node.id, '$ReadOnlyArray');
+          },
+          message: 'Use "$ReadOnlyArray" instead of "Array"',
+          node
+        });
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noPrimitiveConstructorTypes.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [];
+
+var create = function create(context) {
+  return {
+    GenericTypeAnnotation: function GenericTypeAnnotation(node) {
+      var name = _lodash2.default.get(node, 'id.name');
+
+      if (RegExp(/^(Boolean|Number|String)$/).test(name)) {
+        context.report({
+          data: {
+            name
+          },
+          loc: node.loc,
+          message: 'Unexpected use of {{name}} constructor type.',
+          node
+        });
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noTypesMissingFileAnnotation.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../utilities');
+
+/**
+ * Disallows the use for flow types without a valid file annotation.
+ * Only checks files without a valid flow annotation.
+ */
+
+var schema = [];
+
+var create = function create(context) {
+  // Skip flow files
+  if ((0, _utilities.isFlowFile)(context, false)) {
+    return {};
+  }
+
+  var reporter = function reporter(node, type) {
+    context.report({
+      data: { type },
+      message: 'Type {{type}} require valid Flow declaration.',
+      node
+    });
+  };
+
+  return {
+    ExportNamedDeclaration(node) {
+      if (node.exportKind === 'type') {
+        reporter(node, 'exports');
+      }
+    },
+    ImportDeclaration(node) {
+      if (node.importKind === 'type') {
+        reporter(node, 'imports');
+      }
+      if (node.importKind === 'value' && node.specifiers.some(function (specifier) {
+        return specifier.importKind === 'type';
+      })) {
+        reporter(node, 'imports');
+      }
+    },
+    TypeAlias(node) {
+      reporter(node, 'aliases');
+    },
+    TypeAnnotation(node) {
+      reporter(node, 'annotations');
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noUnusedExpressions.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _noUnusedExpressions = require('eslint/lib/rules/no-unused-expressions');
+
+var _noUnusedExpressions2 = _interopRequireDefault(_noUnusedExpressions);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var meta = _noUnusedExpressions2.default.meta; // A wrapper around ESLint's core rule no-unused-expressions, additionally ignores type cast
+// expressions.
+
+var create = function create(context) {
+  var coreChecks = _noUnusedExpressions2.default.create(context);
+
+  return {
+    ExpressionStatement(node) {
+      if (node.expression.type !== 'TypeCastExpression') {
+        coreChecks.ExpressionStatement(node);
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  meta
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/noWeakTypes.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  additionalProperties: false,
+  properties: {
+    Function: {
+      type: 'boolean'
+    },
+    Object: {
+      type: 'boolean'
+    },
+    any: {
+      type: 'boolean'
+    }
+  },
+  type: 'object'
+}];
+
+var reportWeakType = function reportWeakType(context, weakType) {
+  return function (node) {
+    context.report({
+      data: { weakType },
+      message: 'Unexpected use of weak type "{{weakType}}"',
+      node
+    });
+  };
+};
+
+var genericTypeEvaluator = function genericTypeEvaluator(context, _ref) {
+  var checkFunction = _ref.checkFunction,
+      checkObject = _ref.checkObject;
+
+  return function (node) {
+    var name = _lodash2.default.get(node, 'id.name');
+
+    if (checkFunction && name === 'Function' || checkObject && name === 'Object') {
+      reportWeakType(context, name)(node);
+    }
+  };
+};
+
+var create = function create(context) {
+  var checkAny = _lodash2.default.get(context, 'options[0].any', true) === true;
+  var checkFunction = _lodash2.default.get(context, 'options[0].Function', true) === true;
+  var checkObject = _lodash2.default.get(context, 'options[0].Object', true) === true;
+
+  var checks = {};
+
+  if (checkAny) {
+    checks.AnyTypeAnnotation = reportWeakType(context, 'any');
+  }
+
+  if (checkFunction || checkObject) {
+    checks.GenericTypeAnnotation = genericTypeEvaluator(context, {
+      checkFunction,
+      checkObject
+    });
+  }
+
+  return checks;
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/objectTypeDelimiter.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// ported from babel/flow-object-type; original author: Nat Mote
+// https://github.com/babel/eslint-plugin-babel/blob/c0a49d25a97feb12c1d07073a0b37317359a5fe5/rules/flow-object-type.js
+
+var SEMICOLON = {
+  char: ';',
+  name: 'semicolon'
+};
+
+var COMMA = {
+  char: ',',
+  name: 'comma'
+};
+
+var create = function create(context) {
+  var GOOD = void 0;
+  var BAD = void 0;
+
+  if (!context.options[0] || context.options[0] === COMMA.name) {
+    GOOD = COMMA;
+    BAD = SEMICOLON;
+  } else {
+    GOOD = SEMICOLON;
+    BAD = COMMA;
+  }
+
+  var requireProperPunctuation = function requireProperPunctuation(node) {
+    var tokens = context.getSourceCode().getTokens(node);
+    var lastToken = tokens[tokens.length - 1];
+
+    if (lastToken.type === 'Punctuator') {
+      if (lastToken.value === BAD.char) {
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(lastToken, GOOD.char);
+          },
+          message: 'Prefer ' + GOOD.name + 's to ' + BAD.name + 's in object and class types',
+          node: lastToken
+        });
+      }
+    }
+  };
+
+  return {
+    ObjectTypeCallProperty: requireProperPunctuation,
+    ObjectTypeIndexer: requireProperPunctuation,
+    ObjectTypeProperty: requireProperPunctuation
+  };
+};
+
+var schema = [{
+  enum: ['semicolon', 'comma'],
+  type: 'string'
+}];
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/requireParameterType.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  additionalProperties: false,
+  properties: {
+    excludeArrowFunctions: {
+      enum: [false, true, 'expressionsOnly']
+    },
+    excludeParameterMatch: {
+      type: 'string'
+    }
+  },
+  type: 'object'
+}];
+
+var create = (0, _utilities.iterateFunctionNodes)(function (context) {
+  var skipArrows = _lodash2.default.get(context, 'options[0].excludeArrowFunctions');
+  var excludeParameterMatch = new RegExp(_lodash2.default.get(context, 'options[0].excludeParameterMatch', 'a^'));
+
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, function (identifierNode) {
+      var parameterName = (0, _utilities.getParameterName)(identifierNode, context);
+
+      if (excludeParameterMatch.test(parameterName)) {
+        return;
+      }
+
+      var typeAnnotation = _lodash2.default.get(identifierNode, 'typeAnnotation') || _lodash2.default.get(identifierNode, 'left.typeAnnotation');
+
+      var isArrow = functionNode.type === 'ArrowFunctionExpression';
+      var isArrowFunctionExpression = functionNode.expression;
+
+      if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
+        return;
+      }
+
+      if (!typeAnnotation) {
+        context.report({
+          data: {
+            name: (0, _utilities.quoteName)(parameterName)
+          },
+          message: 'Missing {{name}}parameter type annotation.',
+          node: identifierNode
+        });
+      }
+    });
+  };
+});
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/requireReturnType.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  enum: ['always'],
+  type: 'string'
+}, {
+  additionalProperties: false,
+  properties: {
+    annotateUndefined: {
+      enum: ['always', 'never'],
+      type: 'string'
+    },
+    excludeArrowFunctions: {
+      enum: [false, true, 'expressionsOnly']
+    },
+    excludeMatching: {
+      items: {
+        type: 'string'
+      },
+      type: 'array'
+    },
+    includeOnlyMatching: {
+      items: {
+        type: 'string'
+      },
+      type: 'array'
+    }
+  },
+  type: 'object'
+}];
+
+var create = function create(context) {
+  var annotateReturn = (_lodash2.default.get(context, 'options[0]') || 'always') === 'always';
+  var annotateUndefined = (_lodash2.default.get(context, 'options[1].annotateUndefined') || 'never') === 'always';
+  var skipArrows = _lodash2.default.get(context, 'options[1].excludeArrowFunctions') || false;
+
+  var makeRegExp = function makeRegExp(str) {
+    return new RegExp(str);
+  };
+
+  var excludeMatching = _lodash2.default.get(context, 'options[1].excludeMatching', []).map(makeRegExp);
+  var includeOnlyMatching = _lodash2.default.get(context, 'options[1].includeOnlyMatching', []).map(makeRegExp);
+
+  var targetNodes = [];
+
+  var registerFunction = function registerFunction(functionNode) {
+    targetNodes.push({
+      functionNode
+    });
+  };
+
+  var isUndefinedReturnType = function isUndefinedReturnType(returnNode) {
+    return returnNode.argument === null || returnNode.argument.name === 'undefined' || returnNode.argument.operator === 'void';
+  };
+
+  var getIsReturnTypeAnnotationUndefined = function getIsReturnTypeAnnotationUndefined(targetNode) {
+    var isReturnTypeAnnotationLiteralUndefined = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.id.name') === 'undefined' && _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'GenericTypeAnnotation';
+    var isReturnTypeAnnotationVoid = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'VoidTypeAnnotation';
+
+    return isReturnTypeAnnotationLiteralUndefined || isReturnTypeAnnotationVoid;
+  };
+
+  var shouldFilterNode = function shouldFilterNode(functionNode) {
+    var isArrow = functionNode.type === 'ArrowFunctionExpression';
+    var isMethod = functionNode.parent && functionNode.parent.type === 'MethodDefinition';
+    var selector = void 0;
+
+    if (isMethod) {
+      selector = 'parent.key.name';
+    } else if (isArrow) {
+      selector = 'parent.id.name';
+    } else {
+      selector = 'id.name';
+    }
+    var identifierName = _lodash2.default.get(functionNode, selector);
+
+    var checkRegExp = function checkRegExp(regex) {
+      return regex.test(identifierName);
+    };
+
+    if (excludeMatching.length && _lodash2.default.some(excludeMatching, checkRegExp)) {
+      return true;
+    }
+
+    if (includeOnlyMatching.length && !_lodash2.default.some(includeOnlyMatching, checkRegExp)) {
+      return true;
+    }
+
+    return false;
+  };
+
+  var evaluateFunction = function evaluateFunction(functionNode) {
+    var targetNode = targetNodes.pop();
+
+    if (functionNode !== targetNode.functionNode) {
+      throw new Error('Mismatch.');
+    }
+
+    var isArrow = functionNode.type === 'ArrowFunctionExpression';
+    var isArrowFunctionExpression = functionNode.expression;
+    var hasImplicitReturnType = functionNode.async || functionNode.generator;
+    var isFunctionReturnUndefined = !isArrowFunctionExpression && !hasImplicitReturnType && (!targetNode.returnStatementNode || isUndefinedReturnType(targetNode.returnStatementNode));
+    var isReturnTypeAnnotationUndefined = getIsReturnTypeAnnotationUndefined(targetNode);
+
+    if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
+      return;
+    }
+    if (shouldFilterNode(functionNode)) {
+      return;
+    }
+    if (isFunctionReturnUndefined && isReturnTypeAnnotationUndefined && !annotateUndefined) {
+      context.report(functionNode, 'Must not annotate undefined return type.');
+    } else if (isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined && annotateUndefined) {
+      context.report(functionNode, 'Must annotate undefined return type.');
+    } else if (!isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined && annotateReturn && !functionNode.returnType) {
+      context.report(functionNode, 'Missing return type annotation.');
+    }
+  };
+
+  var evaluateNoise = function evaluateNoise() {
+    targetNodes.pop();
+  };
+
+  return {
+    ArrowFunctionExpression: registerFunction,
+    'ArrowFunctionExpression:exit': evaluateFunction,
+    ClassDeclaration: registerFunction,
+    'ClassDeclaration:exit': evaluateNoise,
+    ClassExpression: registerFunction,
+    'ClassExpression:exit': evaluateNoise,
+    FunctionDeclaration: registerFunction,
+    'FunctionDeclaration:exit': evaluateFunction,
+    FunctionExpression: registerFunction,
+    'FunctionExpression:exit': evaluateFunction,
+    ReturnStatement: function ReturnStatement(node) {
+      if (targetNodes.length) {
+        targetNodes[targetNodes.length - 1].returnStatementNode = node;
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/requireValidFileAnnotation.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var defaults = {
+  annotationStyle: 'none'
+};
+
+var looksLikeFlowFileAnnotation = function looksLikeFlowFileAnnotation(comment) {
+  return (/@(?:no)?flo/i.test(comment)
+  );
+};
+
+var isValidAnnotationStyle = function isValidAnnotationStyle(node, style) {
+  if (style === 'none') {
+    return true;
+  }
+
+  return style === node.type.toLowerCase();
+};
+
+var checkAnnotationSpelling = function checkAnnotationSpelling(comment) {
+  return (/@[a-z]+\b/.test(comment) && (0, _utilities.fuzzyStringMatch)(comment.replace(/no/i, ''), '@flow', 0.20)
+  );
+};
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}, {
+  additionalProperties: false,
+  properties: {
+    annotationStyle: {
+      enum: ['none', 'line', 'block'],
+      type: 'string'
+    }
+  },
+  type: 'object'
+}];
+
+var create = function create(context) {
+  var always = context.options[0] === 'always';
+  var style = _lodash2.default.get(context, 'options[1].annotationStyle', defaults.annotationStyle);
+
+  return {
+    Program(node) {
+      var firstToken = node.tokens[0];
+
+      var potentialFlowFileAnnotation = _lodash2.default.find(context.getAllComments(), function (comment) {
+        return looksLikeFlowFileAnnotation(comment.value);
+      });
+
+      if (potentialFlowFileAnnotation) {
+        if (firstToken && firstToken.start < potentialFlowFileAnnotation.start) {
+          context.report(potentialFlowFileAnnotation, 'Flow file annotation not at the top of the file.');
+        }
+
+        if ((0, _utilities.isFlowFileAnnotation)(potentialFlowFileAnnotation.value.trim())) {
+          if (!isValidAnnotationStyle(potentialFlowFileAnnotation, style)) {
+            var str = style === 'line' ? '`// ' + potentialFlowFileAnnotation.value.trim() + '`' : '`/* ' + potentialFlowFileAnnotation.value.trim() + ' */`';
+
+            context.report(potentialFlowFileAnnotation, 'Flow file annotation style must be ' + str);
+          }
+        } else if (checkAnnotationSpelling(potentialFlowFileAnnotation.value.trim())) {
+          context.report(potentialFlowFileAnnotation, 'Misspelled or malformed Flow file annotation.');
+        } else {
+          context.report(potentialFlowFileAnnotation, 'Malformed Flow file annotation.');
+        }
+      } else if (always) {
+        context.report(node, 'Flow file annotation is missing.');
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/requireVariableType.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  additionalProperties: false,
+  properties: {
+    excludeVariableMatch: {
+      type: 'string'
+    },
+    excludeVariableTypes: {
+      additionalProperties: false,
+      properties: {
+        const: {
+          type: 'boolean'
+        },
+        let: {
+          type: 'boolean'
+        },
+        var: {
+          type: 'boolean'
+        }
+      },
+      type: 'object'
+    }
+  },
+  type: 'object'
+}];
+
+var create = function create(context) {
+  var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
+
+  if (!checkThisFile) {
+    return function () {};
+  }
+
+  var excludeVariableMatch = new RegExp(_lodash2.default.get(context, 'options[0].excludeVariableMatch', 'a^'));
+  var excludeVariableTypes = _lodash2.default.get(context, 'options[0].excludeVariableTypes', {});
+
+  return {
+    VariableDeclaration: function VariableDeclaration(variableDeclaration) {
+      var variableType = _lodash2.default.get(variableDeclaration, 'kind');
+
+      if (_lodash2.default.get(excludeVariableTypes, variableType)) {
+        return;
+      }
+
+      _lodash2.default.forEach(variableDeclaration.declarations, function (variableDeclarator) {
+        var identifierNode = _lodash2.default.get(variableDeclarator, 'id');
+        var identifierName = _lodash2.default.get(identifierNode, 'name');
+
+        if (excludeVariableMatch.test(identifierName)) {
+          return;
+        }
+
+        var typeAnnotation = _lodash2.default.get(identifierNode, 'typeAnnotation');
+
+        if (!typeAnnotation) {
+          context.report({
+            data: {
+              name: (0, _utilities.quoteName)(identifierName)
+            },
+            message: 'Missing {{name}}variable type annotation.',
+            node: identifierNode
+          });
+        }
+      });
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/semi.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var never = (context.options[0] || 'always') === 'never';
+  var sourceCode = context.getSourceCode();
+
+  var report = function report(node, missing) {
+    var lastToken = sourceCode.getLastToken(node);
+    var fix = void 0,
+        message = void 0;
+    var loc = lastToken.loc;
+
+
+    if (missing) {
+      message = 'Missing semicolon.';
+      loc = loc.end;
+      fix = function fix(fixer) {
+        return fixer.insertTextAfter(lastToken, ';');
+      };
+    } else {
+      message = 'Extra semicolon.';
+      loc = loc.start;
+      fix = function fix(fixer) {
+        return fixer.remove(lastToken);
+      };
+    }
+
+    context.report({
+      fix,
+      loc,
+      message,
+      node
+    });
+  };
+
+  var isSemicolon = function isSemicolon(token) {
+    return token.type === 'Punctuator' && token.value === ';';
+  };
+
+  var checkForSemicolon = function checkForSemicolon(node) {
+    var lastToken = sourceCode.getLastToken(node);
+    var isLastTokenSemicolon = isSemicolon(lastToken);
+
+    if (never && isLastTokenSemicolon) {
+      report(node, false);
+    }
+
+    if (!never && !isLastTokenSemicolon) {
+      report(node, true);
+    }
+  };
+
+  return {
+    TypeAlias: checkForSemicolon
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/sortKeys.js

@@ -0,0 +1,181 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var defaults = {
+  caseSensitive: true,
+  natural: false
+};
+
+var schema = [{
+  enum: ['asc', 'desc'],
+  type: 'string'
+}, {
+  additionalProperties: false,
+  properties: {
+    caseSensitive: {
+      type: 'boolean'
+    },
+    natural: {
+      type: 'boolean'
+    }
+  },
+  type: 'object'
+}];
+
+/**
+ * Functions to compare the order of two strings
+ *
+ * Based on a similar function from eslint's sort-keys rule.
+ * https://github.com/eslint/eslint/blob/master/lib/rules/sort-keys.js
+ *
+ * @private
+ */
+var isValidOrders = {
+  asc(str1, str2) {
+    return str1 <= str2;
+  },
+  ascI(str1, str2) {
+    return str1.toLowerCase() <= str2.toLowerCase();
+  },
+  ascIN(str1, str2) {
+    return isValidOrders.naturalCompare(str1.toLowerCase(), str2.toLowerCase()) <= 0;
+  },
+  ascN(str1, str2) {
+    return isValidOrders.naturalCompare(str1, str2) <= 0;
+  },
+  desc(str1, str2) {
+    return isValidOrders.asc(str2, str1);
+  },
+  descI(str1, str2) {
+    return isValidOrders.ascI(str2, str1);
+  },
+  descIN(str1, str2) {
+    return isValidOrders.ascIN(str2, str1);
+  },
+  descN(str1, str2) {
+    return isValidOrders.ascN(str2, str1);
+  },
+  naturalCompare(str1, str2) {
+    return str1.localeCompare(str2, 'en-US', { numeric: true });
+  }
+};
+
+var variances = {
+  minus: '-',
+  plus: '+'
+};
+
+var generateOrderedList = function generateOrderedList(context, sort, properties) {
+  return properties.map(function (property) {
+    var name = (0, _utilities.getParameterName)(property, context);
+    var value = void 0;
+
+    if (property.value.type === 'ObjectTypeAnnotation') {
+      value = generateFix(property.value, context, sort); // eslint-disable-line no-use-before-define
+    } else {
+      value = context.getSourceCode().getText(property.value);
+    }
+
+    return [(variances[property.variance] || '') + name + (property.optional ? '?' : ''), value];
+  }).sort(function (first, second) {
+    return sort(first[0], second[0]) ? -1 : 1;
+  }).map(function (item) {
+    return item[0] + ': ' + item[1];
+  });
+};
+
+var generateFix = function generateFix(node, context, sort) {
+  // this could be done much more cleanly in ESLint >=4
+  // as we can apply multiple fixes. That also means we can
+  // maintain code style in a much nicer way
+  var nodeText = void 0;
+  var newTypes = generateOrderedList(context, sort, node.properties);
+  var source = context.getSourceCode(node);
+
+  var originalSubstring = source.getText(node);
+
+  nodeText = originalSubstring;
+
+  node.properties.forEach(function (property, index) {
+    var subString = source.getText(property);
+    var addComma = subString[subString.length - 1] === ',';
+
+    nodeText = nodeText.replace(subString, '$' + index + (addComma ? ',' : ''));
+  });
+
+  newTypes.forEach(function (item, index) {
+    nodeText = nodeText.replace('$' + index, item);
+  });
+
+  return nodeText;
+};
+
+var create = function create(context) {
+  var order = _lodash2.default.get(context, ['options', 0], 'asc');
+
+  var _$get = _lodash2.default.get(context, ['options', 1], defaults),
+      natural = _$get.natural,
+      caseSensitive = _$get.caseSensitive;
+
+  var insensitive = caseSensitive === false;
+
+  var prev = void 0;
+  var checkKeyOrder = function checkKeyOrder(node) {
+    prev = null;
+
+    _lodash2.default.forEach(node.properties, function (identifierNode) {
+      var current = (0, _utilities.getParameterName)(identifierNode, context);
+      var last = prev;
+
+      // keep track of the last token
+      prev = current || last;
+
+      if (!last || !current) {
+        return;
+      }
+
+      var isValidOrder = isValidOrders[order + (insensitive ? 'I' : '') + (natural ? 'N' : '')];
+
+      if (isValidOrder(last, current) === false) {
+        context.report({
+          data: {
+            current,
+            insensitive: insensitive ? 'insensitive ' : '',
+            last,
+            natural: natural ? 'natural ' : '',
+            order
+          },
+          fix(fixer) {
+            var nodeText = generateFix(node, context, isValidOrder);
+
+            return fixer.replaceText(node, nodeText);
+          },
+          loc: identifierNode.loc,
+          message: 'Expected type annotations to be in {{natural}}{{insensitive}}{{order}}ending order. "{{current}}" should be before "{{last}}".',
+          node: identifierNode
+        });
+      }
+    });
+  };
+
+  return {
+    ObjectTypeAnnotation: checkKeyOrder
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/spaceAfterTypeColon.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _typeColonSpacing = require('./typeColonSpacing');
+
+var _typeColonSpacing2 = _interopRequireDefault(_typeColonSpacing);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}, {
+  additionalProperties: false,
+  properties: {
+    allowLineBreak: {
+      type: 'boolean'
+    }
+  },
+  type: 'object'
+}];
+
+var create = function create(context) {
+  return (0, _typeColonSpacing2.default)('after', context, {
+    allowLineBreak: _lodash2.default.get(context, ['options', '1', 'allowLineBreak'], false),
+    always: _lodash2.default.get(context, ['options', '0'], 'always') === 'always'
+  });
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/spaceBeforeGenericBracket.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../utilities');
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var never = (context.options[0] || 'never') === 'never';
+
+  return {
+    GenericTypeAnnotation(node) {
+      var types = node.typeParameters;
+
+      // Promise<foo>
+      // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
+      //         ^^^  GenericTypeAnnotation (without typeParameters)
+      if (!types) {
+        return;
+      }
+
+      var spaceBefore = types.start - node.id.end;
+
+      if (never && spaceBefore) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore),
+          message: 'There must be no space before "{{name}}" generic type annotation bracket',
+          node
+        });
+      }
+
+      if (!never && !spaceBefore) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.addSpaceAfter(node.id),
+          message: 'There must be a space before "{{name}}" generic type annotation bracket',
+          node
+        });
+      }
+
+      if (!never && spaceBefore > 1) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore - 1),
+          message: 'There must be one space before "{{name}}" generic type annotation bracket',
+          node
+        });
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/spaceBeforeTypeColon.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeColonSpacing = require('./typeColonSpacing');
+
+var _typeColonSpacing2 = _interopRequireDefault(_typeColonSpacing);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  return (0, _typeColonSpacing2.default)('before', context, {
+    always: context.options[0] === 'always'
+  });
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateFunctions.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('../../utilities');
+
+var _evaluateTypical = require('./evaluateTypical');
+
+var _evaluateTypical2 = _interopRequireDefault(_evaluateTypical);
+
+var _evaluateReturnType = require('./evaluateReturnType');
+
+var _evaluateReturnType2 = _interopRequireDefault(_evaluateReturnType);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (0, _utilities.iterateFunctionNodes)(function (context, report) {
+  var checkParam = (0, _evaluateTypical2.default)(context, report, 'parameter');
+  var checkReturnType = (0, _evaluateReturnType2.default)(context, report);
+
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, checkParam);
+    checkReturnType(functionNode);
+  };
+});
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateObjectTypeIndexer.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../../utilities');
+
+exports.default = function (context, report) {
+  var sourceCode = context.getSourceCode();
+
+  return function (objectTypeIndexer) {
+    // type X = { [a: b]: c }
+    //              ^
+    report({
+      colon: (0, _utilities.getTokenBeforeParens)(sourceCode, objectTypeIndexer.key),
+      node: objectTypeIndexer
+    });
+
+    // type X = { [a: b]: c }
+    //                  ^
+    report({
+      colon: sourceCode.getTokenAfter((0, _utilities.getTokenAfterParens)(sourceCode, objectTypeIndexer.key)),
+      node: objectTypeIndexer
+    });
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateObjectTypeProperty.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../../utilities');
+
+var getColon = function getColon(context, objectTypeProperty) {
+  var tokenIndex = 1; // eslint-disable-line init-declarations
+
+  if (objectTypeProperty.optional) {
+    tokenIndex++;
+  }
+
+  if (objectTypeProperty.static) {
+    tokenIndex++;
+  }
+
+  if (objectTypeProperty.variance) {
+    tokenIndex++;
+  }
+
+  return context.getSourceCode().getFirstToken(objectTypeProperty, tokenIndex);
+};
+
+// 1) type X = { foo(): A; }
+// 2) type X = { foo: () => A; }
+// the above have identical ASTs (save for their ranges)
+// case 1 doesn't have a type annotation colon and should be ignored
+var isShortPropertyFunction = function isShortPropertyFunction(objectTypeProperty) {
+  return objectTypeProperty.value.type === 'FunctionTypeAnnotation' && objectTypeProperty.start === objectTypeProperty.value.start;
+};
+
+exports.default = function (context, report) {
+  return function (objectTypeProperty) {
+    if (isShortPropertyFunction(objectTypeProperty)) {
+      // potential difference: not checked in before
+      return;
+    }
+
+    report({
+      colon: getColon(context, objectTypeProperty),
+      name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(objectTypeProperty, context)),
+      node: objectTypeProperty
+    });
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateReturnType.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context, report) {
+  var sourceCode = context.getSourceCode();
+
+  return function (functionNode) {
+    // skip FunctionTypeAnnotation, possibly another rule as it's an arrow, not a colon?
+    // (foo: number) => string
+    //              ^^^^
+    if (functionNode.returnType && functionNode.type !== 'FunctionTypeAnnotation') {
+      report({
+        colon: sourceCode.getFirstToken(functionNode.returnType),
+        node: functionNode,
+        type: 'return type'
+      });
+    }
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateTypeCastExpression.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context, report) {
+  var sourceCode = context.getSourceCode();
+
+  return function (typeCastExpression) {
+    report({
+      colon: sourceCode.getFirstToken(typeCastExpression.typeAnnotation),
+      node: typeCastExpression,
+      type: 'type cast'
+    });
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/evaluateTypical.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('../../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (context, report, typeForMessage) {
+  var sourceCode = context.getSourceCode();
+
+  var getColon = function getColon(node, typeAnnotation) {
+    if (node.type === 'FunctionTypeParam') {
+      return sourceCode.getFirstToken(node, node.optional ? 2 : 1);
+    } else {
+      return sourceCode.getFirstToken(typeAnnotation);
+    }
+  };
+
+  return function (node) {
+    var typeAnnotation = _lodash2.default.get(node, 'typeAnnotation') || _lodash2.default.get(node, 'left.typeAnnotation');
+
+    if (typeAnnotation) {
+      report({
+        colon: getColon(node, typeAnnotation),
+        name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(node, context)),
+        node,
+        type: typeForMessage + ' type annotation'
+      });
+    }
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/index.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _reporter = require('./reporter');
+
+var _reporter2 = _interopRequireDefault(_reporter);
+
+var _evaluateObjectTypeIndexer = require('./evaluateObjectTypeIndexer');
+
+var _evaluateObjectTypeIndexer2 = _interopRequireDefault(_evaluateObjectTypeIndexer);
+
+var _evaluateObjectTypeProperty = require('./evaluateObjectTypeProperty');
+
+var _evaluateObjectTypeProperty2 = _interopRequireDefault(_evaluateObjectTypeProperty);
+
+var _evaluateTypeCastExpression = require('./evaluateTypeCastExpression');
+
+var _evaluateTypeCastExpression2 = _interopRequireDefault(_evaluateTypeCastExpression);
+
+var _evaluateTypical = require('./evaluateTypical');
+
+var _evaluateTypical2 = _interopRequireDefault(_evaluateTypical);
+
+var _evaluateFunctions = require('./evaluateFunctions');
+
+var _evaluateFunctions2 = _interopRequireDefault(_evaluateFunctions);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (direction, context, options) {
+  var report = (0, _reporter2.default)(direction, context, options);
+
+  return _extends({}, (0, _evaluateFunctions2.default)(context, report), {
+    ClassProperty: (0, _evaluateTypical2.default)(context, report, 'class property'),
+    ObjectTypeIndexer: (0, _evaluateObjectTypeIndexer2.default)(context, report),
+    ObjectTypeProperty: (0, _evaluateObjectTypeProperty2.default)(context, report),
+    TypeCastExpression: (0, _evaluateTypeCastExpression2.default)(context, report)
+  });
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeColonSpacing/reporter.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../../utilities');
+
+var hasLineBreak = function hasLineBreak(direction, colon, context) {
+  var sourceCode = context.getSourceCode();
+
+  if (direction === 'before') {
+    return colon.loc.start.line !== sourceCode.getTokenBefore(colon).loc.end.line;
+  } else {
+    return sourceCode.getTokenAfter(colon).loc.start.line !== colon.loc.end.line;
+  }
+};
+
+var getSpaces = function getSpaces(direction, colon, context) {
+  var sourceCode = context.getSourceCode();
+
+  if (direction === 'before') {
+    return colon.start - sourceCode.getTokenBefore(colon).end;
+  } else {
+    return sourceCode.getTokenAfter(colon).start - colon.end;
+  }
+};
+
+exports.default = function (direction, context, _ref) {
+  var always = _ref.always,
+      allowLineBreak = _ref.allowLineBreak;
+
+  return function (_ref2) {
+    var colon = _ref2.colon,
+        node = _ref2.node,
+        _ref2$name = _ref2.name,
+        name = _ref2$name === undefined ? '' : _ref2$name,
+        _ref2$type = _ref2.type,
+        type = _ref2$type === undefined ? 'type annotation' : _ref2$type;
+
+    var lineBreak = void 0,
+        spaces = void 0;
+
+    // Support optional names
+    // type X = { [string]: a }
+    // type X = string => string
+    if (!colon || colon.value !== ':') {
+      return;
+    }
+
+    var data = {
+      direction,
+      name,
+      type
+    };
+
+    if (hasLineBreak(direction, colon, context)) {
+      if (allowLineBreak) {
+        spaces = 1;
+      } else {
+        lineBreak = true;
+        spaces = getSpaces(direction, colon, context);
+      }
+    } else {
+      spaces = getSpaces(direction, colon, context);
+    }
+
+    if (always && lineBreak) {
+      context.report({
+        data,
+        fix: _utilities.spacingFixers.replaceWithSpace(direction, colon, spaces),
+        message: 'There must not be a line break {{direction}} {{name}}{{type}} colon.',
+        node
+      });
+    } else if (always && spaces > 1) {
+      context.report({
+        data,
+        fix: _utilities.spacingFixers.stripSpaces(direction, colon, spaces - 1),
+        message: 'There must be 1 space {{direction}} {{name}}{{type}} colon.',
+        node
+      });
+    } else if (always && spaces === 0) {
+      context.report({
+        data,
+        fix: _utilities.spacingFixers.addSpace(direction, colon),
+        message: 'There must be a space {{direction}} {{name}}{{type}} colon.',
+        node
+      });
+    } else if (!always && spaces > 0) {
+      context.report({
+        data,
+        fix: _utilities.spacingFixers.stripSpaces(direction, colon, spaces),
+        message: 'There must be no space {{direction}} {{name}}{{type}} colon.',
+        node
+      });
+    }
+  };
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/typeIdMatch.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [{
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var pattern = new RegExp(context.options[0] || '^([A-Z][a-z0-9]*)+Type$');
+
+  return {
+    TypeAlias(typeAliasNode) {
+      var typeIdentifierName = typeAliasNode.id.name;
+
+      if (!pattern.test(typeIdentifierName)) {
+        context.report(typeAliasNode, 'Type identifier \'{{name}}\' does not match pattern \'{{pattern}}\'.', {
+          name: typeIdentifierName,
+          pattern: pattern.toString()
+        });
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/unionIntersectionSpacing.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _utilities = require('../utilities');
+
+var schema = [{
+  enum: ['always', 'never'],
+  type: 'string'
+}];
+
+var create = function create(context) {
+  var sourceCode = context.getSourceCode();
+
+  var always = (context.options[0] || 'always') === 'always';
+
+  var check = function check(node) {
+    node.types.forEach(function (type, index) {
+      if (index + 1 === node.types.length) {
+        return;
+      }
+
+      var separator = (0, _utilities.getTokenAfterParens)(sourceCode, type);
+      var endOfType = sourceCode.getTokenBefore(separator);
+      var nextType = sourceCode.getTokenAfter(separator);
+
+      var spaceBefore = separator.start - endOfType.end;
+      var spaceAfter = nextType.start - separator.end;
+
+      var data = { type: node.type === 'UnionTypeAnnotation' ? 'union' : 'intersection' };
+
+      if (always) {
+        if (!spaceBefore) {
+          context.report({
+            data,
+            fix: _utilities.spacingFixers.addSpaceAfter(endOfType),
+            message: 'There must be a space before {{type}} type annotation separator',
+            node
+          });
+        }
+
+        if (!spaceAfter) {
+          context.report({
+            data,
+            fix: _utilities.spacingFixers.addSpaceAfter(separator),
+            message: 'There must be a space after {{type}} type annotation separator',
+            node
+          });
+        }
+      } else {
+        if (spaceBefore) {
+          context.report({
+            data,
+            fix: _utilities.spacingFixers.stripSpacesAfter(endOfType, spaceBefore),
+            message: 'There must be no space before {{type}} type annotation separator',
+            node
+          });
+        }
+
+        if (spaceAfter) {
+          context.report({
+            data,
+            fix: _utilities.spacingFixers.stripSpacesAfter(separator, spaceAfter),
+            message: 'There must be no space after {{type}} type annotation separator',
+            node
+          });
+        }
+      }
+    });
+  };
+
+  return {
+    IntersectionTypeAnnotation: check,
+    UnionTypeAnnotation: check
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/useFlowType.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var schema = [];
+
+var create = function create(context) {
+  var markTypeAsUsed = function markTypeAsUsed(node) {
+    context.markVariableAsUsed(node.id.name);
+  };
+
+  return {
+    DeclareClass: markTypeAsUsed,
+    DeclareFunction: markTypeAsUsed,
+    DeclareModule: markTypeAsUsed,
+    DeclareVariable: markTypeAsUsed,
+    GenericTypeAnnotation(node) {
+      var typeId = void 0;
+      var scope = void 0;
+      var variable = void 0;
+
+      if (node.id.type === 'Identifier') {
+        typeId = node.id;
+      } else if (node.id.type === 'QualifiedTypeIdentifier') {
+        typeId = node.id;
+        do {
+          typeId = typeId.qualification;
+        } while (typeId.qualification);
+      }
+
+      for (scope = context.getScope(); scope; scope = scope.upper) {
+        variable = scope.set.get(typeId.name);
+        if (variable && variable.defs.length) {
+          context.markVariableAsUsed(typeId.name);
+          break;
+        }
+      }
+    }
+  };
+};
+
+exports.default = {
+  create,
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/rules/validSyntax.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utilities = require('./../utilities');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var schema = [];
+
+var create = (0, _utilities.iterateFunctionNodes)(function (context) {
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, function (identifierNode) {
+      var nodeType = _lodash2.default.get(identifierNode, 'type');
+      var isAssignmentPattern = nodeType === 'AssignmentPattern';
+      var hasTypeAnnotation = Boolean(_lodash2.default.get(identifierNode, 'typeAnnotation'));
+      var leftAnnotated = Boolean(_lodash2.default.get(identifierNode, 'left.typeAnnotation'));
+
+      if (isAssignmentPattern && hasTypeAnnotation && !leftAnnotated) {
+        context.report({
+          data: {
+            name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(identifierNode, context))
+          },
+          message: '{{name}}parameter type annotation must be placed on left-hand side of assignment.',
+          node: identifierNode
+        });
+      }
+    });
+  };
+});
+
+exports.default = {
+  create,
+  meta: {
+    deprecated: true
+  },
+  schema
+};
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/checkFlowFileAnnotation.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _isFlowFile = require('./isFlowFile');
+
+var _isFlowFile2 = _interopRequireDefault(_isFlowFile);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (cb, context) {
+  var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _isFlowFile2.default)(context);
+
+  if (!checkThisFile) {
+    return function () {};
+  }
+
+  return cb(context);
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/fuzzyStringMatch.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Creates an array of letter pairs from a given an array
+ * https://github.com/d3/d3-array/blob/master/src/pairs.js
+ *
+ * @param {any} array
+ * @returns array
+ */
+/* eslint-disable */
+function d3ArrayPairs(array) {
+  var i = 0,
+      n = array.length - 1,
+      p = array[0],
+      pairs = new Array(n < 0 ? 0 : n);
+  while (i < n) {
+    pairs[i] = [p, p = array[++i]];
+  }return pairs;
+};
+/* eslint-enable */
+
+exports.default = function (needle, haystack) {
+  var weight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.5;
+
+  // Based on http://stackoverflow.com/a/23305385
+
+  var stringSimilarity = function stringSimilarity(str1, str2) {
+    if (str1.length > 0 && str2.length > 0) {
+      var pairs1 = d3ArrayPairs(str1);
+      var pairs2 = d3ArrayPairs(str2);
+      var unionLen = pairs1.length + pairs2.length;
+      var hitCount = void 0;
+
+      hitCount = 0;
+
+      _lodash2.default.forIn(pairs1, function (val1) {
+        _lodash2.default.forIn(pairs2, function (val2) {
+          if (_lodash2.default.isEqual(val1, val2)) {
+            hitCount++;
+          }
+        });
+      });
+
+      if (hitCount > 0) {
+        return 2.0 * hitCount / unionLen;
+      }
+    }
+
+    return 0.0;
+  };
+
+  return stringSimilarity(needle, haystack) >= Number(weight);
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/getParameterName.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (identifierNode, context) {
+  if (_lodash2.default.has(identifierNode, 'name')) {
+    return identifierNode.name;
+  }
+
+  if (_lodash2.default.has(identifierNode, 'left.name')) {
+    return identifierNode.left.name;
+  }
+
+  if (_lodash2.default.has(identifierNode, 'key.name')) {
+    return identifierNode.key.name;
+  }
+
+  if (identifierNode.type === 'RestElement') {
+    return identifierNode.argument.name;
+  }
+
+  if (identifierNode.type === 'ObjectTypeProperty') {
+    var tokenIndex = 0; // eslint-disable-line init-declarations
+
+    if (identifierNode.static) {
+      tokenIndex++;
+    }
+
+    if (identifierNode.variance) {
+      tokenIndex++;
+    }
+
+    return context.getSourceCode().getFirstToken(identifierNode, tokenIndex).value;
+  }
+
+  if (identifierNode.type === 'FunctionTypeParam') {
+    return context.getSourceCode().getFirstToken(identifierNode).value;
+  }
+
+  if (identifierNode.type === 'ObjectPattern' || identifierNode.type === 'ArrayPattern') {
+    var text = context.getSourceCode().getText(identifierNode);
+
+    if (identifierNode.typeAnnotation) {
+      return text.replace(context.getSourceCode().getText(identifierNode.typeAnnotation), '').trim();
+    } else {
+      return text;
+    }
+  }
+  if (_lodash2.default.get(identifierNode, 'left.type') === 'ObjectPattern') {
+    return context.getSourceCode().getText(identifierNode.left);
+  }
+
+  return null;
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/getTokenAfterParens.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var getTokenAfterParens = function getTokenAfterParens(sourceCode, node) {
+  var token = void 0;
+
+  token = sourceCode.getTokenAfter(node);
+
+  while (token.type === 'Punctuator' && token.value === ')') {
+    token = sourceCode.getTokenAfter(token);
+  }
+
+  return token;
+};
+
+exports.default = getTokenAfterParens;
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/getTokenBeforeParens.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var getTokenBeforeParens = function getTokenBeforeParens(sourceCode, node) {
+  var token = void 0;
+
+  token = sourceCode.getTokenBefore(node);
+
+  while (token.type === 'Punctuator' && token.value === '(') {
+    token = sourceCode.getTokenBefore(token);
+  }
+
+  return token;
+};
+
+exports.default = getTokenBeforeParens;
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/index.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.spacingFixers = exports.quoteName = exports.iterateFunctionNodes = exports.isFlowFileAnnotation = exports.isFlowFile = exports.getTokenBeforeParens = exports.getTokenAfterParens = exports.getParameterName = exports.fuzzyStringMatch = exports.checkFlowFileAnnotation = undefined;
+
+var _checkFlowFileAnnotation = require('./checkFlowFileAnnotation');
+
+Object.defineProperty(exports, 'checkFlowFileAnnotation', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_checkFlowFileAnnotation).default;
+  }
+});
+
+var _fuzzyStringMatch = require('./fuzzyStringMatch');
+
+Object.defineProperty(exports, 'fuzzyStringMatch', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_fuzzyStringMatch).default;
+  }
+});
+
+var _getParameterName = require('./getParameterName.js');
+
+Object.defineProperty(exports, 'getParameterName', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getParameterName).default;
+  }
+});
+
+var _getTokenAfterParens = require('./getTokenAfterParens');
+
+Object.defineProperty(exports, 'getTokenAfterParens', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getTokenAfterParens).default;
+  }
+});
+
+var _getTokenBeforeParens = require('./getTokenBeforeParens');
+
+Object.defineProperty(exports, 'getTokenBeforeParens', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getTokenBeforeParens).default;
+  }
+});
+
+var _isFlowFile = require('./isFlowFile.js');
+
+Object.defineProperty(exports, 'isFlowFile', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_isFlowFile).default;
+  }
+});
+
+var _isFlowFileAnnotation = require('./isFlowFileAnnotation.js');
+
+Object.defineProperty(exports, 'isFlowFileAnnotation', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_isFlowFileAnnotation).default;
+  }
+});
+
+var _iterateFunctionNodes = require('./iterateFunctionNodes.js');
+
+Object.defineProperty(exports, 'iterateFunctionNodes', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_iterateFunctionNodes).default;
+  }
+});
+
+var _quoteName = require('./quoteName');
+
+Object.defineProperty(exports, 'quoteName', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_quoteName).default;
+  }
+});
+
+var _spacingFixers = require('./spacingFixers');
+
+var spacingFixers = _interopRequireWildcard(_spacingFixers);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.spacingFixers = spacingFixers;

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/isFlowFile.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _isFlowFileAnnotation = require('./isFlowFileAnnotation.js');
+
+var _isFlowFileAnnotation2 = _interopRequireDefault(_isFlowFileAnnotation);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable flowtype/require-valid-file-annotation */
+/**
+ * Checks whether a file has an @flow or @noflow annotation.
+ * @param context
+ * @param [strict] - By default, the function returns true if the file starts with @flow but not if it
+ * starts by @noflow. When the strict flag is set to false, the function returns true if the flag has @noflow also.
+ */
+/* eslint-enable flowtype/require-valid-file-annotation */
+exports.default = function (context) {
+  var strict = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+  var comments = context.getAllComments();
+
+  if (!comments.length) {
+    return false;
+  }
+
+  return comments.some(function (comment) {
+    return (0, _isFlowFileAnnotation2.default)(comment.value) && !(strict && /no/.test(comment.value));
+  });
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/isFlowFileAnnotation.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var FLOW_MATCHER = /^@(?:no)?flow$/;
+
+exports.default = function (comment) {
+  // eslint-disable-next-line flowtype/require-valid-file-annotation
+  // The flow parser splits comments with the following regex to look for the @flow flag.
+  // See https://github.com/facebook/flow/blob/a96249b93541f2f7bfebd8d62085bf7a75de02f2/src/parsing/docblock.ml#L39
+  return _lodash2.default.some(comment.split(/[ \t\r\n\\*/]+/), function (commentPart) {
+    return FLOW_MATCHER.test(commentPart);
+  });
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/iterateFunctionNodes.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (iterator) {
+  return function (context) {
+    for (var _len = arguments.length, rest = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      rest[_key - 1] = arguments[_key];
+    }
+
+    var nodeIterator = iterator.apply(undefined, [context].concat(rest));
+
+    return {
+      ArrowFunctionExpression: nodeIterator,
+      FunctionDeclaration: nodeIterator,
+      FunctionExpression: nodeIterator,
+      FunctionTypeAnnotation: nodeIterator
+    };
+  };
+};
+
+module.exports = exports["default"];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/quoteName.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (name) {
+  return name ? '"' + name + '" ' : '';
+};
+
+module.exports = exports['default'];

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/dist/utilities/spacingFixers.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var stripSpacesBefore = exports.stripSpacesBefore = function stripSpacesBefore(node, spaces) {
+  return function (fixer) {
+    return fixer.removeRange([node.start - spaces, node.start]);
+  };
+};
+
+var stripSpacesAfter = exports.stripSpacesAfter = function stripSpacesAfter(node, spaces) {
+  return function (fixer) {
+    return fixer.removeRange([node.end, node.end + spaces]);
+  };
+};
+
+var addSpaceBefore = exports.addSpaceBefore = function addSpaceBefore(node) {
+  return function (fixer) {
+    return fixer.insertTextBefore(node, ' ');
+  };
+};
+
+var addSpaceAfter = exports.addSpaceAfter = function addSpaceAfter(node) {
+  return function (fixer) {
+    return fixer.insertTextAfter(node, ' ');
+  };
+};
+
+var replaceWithSpaceBefore = exports.replaceWithSpaceBefore = function replaceWithSpaceBefore(node, spaces) {
+  return function (fixer) {
+    return fixer.replaceTextRange([node.start - spaces, node.start], ' ');
+  };
+};
+
+var replaceWithSpaceAfter = exports.replaceWithSpaceAfter = function replaceWithSpaceAfter(node, spaces) {
+  return function (fixer) {
+    return fixer.replaceTextRange([node.end, node.end + spaces], ' ');
+  };
+};
+
+var stripSpaces = exports.stripSpaces = function stripSpaces(direction, node, spaces) {
+  if (direction === 'before') {
+    return stripSpacesBefore(node, spaces);
+  } else {
+    return stripSpacesAfter(node, spaces);
+  }
+};
+
+var addSpace = exports.addSpace = function addSpace(direction, node) {
+  if (direction === 'before') {
+    return addSpaceBefore(node);
+  } else {
+    return addSpaceAfter(node);
+  }
+};
+
+var replaceWithSpace = exports.replaceWithSpace = function replaceWithSpace(direction, node, spaces) {
+  if (direction === 'before') {
+    return replaceWithSpaceBefore(node, spaces);
+  } else {
+    return replaceWithSpaceAfter(node, spaces);
+  }
+};

goTorrentWebUI/node_modules/react-scripts/node_modules/eslint-plugin-flowtype/package.json

@@ -0,0 +1,89 @@
+{
+  "_args": [
+    [
+      "eslint-plugin-flowtype@2.39.1",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "eslint-plugin-flowtype@2.39.1",
+  "_id": "eslint-plugin-flowtype@2.39.1",
+  "_inBundle": false,
+  "_integrity": "sha512-RiQv+7Z9QDJuzt+NO8sYgkLGT+h+WeCrxP7y8lI7wpU41x3x/2o3PGtHk9ck8QnA9/mlbNcy/hG0eKvmd7npaA==",
+  "_location": "/react-scripts/eslint-plugin-flowtype",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "eslint-plugin-flowtype@2.39.1",
+    "name": "eslint-plugin-flowtype",
+    "escapedName": "eslint-plugin-flowtype",
+    "rawSpec": "2.39.1",
+    "saveSpec": null,
+    "fetchSpec": "2.39.1"
+  },
+  "_requiredBy": [
+    "/react-scripts"
+  ],
+  "_resolved": "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.39.1.tgz",
+  "_spec": "2.39.1",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Gajus Kuizinas",
+    "email": "gajus@gajus.com",
+    "url": "http://gajus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/gajus/eslint-plugin-flowtype/issues"
+  },
+  "dependencies": {
+    "lodash": "^4.15.0"
+  },
+  "description": "Flowtype linting rules for ESLint.",
+  "devDependencies": {
+    "ajv": "^5.2.1",
+    "babel-cli": "^6.14.0",
+    "babel-eslint": "^6.1.2",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-plugin-transform-object-rest-spread": "^6.23.0",
+    "babel-preset-env": "^1.1.10",
+    "babel-register": "^6.14.0",
+    "chai": "^3.5.0",
+    "eslint": "^3.16.0",
+    "eslint-config-canonical": "1.8.1",
+    "gitdown": "^2.5.0",
+    "glob": "^7.1.2",
+    "husky": "^0.11.7",
+    "jsonlint": "^1.6.2",
+    "mocha": "^3.0.2",
+    "semantic-release": "^6.3.2"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "homepage": "https://github.com/gajus/eslint-plugin-flowtype#readme",
+  "keywords": [
+    "eslint",
+    "plugin",
+    "flowtype"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "./dist/index.js",
+  "name": "eslint-plugin-flowtype",
+  "peerDependencies": {
+    "eslint": ">=2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gajus/eslint-plugin-flowtype.git"
+  },
+  "scripts": {
+    "build": "babel ./src --out-dir ./dist --copy-files",
+    "documentation": "gitdown ./.README/README.md --output-file ./README.md; npm run documentation-add-assertions",
+    "documentation-add-assertions": "babel-node ./bin/readmeAssertions",
+    "format-json": "jsonlint --sort-keys --in-place --indent '  ' ./src/configs/recommended.json && echo '' >> ./src/configs/recommended.json",
+    "lint": "eslint ./src ./tests",
+    "precommit": "npm run lint && npm run test && npm run format-json",
+    "test": "mocha --compilers js:babel-register ./tests/rules/index.js"
+  },
+  "version": "2.39.1"
+}