jasmine-core 4.6.0 → 5.0.0-alpha.0

package/README.md

@@ -32,10 +32,10 @@ Microsoft Edge) as well as Node.
 
 | Environment       | Supported versions |
 |-------------------|--------------------|
-| Node              | 12.17+, 14, 16, 18 |
-| Safari            | 14-16              |
+| Node              | 16.14-16.19, 18    |
+| Safari            | 15-16              |
 | Chrome            | Evergreen          |
-| Firefox           | Evergreen, 91, 102 |
+| Firefox           | Evergreen, 102     |
 | Edge              | Evergreen          |
 
 For evergreen browsers, each version of Jasmine is tested against the version of the browser that is available to us

package/lib/jasmine-core/jasmine.js

@@ -1181,6 +1181,7 @@ getJasmineRequireObj().Env = function(j$) {
     let reporter;
     let topSuite;
     let runner;
+    let parallelLoadingState = null; // 'specs', 'helpers', or null for non-parallel
 
     /**
      * This represents the available options to configure Jasmine.
@@ -1209,6 +1210,10 @@ getJasmineRequireObj().Env = function(j$) {
       seed: null,
       /**
        * Whether to stop execution of the suite after the first spec failure
+       *
+       * <p>In parallel mode, `stopOnSpecFailure` works on a "best effort"
+       * basis. Jasmine will stop execution as soon as practical after a failure
+       * but it might not be immediate.</p>
        * @name Configuration#stopOnSpecFailure
        * @since 3.9.0
        * @type Boolean
@@ -1284,20 +1289,14 @@ getJasmineRequireObj().Env = function(j$) {
 
     if (!options.suppressLoadErrors) {
       installGlobalErrors();
-      globalErrors.pushListener(function loadtimeErrorHandler(
-        message,
-        filename,
-        lineno,
-        colNo,
-        err
-      ) {
+      globalErrors.pushListener(function loadtimeErrorHandler(error, event) {
         topSuite.result.failedExpectations.push({
           passed: false,
           globalErrorType: 'load',
-          message: message,
-          stack: err && err.stack,
-          filename: filename,
-          lineno: lineno
+          message: error ? error.message : event.message,
+          stack: error && error.stack,
+          filename: event && event.filename,
+          lineno: event && event.lineno
         });
       });
     }
@@ -1515,7 +1514,6 @@ getJasmineRequireObj().Env = function(j$) {
         function(e) {
           (runner.currentRunable() || topSuite).handleException(e);
         };
-      options.deprecated = self.deprecated;
 
       new j$.QueueRunner(options).execute();
     }
@@ -1541,6 +1539,7 @@ getJasmineRequireObj().Env = function(j$) {
      * @since 2.0.0
      */
     this.topSuite = function() {
+      ensureNonParallel('topSuite');
       return topSuite.metadata;
     };
 
@@ -1634,21 +1633,25 @@ getJasmineRequireObj().Env = function(j$) {
       reportSpecDone
     });
 
+    this.setParallelLoadingState = function(state) {
+      parallelLoadingState = state;
+    };
+
+    this.parallelReset = function() {
+      // TODO: ensure that autoCleanClosures was false
+      suiteBuilder.parallelReset();
+      runner.parallelReset();
+    };
+
     /**
      * Executes the specs.
      *
-     * If called with no parameters or with a falsy value as the first parameter,
+     * If called with no parameter or with a falsy parameter,
      * all specs will be executed except those that are excluded by a
      * [spec filter]{@link Configuration#specFilter} or other mechanism. If the
-     * first parameter is a list of spec/suite IDs, only those specs/suites will
+     * parameter is a list of spec/suite IDs, only those specs/suites will
      * be run.
      *
-     * Both parameters are optional, but a completion callback is only valid as
-     * the second parameter. To specify a completion callback but not a list of
-     * specs/suites to run, pass null or undefined as the first parameter. The
-     * completion callback is supported for backward compatibility. In most
-     * cases it will be more convenient to use the returned promise instead.
-     *
      * execute should not be called more than once unless the env has been
      * configured with `{autoCleanClosures: false}`.
      *
@@ -1656,25 +1659,26 @@ getJasmineRequireObj().Env = function(j$) {
      * {@link JasmineDoneInfo|overall result} that's passed to a reporter's
      * `jasmineDone` method, even if the suite did not pass. To determine
      * whether the suite passed, check the value that the promise resolves to
-     * or use a {@link Reporter}.
+     * or use a {@link Reporter}. The promise will be rejected in the case of
+     * certain serious errors that prevent execution from starting.
      *
      * @name Env#execute
      * @since 2.0.0
      * @function
+     * @async
      * @param {(string[])=} runablesToRun IDs of suites and/or specs to run
-     * @param {Function=} onComplete Function that will be called after all specs have run
      * @return {Promise<JasmineDoneInfo>}
      */
-    this.execute = function(runablesToRun, onComplete) {
+    this.execute = async function(runablesToRun) {
       installGlobalErrors();
 
-      return runner.execute(runablesToRun).then(function(jasmineDoneInfo) {
-        if (onComplete) {
-          onComplete();
-        }
+      if (parallelLoadingState) {
+        validateConfigForParallel();
+      }
 
-        return jasmineDoneInfo;
-      });
+      const result = await runner.execute(runablesToRun);
+      this.cleanup_();
+      return result;
     };
 
     /**
@@ -1686,6 +1690,10 @@ getJasmineRequireObj().Env = function(j$) {
      * @see custom_reporter
      */
     this.addReporter = function(reporterToAdd) {
+      if (parallelLoadingState) {
+        throw new Error('Reporters cannot be added via Env in parallel mode');
+      }
+
       reporter.addReporter(reporterToAdd);
     };
 
@@ -1708,6 +1716,10 @@ getJasmineRequireObj().Env = function(j$) {
      * @function
      */
     this.clearReporters = function() {
+      if (parallelLoadingState) {
+        throw new Error('Reporters cannot be removed via Env in parallel mode');
+      }
+
       reporter.clearReporters();
     };
 
@@ -1807,6 +1819,38 @@ getJasmineRequireObj().Env = function(j$) {
       }
     }
 
+    function ensureNonParallel(method) {
+      if (parallelLoadingState) {
+        throw new Error(`'${method}' is not available in parallel mode`);
+      }
+    }
+
+    function ensureNonParallelOrInDescribe(msg) {
+      if (parallelLoadingState && !suiteBuilder.inDescribe()) {
+        throw new Error(msg);
+      }
+    }
+
+    function ensureNonParallelOrInHelperOrInDescribe(method) {
+      if (parallelLoadingState === 'specs' && !suiteBuilder.inDescribe()) {
+        throw new Error(
+          'In parallel mode, ' +
+            method +
+            ' must be in a describe block or in a helper file'
+        );
+      }
+    }
+
+    function validateConfigForParallel() {
+      if (!config.random) {
+        throw new Error('Randomization cannot be disabled in parallel mode');
+      }
+
+      if (config.seed !== null && config.seed !== undefined) {
+        throw new Error('Random seed cannot be set in parallel mode');
+      }
+    }
+
     this.describe = function(description, definitionFn) {
       ensureIsNotNested('describe');
       const filename = callerCallerFilename();
@@ -1823,6 +1867,7 @@ getJasmineRequireObj().Env = function(j$) {
 
     this.fdescribe = function(description, definitionFn) {
       ensureIsNotNested('fdescribe');
+      ensureNonParallel('fdescribe');
       const filename = callerCallerFilename();
       return suiteBuilder.fdescribe(description, definitionFn, filename)
         .metadata;
@@ -1864,6 +1909,7 @@ getJasmineRequireObj().Env = function(j$) {
 
     this.fit = function(description, fn, timeout) {
       ensureIsNotNested('fit');
+      ensureNonParallel('fit');
       const filename = callerCallerFilename();
       return suiteBuilder.fit(description, fn, timeout, filename).metadata;
     };
@@ -1937,21 +1983,37 @@ getJasmineRequireObj().Env = function(j$) {
 
     this.beforeEach = function(beforeEachFunction, timeout) {
       ensureIsNotNested('beforeEach');
+      ensureNonParallelOrInHelperOrInDescribe('beforeEach');
       suiteBuilder.beforeEach(beforeEachFunction, timeout);
     };
 
     this.beforeAll = function(beforeAllFunction, timeout) {
       ensureIsNotNested('beforeAll');
+      // This message is -npm-specific, but currently parallel operation is
+      // only supported via -npm.
+      ensureNonParallelOrInDescribe(
+        "In parallel mode, 'beforeAll' " +
+          'must be in a describe block. Use the globalSetup config ' +
+          'property for exactly-once setup in parallel mode.'
+      );
       suiteBuilder.beforeAll(beforeAllFunction, timeout);
     };
 
     this.afterEach = function(afterEachFunction, timeout) {
       ensureIsNotNested('afterEach');
+      ensureNonParallelOrInHelperOrInDescribe('afterEach');
       suiteBuilder.afterEach(afterEachFunction, timeout);
     };
 
     this.afterAll = function(afterAllFunction, timeout) {
       ensureIsNotNested('afterAll');
+      // This message is -npm-specific, but currently parallel operation is
+      // only supported via -npm.
+      ensureNonParallelOrInDescribe(
+        "In parallel mode, 'afterAll' " +
+          'must be in a describe block. Use the globalTeardown config ' +
+          'property for exactly-once teardown in parallel mode.'
+      );
       suiteBuilder.afterAll(afterAllFunction, timeout);
     };
 
@@ -2006,7 +2068,10 @@ getJasmineRequireObj().Env = function(j$) {
   }
 
   function callerCallerFilename() {
-    return new j$.StackTrace(new Error()).frames[3].file;
+    const frames = new j$.StackTrace(new Error()).frames;
+    // frames[3] should always exist except in Jasmine's own tests, which bypass
+    // the global it/describe layer, but don't crash if it doesn't.
+    return frames[3] && frames[3].file;
   }
 
   return Env;
@@ -4005,18 +4070,22 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
     let overrideHandler = null,
       onRemoveOverrideHandler = null;
 
-    function onerror(message, source, lineno, colno, error) {
+    function onBrowserError(event) {
+      dispatchBrowserError(event.error, event);
+    }
+
+    function dispatchBrowserError(error, event) {
       if (overrideHandler) {
-        overrideHandler(error || message);
+        overrideHandler(error);
         return;
       }
 
       const handler = handlers[handlers.length - 1];
 
       if (handler) {
-        handler.apply(null, Array.prototype.slice.call(arguments, 0));
+        handler(error, event);
       } else {
-        throw arguments[0];
+        throw error;
       }
     }
 
@@ -4093,8 +4162,7 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
         this.installOne_('uncaughtException', 'Uncaught exception');
         this.installOne_('unhandledRejection', 'Unhandled promise rejection');
       } else {
-        const originalHandler = global.onerror;
-        global.onerror = onerror;
+        global.addEventListener('error', onBrowserError);
 
         const browserRejectionHandler = function browserRejectionHandler(
           event
@@ -4102,16 +4170,19 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
           if (j$.isError_(event.reason)) {
             event.reason.jasmineMessage =
               'Unhandled promise rejection: ' + event.reason;
-            global.onerror(event.reason);
+            dispatchBrowserError(event.reason, event);
           } else {
-            global.onerror('Unhandled promise rejection: ' + event.reason);
+            dispatchBrowserError(
+              'Unhandled promise rejection: ' + event.reason,
+              event
+            );
           }
         };
 
         global.addEventListener('unhandledrejection', browserRejectionHandler);
 
         this.uninstall = function uninstall() {
-          global.onerror = originalHandler;
+          global.removeEventListener('error', onBrowserError);
           global.removeEventListener(
             'unhandledrejection',
             browserRejectionHandler
@@ -4120,6 +4191,13 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
       }
     };
 
+    // The listener at the top of the stack will be called with two arguments:
+    // the error and the event. Either of them may be falsy.
+    // The error will normally be provided, but will be falsy in the case of
+    // some browser load-time errors. The event will normally be provided in
+    // browsers but will be falsy in Node.
+    // Listeners that are pushed after spec files have been loaded should be
+    // able to just use the error parameter.
     this.pushListener = function pushListener(listener) {
       handlers.push(listener);
     };
@@ -7450,6 +7528,15 @@ getJasmineRequireObj().makePrettyPrinter = function(j$) {
 };
 
 getJasmineRequireObj().QueueRunner = function(j$) {
+  /*
+    QueueRunner isn't part of the public interface, but it is used by
+    jasmine-npm. -core and -npm version in lockstep at the major and minor
+    levels but version independently at the patch level. Any changes that
+    would break -npm should be done in a major or minor release, never a
+    patch release, and accompanied by a change to -npm that's released in
+    the same version.
+   */
+
   let nextid = 1;
 
   function StopExecutionError() {}
@@ -7513,15 +7600,11 @@ getJasmineRequireObj().QueueRunner = function(j$) {
     if (typeof this.onComplete !== 'function') {
       throw new Error('invalid onComplete ' + JSON.stringify(this.onComplete));
     }
-    this.deprecated = attrs.deprecated;
   }
 
   QueueRunner.prototype.execute = function() {
-    this.handleFinalError = (message, source, lineno, colno, error) => {
-      // Older browsers would send the error as the first parameter. HTML5
-      // specifies the the five parameters above. The error instance should
-      // be preffered, otherwise the call stack would get lost.
-      this.onException(error || message);
+    this.handleFinalError = error => {
+      this.onException(error);
     };
     this.globalErrors.pushListener(this.handleFinalError);
     this.run(0);
@@ -7740,6 +7823,15 @@ getJasmineRequireObj().QueueRunner = function(j$) {
 };
 
 getJasmineRequireObj().ReportDispatcher = function(j$) {
+  /*
+    ReportDispatcher isn't part of the public interface, but it is used by
+    jasmine-npm. -core and -npm version in lockstep at the major and minor
+    levels but version independently at the patch level. Any changes that
+    would break -npm should be done in a major or minor release, never a
+    patch release, and accompanied by a change to -npm that's released in
+    the same version.
+   */
+
   function ReportDispatcher(methods, queueRunnerFactory, onLateError) {
     const dispatchedMethods = methods || [];
 
@@ -8411,6 +8503,7 @@ getJasmineRequireObj().Runner = function(j$) {
   class Runner {
     constructor(options) {
       this.topSuite_ = options.topSuite;
+      // TODO use names that read like getters
       this.totalSpecsDefined_ = options.totalSpecsDefined;
       this.focusedRunables_ = options.focusedRunables;
       this.runableResources_ = options.runableResources;
@@ -8435,11 +8528,11 @@ getJasmineRequireObj().Runner = function(j$) {
       ];
     }
 
-    // Although execute returns a promise, it isn't async for backwards
-    // compatibility: The "Invalid order" exception needs to be propagated
-    // synchronously from Env#execute.
-    // TODO: make this and Env#execute async in the next major release
-    execute(runablesToRun) {
+    parallelReset() {
+      this.executedBefore_ = false;
+    }
+
+    async execute(runablesToRun) {
       if (this.executedBefore_) {
         this.topSuite_.reset();
       }
@@ -8535,13 +8628,17 @@ getJasmineRequireObj().Runner = function(j$) {
       /**
        * Information passed to the {@link Reporter#jasmineStarted} event.
        * @typedef JasmineStartedInfo
-       * @property {Int} totalSpecsDefined - The total number of specs defined in this suite.
-       * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.
+       * @property {Int} totalSpecsDefined - The total number of specs defined in this suite. Note that this property is not present when Jasmine is run in parallel mode.
+       * @property {Order} order - Information about the ordering (random or not) of this execution of the suite. Note that this property is not present when Jasmine is run in parallel mode.
+       * @property {Boolean} parallel - Whether Jasmine is being run in parallel mode.
        * @since 2.0.0
        */
       await this.reporter_.jasmineStarted({
+        // In parallel mode, the jasmineStarted event is separately dispatched
+        // by jasmine-npm. This event only reaches reporters in non-parallel.
         totalSpecsDefined,
-        order: order
+        order: order,
+        parallel: false
       });
 
       this.currentlyExecutingSuites_.push(this.topSuite_);
@@ -8553,7 +8650,7 @@ getJasmineRequireObj().Runner = function(j$) {
 
       this.runableResources_.clearForRunable(this.topSuite_.id);
       this.currentlyExecutingSuites_.pop();
-      let overallStatus, incompleteReason;
+      let overallStatus, incompleteReason, incompleteCode;
 
       if (
         this.hasFailures ||
@@ -8563,9 +8660,11 @@ getJasmineRequireObj().Runner = function(j$) {
       } else if (this.focusedRunables_().length > 0) {
         overallStatus = 'incomplete';
         incompleteReason = 'fit() or fdescribe() was found';
+        incompleteCode = 'focused';
       } else if (totalSpecsDefined === 0) {
         overallStatus = 'incomplete';
         incompleteReason = 'No specs found';
+        incompleteCode = 'noSpecsFound';
       } else {
         overallStatus = 'passed';
       }
@@ -8575,8 +8674,10 @@ getJasmineRequireObj().Runner = function(j$) {
        * @typedef JasmineDoneInfo
        * @property {OverallStatus} overallStatus - The overall result of the suite: 'passed', 'failed', or 'incomplete'.
        * @property {Int} totalTime - The total time (in ms) that it took to execute the suite
-       * @property {IncompleteReason} incompleteReason - Explanation of why the suite was incomplete.
-       * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.
+       * @property {String} incompleteReason - Human-readable explanation of why the suite was incomplete.
+       * @property {String} incompleteCode - Machine-readable explanation of why the suite was incomplete: 'focused', 'noSpecsFound', or undefined.
+       * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.  Note that this property is not present when Jasmine is run in parallel mode.
+       * @property {Int} numWorkers - Number of parallel workers.  Note that this property is only present when Jasmine is run in parallel mode.
        * @property {Expectation[]} failedExpectations - List of expectations that failed in an {@link afterAll} at the global level.
        * @property {Expectation[]} deprecationWarnings - List of deprecation warnings that occurred at the global level.
        * @since 2.4.0
@@ -8585,6 +8686,7 @@ getJasmineRequireObj().Runner = function(j$) {
         overallStatus: overallStatus,
         totalTime: jasmineTimer.elapsed(),
         incompleteReason: incompleteReason,
+        incompleteCode: incompleteCode,
         order: order,
         failedExpectations: this.topSuite_.result.failedExpectations,
         deprecationWarnings: this.topSuite_.result.deprecationWarnings
@@ -9670,6 +9772,10 @@ getJasmineRequireObj().Suite = function(j$) {
     this.reportedDone = false;
   };
 
+  Suite.prototype.removeChildren = function() {
+    this.children = [];
+  };
+
   Suite.prototype.addChild = function(child) {
     this.children.push(child);
   };
@@ -9885,6 +9991,17 @@ getJasmineRequireObj().SuiteBuilder = function(j$) {
       this.focusedRunables = [];
     }
 
+    inDescribe() {
+      return this.currentDeclarationSuite_ !== this.topSuite;
+    }
+
+    parallelReset() {
+      this.topSuite.removeChildren();
+      this.topSuite.reset();
+      this.totalSpecsDefined = 0;
+      this.focusedRunables = [];
+    }
+
     describe(description, definitionFn, filename) {
       ensureIsFunction(definitionFn, 'describe');
       const suite = this.suiteFactory_(description, filename);
@@ -10176,6 +10293,15 @@ getJasmineRequireObj().SuiteBuilder = function(j$) {
 };
 
 getJasmineRequireObj().Timer = function() {
+  /*
+    Timer isn't part of the public interface, but it is used by
+    jasmine-npm. -core and -npm version in lockstep at the major and minor
+    levels but version independently at the patch level. Any changes that
+    would break -npm should be done in a major or minor release, never a
+    patch release, and accompanied by a change to -npm that's released in
+    the same version.
+   */
+
   const defaultNow = (function(Date) {
     return function() {
       return new Date().getTime();
@@ -10484,5 +10610,5 @@ getJasmineRequireObj().UserContext = function(j$) {
 };
 
 getJasmineRequireObj().version = function() {
-  return '4.6.0';
+  return '5.0.0-alpha.0';
 };

package/lib/jasmine-core.js

@@ -6,36 +6,48 @@
 const jasmineRequire = require('./jasmine-core/jasmine.js');
 module.exports = jasmineRequire;
 
+const bootOnce = (function() {
+  let jasmine, jasmineInterface;
+
+  return function bootWithoutGlobals() {
+    if (!jasmineInterface) {
+      jasmine = jasmineRequire.core(jasmineRequire);
+      const env = jasmine.getEnv({ suppressLoadErrors: true });
+      jasmineInterface = jasmineRequire.interface(jasmine, env);
+    }
+
+    return {jasmine, jasmineInterface};
+  };
+}());
+
 /**
  * Boots a copy of Jasmine and returns an object as described in {@link jasmine}.
+ * If boot is called multiple times, the same object is returned every time.
  * @type {function}
  * @return {jasmine}
  */
-module.exports.boot = require('./jasmine-core/node_boot.js');
+module.exports.boot = function() {
+  const {jasmine, jasmineInterface} = bootOnce();
+
+  for (const k in jasmineInterface) {
+    global[k] = jasmineInterface[k];
+  }
+
+  return jasmine;
+};
 
 /**
  * Boots a copy of Jasmine and returns an object containing the properties
  * that would normally be added to the global object. If noGlobals is called
  * multiple times, the same object is returned every time.
  *
- * Do not call boot() if you also call noGlobals().
- *
  * @example
  * const {describe, beforeEach, it, expect, jasmine} = require('jasmine-core').noGlobals();
  */
-module.exports.noGlobals = (function() {
-  let jasmineInterface;
-
-  return function bootWithoutGlobals() {
-    if (!jasmineInterface) {
-      const jasmine = jasmineRequire.core(jasmineRequire);
-      const env = jasmine.getEnv({ suppressLoadErrors: true });
-      jasmineInterface = jasmineRequire.interface(jasmine, env);
-    }
-
-    return jasmineInterface;
-  };
-}());
+module.exports.noGlobals = function() {
+  const {jasmineInterface} = bootOnce();
+  return jasmineInterface;
+};
 
 const path = require('path'),
   fs = require('fs');
@@ -43,10 +55,9 @@ const path = require('path'),
 const rootPath = path.join(__dirname, 'jasmine-core'),
   bootFiles = ['boot0.js', 'boot1.js'],
   legacyBootFiles = ['boot.js'],
-  nodeBootFiles = ['node_boot.js'],
   cssFiles = [],
   jsFiles = [],
-  jsFilesToSkip = ['jasmine.js'].concat(bootFiles, legacyBootFiles, nodeBootFiles);
+  jsFilesToSkip = ['jasmine.js'].concat(bootFiles, legacyBootFiles);
 
 fs.readdirSync(rootPath).forEach(function(file) {
   if(fs.statSync(path.join(rootPath, file)).isFile()) {
@@ -56,18 +67,18 @@ fs.readdirSync(rootPath).forEach(function(file) {
       break;
       case '.js':
         if (jsFilesToSkip.indexOf(file) < 0) {
-        jsFiles.push(file);
-      }
+          jsFiles.push(file);
+        }
       break;
     }
   }
 });
 
 module.exports.files = {
+  self: __filename,
   path: rootPath,
   bootDir: rootPath,
   bootFiles: bootFiles,
-  nodeBootFiles: nodeBootFiles,
   cssFiles: cssFiles,
   jsFiles: ['jasmine.js'].concat(jsFiles),
   imagesDir: path.join(__dirname, '../images')

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "4.6.0",
+  "version": "5.0.0-alpha.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -43,7 +43,7 @@
     "grunt-contrib-concat": "^2.0.0",
     "grunt-css-url-embed": "^1.11.1",
     "grunt-sass": "^3.0.2",
-    "jasmine": "^4.1.0",
+    "jasmine": "github:jasmine/jasmine-npm#5.0",
     "jasmine-browser-runner": "^1.0.0",
     "jsdom": "^19.0.0",
     "load-grunt-tasks": "^5.1.0",
@@ -101,10 +101,9 @@
     }
   },
   "browserslist": [
-    "Safari >= 14",
+    "Safari >= 15",
+    "Firefox >= 102",
     "last 2 Chrome versions",
-    "last 2 Firefox versions",
-    "Firefox >= 91",
     "last 2 Edge versions"
   ]
 }

package/lib/jasmine-core/node_boot.js

@@ -1,38 +0,0 @@
-/*
-Copyright (c) 2008-2023 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.
-*/
-module.exports = function(jasmineRequire) {
-  const jasmine = jasmineRequire.core(jasmineRequire);
-
-  const env = jasmine.getEnv({ suppressLoadErrors: true });
-
-  const jasmineInterface = jasmineRequire.interface(jasmine, env);
-
-  extend(global, jasmineInterface);
-
-  function extend(destination, source) {
-    for (const property in source) destination[property] = source[property];
-    return destination;
-  }
-
-  return jasmine;
-};