Added logging, changed some directory structure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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