docs/static/kute-page_files/app.e653d17f57bebeb097ee.js
function race$1(entries) {
  /*jshint validthis:true */
  var Constructor = this;

  if (!isArray(entries)) {
    return new Constructor(function (_, reject) {
      return reject(new TypeError('You must pass an array to race.'));
    });
  } else {
    return new Constructor(function (resolve, reject) {
      var length = entries.length;
      for (var i = 0; i < length; i++) {
        Constructor.resolve(entries[i]).then(resolve, reject);
      }
    });
  }
}
function race$1(entries) {
  /*jshint validthis:true */
  var Constructor = this;

  if (!isArray(entries)) {
    return new Constructor(function (_, reject) {
      return reject(new TypeError('You must pass an array to race.'));
    });
  } else {
    return new Constructor(function (resolve, reject) {
      var length = entries.length;
      for (var i = 0; i < length; i++) {
        Constructor.resolve(entries[i]).then(resolve, reject);
      }
    });
  }
}
function race$1 ( entries ) { /*jshint validthis:true */ var Constructor = this ; if ( ! isArray ( entries ) ) { return new Constructor ( function ( _ , reject ) { return reject ( new TypeError ( 'You must pass an array to race.' ) ) ; } ) ; } else { return new Constructor ( function ( resolve , reject ) { var length = entries . length ; for ( var i = 0 ; i < length ; i ++ ) { Constructor . resolve ( entries [ i ] ) . then ( resolve , reject ) ; } } ) ; } }
`Promise.race` returns a new promise which is settled in the same way as the
first passed promise to settle.

Example:

```javascript
let promise1 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 1');
}, 200);
});

let promise2 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 2');
}, 100);
});

Promise.race([promise1, promise2]).then(function(result){
result === 'promise 2' because it was resolved before promise1
was resolved.
});
```

`Promise.race` is deterministic in that only the state of the first
settled promise matters. For example, even if other promises given to the
`promises` array argument are resolved, but the first settled promise has
become rejected before the other promises became fulfilled, the returned
promise will become rejected:

```javascript
let promise1 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 1');
}, 200);
});

let promise2 = new Promise(function(resolve, reject){
setTimeout(function(){
reject(new Error('promise 2'));
}, 100);
});

Promise.race([promise1, promise2]).then(function(result){
Code here never runs
}, function(reason){
reason.message === 'promise 2' because promise 2 became rejected before
promise 1 became fulfilled
});
```

An example real-world use case is implementing timeouts:

```javascript
Promise.race([ajax('foo.json'), timeout(5000)])
```

@method race
@static
@param {Array} promises array of promises to observe
Useful for tooling.
@return {Promise} a promise which settles in the same way as the first passed
promise to settle.
Promise . race returns a new promise which is settled in the same way as the first passed promise to settle .