Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/babel-preset-env/lib/default-includes.js

@@ -0,0 +1,4 @@
+"use strict";
+
+exports.__esModule = true;
+var defaultWebIncludes = exports.defaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"];

torrent-project/node_modules/babel-preset-env/lib/index.js

@@ -0,0 +1,194 @@
+"use strict";
+
+exports.__esModule = true;
+exports.transformIncludesAndExcludes = exports.isPluginRequired = undefined;
+exports.default = buildPreset;
+
+var _semver = require("semver");
+
+var _semver2 = _interopRequireDefault(_semver);
+
+var _builtIns = require("../data/built-ins.json");
+
+var _builtIns2 = _interopRequireDefault(_builtIns);
+
+var _defaultIncludes = require("./default-includes");
+
+var _moduleTransformations = require("./module-transformations");
+
+var _moduleTransformations2 = _interopRequireDefault(_moduleTransformations);
+
+var _normalizeOptions = require("./normalize-options.js");
+
+var _normalizeOptions2 = _interopRequireDefault(_normalizeOptions);
+
+var _plugins = require("../data/plugins.json");
+
+var _plugins2 = _interopRequireDefault(_plugins);
+
+var _transformPolyfillRequirePlugin = require("./transform-polyfill-require-plugin");
+
+var _transformPolyfillRequirePlugin2 = _interopRequireDefault(_transformPolyfillRequirePlugin);
+
+var _targetsParser = require("./targets-parser");
+
+var _targetsParser2 = _interopRequireDefault(_targetsParser);
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Determine if a transformation is required
+ *
+ * NOTE: This assumes `supportedEnvironments` has already been parsed by `getTargets`
+ *
+ * @param  {Object}  supportedEnvironments  An Object containing environment keys and the lowest
+ *                                          supported version as a value
+ * @param  {Object}  plugin                 An Object containing environment keys and the lowest
+ *                                          version the feature was implemented in as a value
+ * @return {Boolean} Whether or not the transformation is required
+ */
+var isPluginRequired = exports.isPluginRequired = function isPluginRequired(supportedEnvironments, plugin) {
+  var targetEnvironments = Object.keys(supportedEnvironments);
+
+  if (targetEnvironments.length === 0) {
+    return true;
+  }
+
+  var isRequiredForEnvironments = targetEnvironments.filter(function (environment) {
+    // Feature is not implemented in that environment
+    if (!plugin[environment]) {
+      return true;
+    }
+
+    var lowestImplementedVersion = plugin[environment];
+    var lowestTargetedVersion = supportedEnvironments[environment];
+
+    if (!_semver2.default.valid(lowestTargetedVersion)) {
+      throw new Error(
+      // eslint-disable-next-line max-len
+      "Invalid version passed for target \"" + environment + "\": \"" + lowestTargetedVersion + "\". Versions must be in semver format (major.minor.patch)");
+    }
+
+    return _semver2.default.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion);
+  });
+
+  return isRequiredForEnvironments.length > 0;
+};
+
+var hasBeenLogged = false;
+
+var logPlugin = function logPlugin(plugin, targets, list) {
+  var envList = list[plugin] || {};
+  var filteredList = Object.keys(targets).reduce(function (a, b) {
+    if (!envList[b] || _semver2.default.lt(targets[b], (0, _utils.semverify)(envList[b]))) {
+      a[b] = (0, _utils.prettifyVersion)(targets[b]);
+    }
+    return a;
+  }, {});
+  var logStr = "  " + plugin + " " + JSON.stringify(filteredList);
+  console.log(logStr);
+};
+
+var filterItem = function filterItem(targets, exclusions, list, item) {
+  var isDefault = _defaultIncludes.defaultWebIncludes.indexOf(item) >= 0;
+  var notExcluded = exclusions.indexOf(item) === -1;
+
+  if (isDefault) return notExcluded;
+  var isRequired = isPluginRequired(targets, list[item]);
+  return isRequired && notExcluded;
+};
+
+var getBuiltInTargets = function getBuiltInTargets(targets) {
+  var builtInTargets = (0, _utils._extends)({}, targets);
+  if (builtInTargets.uglify != null) {
+    delete builtInTargets.uglify;
+  }
+  return builtInTargets;
+};
+
+var transformIncludesAndExcludes = exports.transformIncludesAndExcludes = function transformIncludesAndExcludes(opts) {
+  return {
+    all: opts,
+    plugins: opts.filter(function (opt) {
+      return !opt.match(/^(es\d+|web)\./);
+    }),
+    builtIns: opts.filter(function (opt) {
+      return opt.match(/^(es\d+|web)\./);
+    })
+  };
+};
+
+function getPlatformSpecificDefaultFor(targets) {
+  var targetNames = Object.keys(targets);
+  var isAnyTarget = !targetNames.length;
+  var isWebTarget = targetNames.some(function (name) {
+    return name !== "node";
+  });
+
+  return isAnyTarget || isWebTarget ? _defaultIncludes.defaultWebIncludes : [];
+}
+
+function buildPreset(context) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  var validatedOptions = (0, _normalizeOptions2.default)(opts);
+  var debug = validatedOptions.debug,
+      loose = validatedOptions.loose,
+      moduleType = validatedOptions.moduleType,
+      spec = validatedOptions.spec,
+      useBuiltIns = validatedOptions.useBuiltIns;
+
+
+  var targets = (0, _targetsParser2.default)(validatedOptions.targets);
+  var include = transformIncludesAndExcludes(validatedOptions.include);
+  var exclude = transformIncludesAndExcludes(validatedOptions.exclude);
+
+  var filterPlugins = filterItem.bind(null, targets, exclude.plugins, _plugins2.default);
+  var transformations = Object.keys(_plugins2.default).filter(filterPlugins).concat(include.plugins);
+
+  var polyfills = void 0;
+  var polyfillTargets = void 0;
+  if (useBuiltIns) {
+    polyfillTargets = getBuiltInTargets(targets);
+    var filterBuiltIns = filterItem.bind(null, polyfillTargets, exclude.builtIns, _builtIns2.default);
+    polyfills = Object.keys(_builtIns2.default).concat(getPlatformSpecificDefaultFor(polyfillTargets)).filter(filterBuiltIns).concat(include.builtIns);
+  }
+
+  if (debug && !hasBeenLogged) {
+    hasBeenLogged = true;
+    console.log("babel-preset-env: `DEBUG` option");
+    console.log("\nUsing targets:");
+    console.log(JSON.stringify((0, _utils.prettifyTargets)(targets), null, 2));
+    console.log("\nModules transform: " + moduleType);
+    console.log("\nUsing plugins:");
+    transformations.forEach(function (transform) {
+      logPlugin(transform, targets, _plugins2.default);
+    });
+    if (useBuiltIns && polyfills.length) {
+      console.log("\nUsing polyfills:");
+      polyfills.forEach(function (polyfill) {
+        logPlugin(polyfill, polyfillTargets, _builtIns2.default);
+      });
+    }
+  }
+
+  var regenerator = transformations.indexOf("transform-regenerator") >= 0;
+  var modulePlugin = moduleType !== false && _moduleTransformations2.default[moduleType];
+  var plugins = [];
+
+  // NOTE: not giving spec here yet to avoid compatibility issues when
+  // babel-plugin-transform-es2015-modules-commonjs gets its spec mode
+  modulePlugin && plugins.push([require("babel-plugin-" + modulePlugin), { loose: loose }]);
+
+  plugins.push.apply(plugins, transformations.map(function (pluginName) {
+    return [require("babel-plugin-" + pluginName), { spec: spec, loose: loose }];
+  }));
+
+  useBuiltIns && plugins.push([_transformPolyfillRequirePlugin2.default, { polyfills: polyfills, regenerator: regenerator }]);
+
+  return {
+    plugins: plugins
+  };
+}

torrent-project/node_modules/babel-preset-env/lib/module-transformations.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = {
+  "amd": "transform-es2015-modules-amd",
+  "commonjs": "transform-es2015-modules-commonjs",
+  "systemjs": "transform-es2015-modules-systemjs",
+  "umd": "transform-es2015-modules-umd"
+};

torrent-project/node_modules/babel-preset-env/lib/normalize-options.js

@@ -0,0 +1,126 @@
+"use strict";
+
+exports.__esModule = true;
+exports.validateModulesOption = exports.validateSpecOption = exports.validateLooseOption = exports.validateBoolOption = exports.checkDuplicateIncludeExcludes = exports.normalizePluginNames = exports.normalizePluginName = exports.validateIncludesAndExcludes = undefined;
+exports.default = normalizeOptions;
+
+var _invariant = require("invariant");
+
+var _invariant2 = _interopRequireDefault(_invariant);
+
+var _builtIns = require("../data/built-ins.json");
+
+var _builtIns2 = _interopRequireDefault(_builtIns);
+
+var _defaultIncludes = require("./default-includes");
+
+var _moduleTransformations = require("./module-transformations");
+
+var _moduleTransformations2 = _interopRequireDefault(_moduleTransformations);
+
+var _plugins = require("../data/plugins.json");
+
+var _plugins2 = _interopRequireDefault(_plugins);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var validIncludesAndExcludes = [].concat(Object.keys(_plugins2.default), Object.keys(_moduleTransformations2.default).map(function (m) {
+  return _moduleTransformations2.default[m];
+}), Object.keys(_builtIns2.default), _defaultIncludes.defaultWebIncludes);
+
+var hasBeenWarned = false;
+
+var validateIncludesAndExcludes = exports.validateIncludesAndExcludes = function validateIncludesAndExcludes() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var type = arguments[1];
+
+  (0, _invariant2.default)(Array.isArray(opts), "Invalid Option: The '" + type + "' option must be an Array<String> of plugins/built-ins");
+
+  var unknownOpts = [];
+  opts.forEach(function (opt) {
+    if (validIncludesAndExcludes.indexOf(opt) === -1) {
+      unknownOpts.push(opt);
+    }
+  });
+
+  (0, _invariant2.default)(unknownOpts.length === 0, "Invalid Option: The plugins/built-ins '" + unknownOpts + "' passed to the '" + type + "' option are not\n    valid. Please check data/[plugin-features|built-in-features].js in babel-preset-env");
+
+  return opts;
+};
+
+var normalizePluginName = exports.normalizePluginName = function normalizePluginName(plugin) {
+  return plugin.replace(/^babel-plugin-/, "");
+};
+
+var normalizePluginNames = exports.normalizePluginNames = function normalizePluginNames(plugins) {
+  return plugins.map(normalizePluginName);
+};
+
+var checkDuplicateIncludeExcludes = exports.checkDuplicateIncludeExcludes = function checkDuplicateIncludeExcludes() {
+  var include = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var exclude = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  var duplicates = include.filter(function (opt) {
+    return exclude.indexOf(opt) >= 0;
+  });
+
+  (0, _invariant2.default)(duplicates.length === 0, "Invalid Option: The plugins/built-ins '" + duplicates + "' were found in both the \"include\" and\n    \"exclude\" options.");
+};
+
+var validateBoolOption = exports.validateBoolOption = function validateBoolOption(name, value, defaultValue) {
+  if (typeof value === "undefined") {
+    value = defaultValue;
+  }
+
+  if (typeof value !== "boolean") {
+    throw new Error("Preset env: '" + name + "' option must be a boolean.");
+  }
+
+  return value;
+};
+
+var validateLooseOption = exports.validateLooseOption = function validateLooseOption(looseOpt) {
+  return validateBoolOption("loose", looseOpt, false);
+};
+var validateSpecOption = exports.validateSpecOption = function validateSpecOption(specOpt) {
+  return validateBoolOption("spec", specOpt, false);
+};
+
+var validateModulesOption = exports.validateModulesOption = function validateModulesOption() {
+  var modulesOpt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "commonjs";
+
+  (0, _invariant2.default)(modulesOpt === false || Object.keys(_moduleTransformations2.default).indexOf(modulesOpt) > -1, "Invalid Option: The 'modules' option must be either 'false' to indicate no modules, or a\n    module type which can be be one of: 'commonjs' (default), 'amd', 'umd', 'systemjs'.");
+
+  return modulesOpt;
+};
+
+function normalizeOptions(opts) {
+  // TODO: remove whitelist in favor of include in next major
+  if (opts.whitelist && !hasBeenWarned) {
+    console.warn("Deprecation Warning: The \"whitelist\" option has been deprecated in favor of \"include\" to\n      match the newly added \"exclude\" option (instead of \"blacklist\").");
+    hasBeenWarned = true;
+  }
+
+  (0, _invariant2.default)(!(opts.whitelist && opts.include), "Invalid Option: The \"whitelist\" and the \"include\" option are the same and one can be used at\n    a time");
+
+  if (opts.exclude) {
+    opts.exclude = normalizePluginNames(opts.exclude);
+  }
+
+  if (opts.whitelist || opts.include) {
+    opts.include = normalizePluginNames(opts.whitelist || opts.include);
+  }
+
+  checkDuplicateIncludeExcludes(opts.include, opts.exclude);
+
+  return {
+    debug: opts.debug,
+    exclude: validateIncludesAndExcludes(opts.exclude, "exclude"),
+    include: validateIncludesAndExcludes(opts.include, "include"),
+    loose: validateLooseOption(opts.loose),
+    moduleType: validateModulesOption(opts.modules),
+    spec: validateSpecOption(opts.spec),
+    targets: opts.targets,
+    useBuiltIns: opts.useBuiltIns
+  };
+}

torrent-project/node_modules/babel-preset-env/lib/targets-parser.js

@@ -0,0 +1,139 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _browserslist = require("browserslist");
+
+var _browserslist2 = _interopRequireDefault(_browserslist);
+
+var _semver = require("semver");
+
+var _semver2 = _interopRequireDefault(_semver);
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var browserNameMap = {
+  android: "android",
+  chrome: "chrome",
+  and_chr: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  ie: "ie",
+  ios_saf: "ios",
+  safari: "safari"
+};
+
+var isBrowsersQueryValid = function isBrowsersQueryValid(browsers) {
+  return typeof browsers === "string" || Array.isArray(browsers);
+};
+
+var semverMin = function semverMin(first, second) {
+  return first && _semver2.default.lt(first, second) ? first : second;
+};
+
+var getLowestVersions = function getLowestVersions(browsers) {
+  return browsers.reduce(function (all, browser) {
+    var _browser$split = browser.split(" "),
+        browserName = _browser$split[0],
+        browserVersion = _browser$split[1];
+
+    var normalizedBrowserName = browserNameMap[browserName];
+
+    if (!normalizedBrowserName) {
+      return all;
+    }
+
+    try {
+      // Browser version can return as "10.0-10.2"
+      var splitVersion = browserVersion.split("-")[0];
+      var parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
+
+      all[normalizedBrowserName] = semverMin(all[normalizedBrowserName], parsedBrowserVersion);
+    } catch (e) {}
+
+    return all;
+  }, {});
+};
+
+var outputDecimalWarning = function outputDecimalWarning(decimalTargets) {
+  if (!decimalTargets || !decimalTargets.length) {
+    return;
+  }
+
+  console.log("Warning, the following targets are using a decimal version:");
+  console.log("");
+  decimalTargets.forEach(function (_ref) {
+    var target = _ref.target,
+        value = _ref.value;
+    return console.log("  " + target + ": " + value);
+  });
+  console.log("");
+  console.log("We recommend using a string for minor/patch versions to avoid numbers like 6.10");
+  console.log("getting parsed as 6.1, which can lead to unexpected behavior.");
+  console.log("");
+};
+
+var targetParserMap = {
+  __default: function __default(target, value) {
+    return [target, (0, _utils.semverify)(value)];
+  },
+
+  // Parse `node: true` and `node: "current"` to version
+  node: function node(target, value) {
+    var parsed = value === true || value === "current" ? process.versions.node : (0, _utils.semverify)(value);
+
+    return [target, parsed];
+  },
+
+  // Only valid value for Uglify is `true`
+  uglify: function uglify(target, value) {
+    return [target, value === true];
+  }
+};
+
+var getTargets = function getTargets() {
+  var targets = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var targetOpts = {};
+
+  // Parse browsers target via browserslist
+  if (isBrowsersQueryValid(targets.browsers)) {
+    targetOpts = getLowestVersions((0, _browserslist2.default)(targets.browsers));
+  }
+
+  // Parse remaining targets
+  var parsed = Object.keys(targets).reduce(function (results, target) {
+    if (target !== "browsers") {
+      var value = targets[target];
+
+      // Warn when specifying minor/patch as a decimal
+      if (typeof value === "number" && value % 1 !== 0) {
+        results.decimalWarnings.push({ target: target, value: value });
+      }
+
+      // Check if we have a target parser?
+      var parser = targetParserMap[target] || targetParserMap.__default;
+
+      var _parser = parser(target, value),
+          parsedTarget = _parser[0],
+          parsedValue = _parser[1];
+
+      if (parsedValue) {
+        results.targets[parsedTarget] = parsedValue;
+      }
+    }
+
+    return results;
+  }, {
+    targets: targetOpts,
+    decimalWarnings: []
+  });
+
+  outputDecimalWarning(parsed.decimalWarnings);
+
+  return parsed.targets;
+};
+
+exports.default = getTargets;

torrent-project/node_modules/babel-preset-env/lib/transform-polyfill-require-plugin.js

@@ -0,0 +1,87 @@
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function (_ref) {
+  var t = _ref.types;
+
+  function createImportDeclaration(polyfill) {
+    var declar = t.importDeclaration([], t.stringLiteral(polyfill));
+    declar._blockHoist = 3;
+    return declar;
+  }
+
+  function createRequireStatement(polyfill) {
+    return t.expressionStatement(t.callExpression(t.identifier("require"), [t.stringLiteral(polyfill)]));
+  }
+
+  function isRequire(path) {
+    return t.isExpressionStatement(path.node) && t.isCallExpression(path.node.expression) && t.isIdentifier(path.node.expression.callee) && path.node.expression.callee.name === "require" && path.node.expression.arguments.length === 1 && t.isStringLiteral(path.node.expression.arguments[0]) && isPolyfillSource(path.node.expression.arguments[0].value);
+  }
+
+  function createImport(polyfill, requireType, core) {
+    if (core) {
+      polyfill = "core-js/modules/" + polyfill;
+    }
+
+    if (requireType === "import") {
+      return createImportDeclaration(polyfill);
+    } else {
+      return createRequireStatement(polyfill);
+    }
+  }
+
+  function createImports(polyfills, requireType, regenerator) {
+    var imports = polyfills.filter(function (el, i, arr) {
+      return arr.indexOf(el) === i;
+    }).map(function (polyfill) {
+      return createImport(polyfill, requireType, true);
+    });
+
+    return [].concat(imports, [regenerator && createImport("regenerator-runtime/runtime", requireType)]).filter(Boolean);
+  }
+
+  var isPolyfillImport = {
+    ImportDeclaration: function ImportDeclaration(path, state) {
+      if (path.node.specifiers.length === 0 && isPolyfillSource(path.node.source.value)) {
+        this.numPolyfillImports++;
+        if (this.numPolyfillImports > 1) {
+          path.remove();
+          return;
+        }
+
+        path.replaceWithMultiple(createImports(state.opts.polyfills, "import", state.opts.regenerator));
+      }
+    },
+    Program: function Program(path, state) {
+      var _this = this;
+
+      if (!state.opts.polyfills) {
+        throw path.buildCodeFrameError("\nThere was an issue in \"babel-preset-env\" such that\nthe \"polyfills\" option was not correctly passed\nto the \"transform-polyfill-require\" plugin\n");
+      }
+      path.get("body").forEach(function (bodyPath) {
+        if (isRequire(bodyPath)) {
+          _this.numPolyfillImports++;
+          if (_this.numPolyfillImports > 1) {
+            path.remove();
+            return;
+          }
+
+          bodyPath.replaceWithMultiple(createImports(state.opts.polyfills, "require", state.opts.regenerator));
+        }
+      });
+    }
+  };
+
+  return {
+    name: "transform-polyfill-require",
+    visitor: isPolyfillImport,
+    pre: function pre() {
+      this.numPolyfillImports = 0;
+    }
+  };
+};
+
+function isPolyfillSource(value) {
+  return value === "babel-polyfill" || value === "core-js";
+}

torrent-project/node_modules/babel-preset-env/lib/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+exports.prettifyTargets = exports.prettifyVersion = exports.semverify = exports._extends = undefined;
+
+var _semver = require("semver");
+
+var _semver2 = _interopRequireDefault(_semver);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _extends = exports._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;
+};
+
+// Convert version to a semver value.
+// 2.5 -> 2.5.0; 1 -> 1.0.0;
+// @flow
+var semverify = exports.semverify = function semverify(version) {
+  if (typeof version === "string" && _semver2.default.valid(version)) {
+    return version;
+  }
+
+  var split = version.toString().split(".");
+
+  while (split.length < 3) {
+    split.push(0);
+  }
+
+  return split.join(".");
+};
+
+var prettifyVersion = exports.prettifyVersion = function prettifyVersion(version) {
+  if (typeof version !== "string") {
+    return version;
+  }
+
+  var parts = [_semver2.default.major(version)];
+  var minor = _semver2.default.minor(version);
+  var patch = _semver2.default.patch(version);
+
+  if (minor || patch) {
+    parts.push(minor);
+  }
+
+  if (patch) {
+    parts.push(patch);
+  }
+
+  return parts.join(".");
+};
+
+var prettifyTargets = exports.prettifyTargets = function prettifyTargets() {
+  var targets = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  return Object.keys(targets).reduce(function (results, target) {
+    var value = targets[target];
+
+    if (typeof value === "string") {
+      value = prettifyVersion(value);
+    }
+
+    results[target] = value;
+    return results;
+  }, {});
+};