Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/attachComments.js

@@ -0,0 +1,59 @@
+"use strict";
+
+// comment fixes
+module.exports = function (ast, comments, tokens) {
+  if (comments.length) {
+    var firstComment = comments[0];
+    var lastComment = comments[comments.length - 1];
+    // fixup program start
+    if (!tokens.length) {
+      // if no tokens, the program starts at the end of the last comment
+      ast.start = lastComment.end;
+      ast.loc.start.line = lastComment.loc.end.line;
+      ast.loc.start.column = lastComment.loc.end.column;
+
+      if (ast.leadingComments === null && ast.innerComments.length) {
+        ast.leadingComments = ast.innerComments;
+      }
+    } else if (firstComment.start < tokens[0].start) {
+      // if there are comments before the first token, the program starts at the first token
+      var token = tokens[0];
+      // ast.start = token.start;
+      // ast.loc.start.line = token.loc.start.line;
+      // ast.loc.start.column = token.loc.start.column;
+
+      // estraverse do not put leading comments on first node when the comment
+      // appear before the first token
+      if (ast.body.length) {
+        var node = ast.body[0];
+        node.leadingComments = [];
+        var firstTokenStart = token.start;
+        var len = comments.length;
+        for (var i = 0; i < len && comments[i].start < firstTokenStart; i++) {
+          node.leadingComments.push(comments[i]);
+        }
+      }
+    }
+    // fixup program end
+    if (tokens.length) {
+      var lastToken = tokens[tokens.length - 1];
+      if (lastComment.end > lastToken.end) {
+        // If there is a comment after the last token, the program ends at the
+        // last token and not the comment
+        // ast.end = lastToken.end;
+        ast.range[1] = lastToken.end;
+        ast.loc.end.line = lastToken.loc.end.line;
+        ast.loc.end.column = lastToken.loc.end.column;
+      }
+    }
+  } else {
+    if (!tokens.length) {
+      ast.loc.start.line = 1;
+      ast.loc.end.line = 1;
+    }
+  }
+  if (ast.body && ast.body.length > 0) {
+    ast.loc.start.line = ast.body[0].loc.start.line;
+    ast.range[0] = ast.body[0].start;
+  }
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/convertComments.js

@@ -0,0 +1,17 @@
+"use strict";
+
+module.exports = function (comments) {
+  for (var i = 0; i < comments.length; i++) {
+    var comment = comments[i];
+    if (comment.type === "CommentBlock") {
+      comment.type = "Block";
+    } else if (comment.type === "CommentLine") {
+      comment.type = "Line";
+    }
+    // sometimes comments don't get ranges computed,
+    // even with options.ranges === true
+    if (!comment.range) {
+      comment.range = [comment.start, comment.end];
+    }
+  }
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/convertTemplateType.js

@@ -0,0 +1,95 @@
+"use strict";
+
+module.exports = function (tokens, tt) {
+  var startingToken    = 0;
+  var currentToken     = 0;
+  var numBraces        = 0; // track use of {}
+  var numBackQuotes    = 0; // track number of nested templates
+
+  function isBackQuote(token) {
+    return tokens[token].type === tt.backQuote;
+  }
+
+  function isTemplateStarter(token) {
+    return isBackQuote(token) ||
+           // only can be a template starter when in a template already
+           tokens[token].type === tt.braceR && numBackQuotes > 0;
+  }
+
+  function isTemplateEnder(token) {
+    return isBackQuote(token) ||
+           tokens[token].type === tt.dollarBraceL;
+  }
+
+  // append the values between start and end
+  function createTemplateValue(start, end) {
+    var value = "";
+    while (start <= end) {
+      if (tokens[start].value) {
+        value += tokens[start].value;
+      } else if (tokens[start].type !== tt.template) {
+        value += tokens[start].type.label;
+      }
+      start++;
+    }
+    return value;
+  }
+
+  // create Template token
+  function replaceWithTemplateType(start, end) {
+    var templateToken = {
+      type: "Template",
+      value: createTemplateValue(start, end),
+      start: tokens[start].start,
+      end: tokens[end].end,
+      loc: {
+        start: tokens[start].loc.start,
+        end: tokens[end].loc.end
+      }
+    };
+
+    // put new token in place of old tokens
+    tokens.splice(start, end - start + 1, templateToken);
+  }
+
+  function trackNumBraces(token) {
+    if (tokens[token].type === tt.braceL) {
+      numBraces++;
+    } else if (tokens[token].type === tt.braceR) {
+      numBraces--;
+    }
+  }
+
+  while (startingToken < tokens.length) {
+    // template start: check if ` or }
+    if (isTemplateStarter(startingToken) && numBraces === 0) {
+      if (isBackQuote(startingToken)) {
+        numBackQuotes++;
+      }
+
+      currentToken = startingToken + 1;
+
+      // check if token after template start is "template"
+      if (currentToken >= tokens.length - 1 || tokens[currentToken].type !== tt.template) {
+        break;
+      }
+
+      // template end: find ` or ${
+      while (!isTemplateEnder(currentToken)) {
+        if (currentToken >= tokens.length - 1) {
+          break;
+        }
+        currentToken++;
+      }
+
+      if (isBackQuote(currentToken)) {
+        numBackQuotes--;
+      }
+      // template start and end found: create new token
+      replaceWithTemplateType(startingToken, currentToken);
+    } else if (numBackQuotes > 0) {
+      trackNumBraces(startingToken);
+    }
+    startingToken++;
+  }
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var attachComments  = require("./attachComments");
+var convertComments = require("./convertComments");
+var toTokens        = require("./toTokens");
+var toAST           = require("./toAST");
+
+module.exports = function (ast, traverse, tt, code) {
+  // remove EOF token, eslint doesn't use this for anything and it interferes
+  // with some rules see https://github.com/babel/babel-eslint/issues/2
+  // todo: find a more elegant way to do this
+  ast.tokens.pop();
+
+  // convert tokens
+  ast.tokens = toTokens(ast.tokens, tt, code);
+
+  // add comments
+  convertComments(ast.comments);
+
+  // transform esprima and acorn divergent nodes
+  toAST(ast, traverse, code);
+
+  // ast.program.tokens = ast.tokens;
+  // ast.program.comments = ast.comments;
+  // ast = ast.program;
+
+  // remove File
+  ast.type = "Program";
+  ast.sourceType = ast.program.sourceType;
+  ast.directives = ast.program.directives;
+  ast.body = ast.program.body;
+  delete ast.program;
+  delete ast._paths;
+
+  attachComments(ast, ast.comments, ast.tokens);
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/toAST.js

@@ -0,0 +1,237 @@
+"use strict";
+
+var convertComments = require("./convertComments");
+
+module.exports = function (ast, traverse, code) {
+  var state = { source: code };
+  ast.range = [ast.start, ast.end];
+  traverse(ast, astTransformVisitor, null, state);
+};
+
+function changeToLiteral(node, state) {
+  node.type = "Literal";
+  if (!node.raw) {
+    if (node.extra && node.extra.raw) {
+      node.raw = node.extra.raw;
+    } else {
+      node.raw = state.source.slice(node.start, node.end);
+    }
+  }
+}
+
+var astTransformVisitor = {
+  noScope: true,
+  enter (path) {
+    var node = path.node;
+
+    node.range = [node.start, node.end];
+
+    // private var to track original node type
+    node._babelType = node.type;
+
+    if (node.innerComments) {
+      node.trailingComments = node.innerComments;
+      delete node.innerComments;
+    }
+
+    if (node.trailingComments) {
+      convertComments(node.trailingComments);
+    }
+
+    if (node.leadingComments) {
+      convertComments(node.leadingComments);
+    }
+
+    // make '_paths' non-enumerable (babel-eslint #200)
+    Object.defineProperty(node, "_paths", { value: node._paths, writable: true });
+  },
+  exit (path, state) {
+    var node = path.node;
+
+    // fixDirectives
+    if (path.isFunction() || path.isProgram()) {
+      var directivesContainer = node;
+      var body = node.body;
+      if (node.type !== "Program") {
+        directivesContainer = body;
+        body = body.body;
+      }
+      if (directivesContainer.directives) {
+        for (var i = directivesContainer.directives.length - 1; i >= 0; i--) {
+          var directive = directivesContainer.directives[i];
+          directive.type = "ExpressionStatement";
+          directive.expression = directive.value;
+          delete directive.value;
+          directive.expression.type = "Literal";
+          changeToLiteral(directive.expression, state);
+          body.unshift(directive);
+        }
+        delete directivesContainer.directives;
+      }
+    }
+
+    if (path.isJSXText()) {
+      node.type = "Literal";
+      node.raw = node.value;
+    }
+
+    if (path.isNumericLiteral() ||
+        path.isStringLiteral()) {
+      changeToLiteral(node, state);
+    }
+
+    if (path.isBooleanLiteral()) {
+      node.type = "Literal";
+      node.raw = String(node.value);
+    }
+
+    if (path.isNullLiteral()) {
+      node.type = "Literal";
+      node.raw = "null";
+      node.value = null;
+    }
+
+    if (path.isRegExpLiteral()) {
+      node.type = "Literal";
+      node.raw = node.extra.raw;
+      node.value = {};
+      node.regex = {
+        pattern: node.pattern,
+        flags: node.flags
+      };
+      delete node.extra;
+      delete node.pattern;
+      delete node.flags;
+    }
+
+    if (path.isObjectProperty()) {
+      node.type = "Property";
+      node.kind = "init";
+    }
+
+    if (path.isClassMethod() || path.isObjectMethod()) {
+      var code = state.source.slice(node.key.end, node.body.start);
+      var offset = code.indexOf("(");
+
+      node.value = {
+        type: "FunctionExpression",
+        id: node.id,
+        params: node.params,
+        body: node.body,
+        async: node.async,
+        generator: node.generator,
+        expression: node.expression,
+        defaults: [], // basic support - TODO: remove (old esprima)
+        loc: {
+          start: {
+            line: node.key.loc.start.line,
+            column: node.key.loc.end.column + offset // a[() {]
+          },
+          end: node.body.loc.end
+        }
+      };
+      // [asdf]() {
+      node.value.range = [node.key.end + offset, node.body.end];
+
+      node.value.start = node.value.range && node.value.range[0] || node.value.loc.start.column;
+      node.value.end = node.value.range && node.value.range[1] || node.value.loc.end.column;
+
+      if (node.returnType) {
+        node.value.returnType = node.returnType;
+      }
+
+      if (node.typeParameters) {
+        node.value.typeParameters = node.typeParameters;
+      }
+
+      if (path.isClassMethod()) {
+        node.type = "MethodDefinition";
+      }
+
+      if (path.isObjectMethod()) {
+        node.type = "Property";
+        if (node.kind === "method") {
+          node.kind = "init";
+        }
+      }
+
+      delete node.body;
+      delete node.id;
+      delete node.async;
+      delete node.generator;
+      delete node.expression;
+      delete node.params;
+      delete node.returnType;
+      delete node.typeParameters;
+    }
+
+    if (path.isRestProperty() || path.isSpreadProperty()) {
+      node.type = `Experimental${node.type}`;
+    }
+
+    if (path.isTypeParameter && path.isTypeParameter()) {
+      node.type = "Identifier";
+      node.typeAnnotation = node.bound;
+      delete node.bound;
+    }
+
+    // flow: prevent "no-undef"
+    // for "Component" in: "let x: React.Component"
+    if (path.isQualifiedTypeIdentifier()) {
+      delete node.id;
+    }
+    // for "b" in: "var a: { b: Foo }"
+    if (path.isObjectTypeProperty()) {
+      delete node.key;
+    }
+    // for "indexer" in: "var a: {[indexer: string]: number}"
+    if (path.isObjectTypeIndexer()) {
+      delete node.id;
+    }
+    // for "param" in: "var a: { func(param: Foo): Bar };"
+    if (path.isFunctionTypeParam()) {
+      delete node.name;
+    }
+
+    // modules
+
+    if (path.isImportDeclaration()) {
+      delete node.isType;
+    }
+
+    if (path.isExportDeclaration()) {
+      var declar = path.get("declaration");
+      if (declar.isClassExpression()) {
+        node.declaration.type = "ClassDeclaration";
+      } else if (declar.isFunctionExpression()) {
+        node.declaration.type = "FunctionDeclaration";
+      }
+    }
+
+    // TODO: remove (old esprima)
+    if (path.isFunction()) {
+      if (!node.defaults) {
+        node.defaults = [];
+      }
+    }
+
+    // template string range fixes
+    if (path.isTemplateLiteral()) {
+      for (var j = 0; j < node.quasis.length; j++) {
+        var q = node.quasis[j];
+        q.range[0] -= 1;
+        if (q.tail) {
+          q.range[1] += 1;
+        } else {
+          q.range[1] += 2;
+        }
+        q.loc.start.column -= 1;
+        if (q.tail) {
+          q.loc.end.column += 1;
+        } else {
+          q.loc.end.column += 2;
+        }
+      }
+    }
+  }
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/toToken.js

@@ -0,0 +1,62 @@
+"use strict";
+
+module.exports = function (token, tt, source) {
+  var type = token.type;
+  token.range = [token.start, token.end];
+
+  if (type === tt.name) {
+    token.type = "Identifier";
+  } else if (type === tt.semi || type === tt.comma ||
+             type === tt.parenL || type === tt.parenR ||
+             type === tt.braceL || type === tt.braceR ||
+             type === tt.slash || type === tt.dot ||
+             type === tt.bracketL || type === tt.bracketR ||
+             type === tt.ellipsis || type === tt.arrow ||
+             type === tt.star || type === tt.incDec ||
+             type === tt.colon || type === tt.question ||
+             type === tt.template || type === tt.backQuote ||
+             type === tt.dollarBraceL || type === tt.at ||
+             type === tt.logicalOR || type === tt.logicalAND ||
+             type === tt.bitwiseOR || type === tt.bitwiseXOR ||
+             type === tt.bitwiseAND || type === tt.equality ||
+             type === tt.relational || type === tt.bitShift ||
+             type === tt.plusMin || type === tt.modulo ||
+             type === tt.exponent || type === tt.prefix ||
+             type === tt.doubleColon ||
+             type.isAssign) {
+    token.type = "Punctuator";
+    if (!token.value) token.value = type.label;
+  } else if (type === tt.jsxTagStart) {
+    token.type = "Punctuator";
+    token.value = "<";
+  } else if (type === tt.jsxTagEnd) {
+    token.type = "Punctuator";
+    token.value = ">";
+  } else if (type === tt.jsxName) {
+    token.type = "JSXIdentifier";
+  } else if (type === tt.jsxText) {
+    token.type = "JSXText";
+  } else if (type.keyword === "null") {
+    token.type = "Null";
+  } else if (type.keyword === "false" || type.keyword === "true") {
+    token.type = "Boolean";
+  } else if (type.keyword) {
+    token.type = "Keyword";
+  } else if (type === tt.num) {
+    token.type = "Numeric";
+    token.value = source.slice(token.start, token.end);
+  } else if (type === tt.string) {
+    token.type = "String";
+    token.value = source.slice(token.start, token.end);
+  } else if (type === tt.regexp) {
+    token.type = "RegularExpression";
+    var value = token.value;
+    token.regex = {
+      pattern: value.pattern,
+      flags: value.flags
+    };
+    token.value = `/${value.pattern}/${value.flags}`;
+  }
+
+  return token;
+};

torrent-project/node_modules/react-scripts/node_modules/babel-eslint/babylon-to-espree/toTokens.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var convertTemplateType = require("./convertTemplateType");
+var toToken = require("./toToken");
+
+module.exports = function (tokens, tt, code) {
+  // transform tokens to type "Template"
+  convertTemplateType(tokens, tt);
+
+  var transformedTokens = [];
+  for (var i = 0; i < tokens.length; i++) {
+    var token = tokens[i];
+    if (token.type !== "CommentLine" && token.type !== "CommentBlock") {
+      transformedTokens.push(toToken(token, tt, code));
+    }
+  }
+
+  return transformedTokens;
+};