prepack/lib/methods/promise.js

Execute a JS bundle, serialize global state and side effects to a snapshot that can be quickly restored.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.EnqueueJob = EnqueueJob;
exports.NewPromiseCapability = NewPromiseCapability;
exports.PerformPromiseAll = PerformPromiseAll;
exports.PerformPromiseRace = PerformPromiseRace;
exports.PerformPromiseThen = PerformPromiseThen;
exports.PromiseReactionJob = PromiseReactionJob;
exports.CreateResolvingFunctions = CreateResolvingFunctions;
exports.FulfillPromise = FulfillPromise;
exports.RejectPromise = RejectPromise;
exports.TriggerPromiseReactions = TriggerPromiseReactions;
exports.HostPromiseRejectionTracker = HostPromiseRejectionTracker;
exports.PromiseResolveThenableJob = PromiseResolveThenableJob;

var _completions = require("../completions.js");

var _index = require("../values/index.js");

var _abstract = require("./abstract.js");

var _construct = require("./construct.js");

var _get = require("./get.js");

var _call = require("./call.js");

var _is = require("./is.js");

var _iterator = require("./iterator.js");

var _singletons = require("../singletons.js");

var _invariant = _interopRequireDefault(require("../invariant.js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Copyright (c) 2017-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.
 */
// ECMA262 8.4.1
function EnqueueJob(realm, queueName, job, args) {} // ECMA262 25.4.1.5


function NewPromiseCapability(realm, C) {
  // 1. If IsConstructor(C) is false, throw a TypeError exception.
  if ((0, _is.IsConstructor)(realm, C) === false) {
    throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "IsConstructor(C) is false");
  }

  (0, _invariant.default)(C instanceof _index.ObjectValue); // 2. NOTE C is assumed to be a constructor function that supports the parameter conventions of the Promise constructor (see 25.4.3.1).
  // 3. Let promiseCapability be a new PromiseCapability { [[Promise]]: undefined, [[Resolve]]: undefined, [[Reject]]: undefined }.

  let promiseCapability = {
    promise: realm.intrinsics.undefined,
    resolve: realm.intrinsics.undefined,
    reject: realm.intrinsics.undefined
  }; // 4. Let executor be a new built-in function object as defined in GetCapabilitiesExecutor Functions (25.4.1.5.1).

  let executor = new _index.NativeFunctionValue(realm, undefined, undefined, 2, (context, [resolve, reject]) => {
    // 1. Assert: F has a [[Capability]] internal slot whose value is a PromiseCapability Record.
    (0, _invariant.default)(executor.$Capability, "F has a [[Capability]] internal slot whose value is a PromiseCapability Record"); // 2. Let promiseCapability be the value of F's [[Capability]] internal slot.

    (0, _invariant.default)(promiseCapability === executor.$Capability); // 3. If promiseCapability.[[Resolve]] is not undefined, throw a TypeError exception.

    if (!promiseCapability.resolve.mightBeUndefined()) {
      throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "promiseCapability.[[Resolve]] is not undefined");
    }

    promiseCapability.resolve.throwIfNotConcrete(); // 4. If promiseCapability.[[Reject]] is not undefined, throw a TypeError exception.

    if (!promiseCapability.reject.mightBeUndefined()) {
      throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "promiseCapability.[[Reject]] is not undefined");
    }

    promiseCapability.reject.throwIfNotConcrete(); // 5. Set promiseCapability.[[Resolve]] to resolve.

    promiseCapability.resolve = resolve; // 6. Set promiseCapability.[[Reject]] to reject.

    promiseCapability.reject = reject; // 7. Return undefined.

    return realm.intrinsics.undefined;
  }, false); // 5. Set the [[Capability]] internal slot of executor to promiseCapability.

  executor.$Capability = promiseCapability; // 6. Let promise be ? Construct(C, « executor »).

  let promise = (0, _construct.Construct)(realm, C, [executor]).throwIfNotConcreteObject(); // 7. If IsCallable(promiseCapability.[[Resolve]]) is false, throw a TypeError exception.

  if ((0, _is.IsCallable)(realm, promiseCapability.resolve) === false) {
    throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "IsCallable(promiseCapability.[[Resolve]]) is false");
  } // 8. If IsCallable(promiseCapability.[[Reject]]) is false, throw a TypeError exception.


  if ((0, _is.IsCallable)(realm, promiseCapability.reject) === false) {
    throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "IsCallable(promiseCapability.[[Reject]]) is false");
  } // 9. Set promiseCapability.[[Promise]] to promise.


  promiseCapability.promise = promise; // 10. Return promiseCapability.

  return promiseCapability;
} // ECMA262 25.4.4.1.1j


function createResolveElementFunction(realm) {
  let resolveElement = new _index.NativeFunctionValue(realm, undefined, undefined, 1, (context, [x]) => {
    // 1. Let alreadyCalled be the value of F's [[AlreadyCalled]] internal slot.
    let alreadyCalled = resolveElement.$AlreadyCalled;
    (0, _invariant.default)(alreadyCalled); // 2. If alreadyCalled.[[Value]] is true, return undefined.

    if (alreadyCalled.value === true) {
      return realm.intrinsics.undefined;
    } // 3. Set alreadyCalled.[[Value]] to true.


    alreadyCalled.value = true; // 4. Let index be the value of F's [[Index]] internal slot.

    let myIndex = resolveElement.$Index;
    (0, _invariant.default)(typeof myIndex === "number"); // 5. Let values be the value of F's [[Values]] internal slot.

    let values = resolveElement.$Values;
    (0, _invariant.default)(values instanceof Array); // 6. Let promiseCapability be the value of F's [[Capabilities]] internal slot.

    let promiseCapability = resolveElement.$Capabilities;
    (0, _invariant.default)(promiseCapability); // 7. Let remainingElementsCount be the value of F's [[RemainingElements]] internal slot.

    let remainingElementsCount = resolveElement.$RemainingElements;
    (0, _invariant.default)(remainingElementsCount); // 8. Set values[index] to x.

    values[myIndex] = x; // 9. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.

    remainingElementsCount.value = remainingElementsCount.value - 1; // 10. If remainingElementsCount.[[Value]] is 0, then

    if (remainingElementsCount.value === 0) {
      // a. Let valuesArray be CreateArrayFromList(values).
      let valuesArray = _singletons.Create.CreateArrayFromList(realm, values); // b. Return ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »).


      (0, _call.Call)(realm, promiseCapability.resolve, realm.intrinsics.undefined, [valuesArray]);
    } // 11. Return undefined.


    return realm.intrinsics.undefined;
  }, false);
  return resolveElement;
} // ECMA262 25.4.4.1.1


function PerformPromiseAll(realm, iteratorRecord, constructor, resultCapability) {
  // 1. Assert: constructor is a constructor function.
  (0, _invariant.default)(constructor instanceof _index.FunctionValue && (0, _is.IsConstructor)(realm, constructor), "constructor is a constructor function"); // 2. Assert: resultCapability is a PromiseCapability record.

  resultCapability; // 3. Let values be a new empty List.

  let values = []; // 4. Let remainingElementsCount be a new Record { [[Value]]: 1 }.

  let remainingElementsCount = {
    value: 1
  }; // 5. Let index be 0.

  let index = 0; // 6. Repeat

  while (true) {
    // a. Let next be IteratorStep(iteratorRecord.[[Iterator]]).
    let next;

    try {
      next = (0, _iterator.IteratorStep)(realm, iteratorRecord.$Iterator);
    } catch (e) {
      if (e instanceof _completions.AbruptCompletion) {
        // b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
        iteratorRecord.$Done = true;
      } // c. ReturnIfAbrupt(next).


      throw e;
    } // d. If next is false, then


    if (next === false) {
      // i. Set iteratorRecord.[[Done]] to true.
      iteratorRecord.$Done = true; // ii. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.

      remainingElementsCount.value = remainingElementsCount.value - 1; // iii. If remainingElementsCount.[[Value]] is 0, then

      if (remainingElementsCount.value === 0) {
        // 1. Let valuesArray be CreateArrayFromList(values).
        let valuesArray = _singletons.Create.CreateArrayFromList(realm, values); // 2. Perform ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »).


        (0, _call.Call)(realm, resultCapability.resolve, realm.intrinsics.undefined, [valuesArray]);
      } // iv. Return resultCapability.[[Promise]].


      return resultCapability.promise;
    } // e. Let nextValue be IteratorValue(next).


    let nextValue;

    try {
      nextValue = (0, _iterator.IteratorValue)(realm, next);
    } catch (e) {
      if (e instanceof _completions.AbruptCompletion) {
        // f. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
        iteratorRecord.$Done = true;
      } // g. ReturnIfAbrupt(nextValue).


      throw e;
    } // h. Append undefined to values.


    values.push(realm.intrinsics.undefined); // i. Let nextPromise be ? Invoke(constructor, "resolve", « nextValue »).

    let nextPromise = (0, _call.Invoke)(realm, constructor, "resolve", [nextValue]); // j. Let resolveElement be a new built-in function object as defined in Promise.all Resolve Element Functions.

    let resolveElement = createResolveElementFunction(realm); // k. Set the [[AlreadyCalled]] internal slot of resolveElement to a new Record {[[Value]]: false }.

    resolveElement.$AlreadyCalled = {
      value: false
    }; // l. Set the [[Index]] internal slot of resolveElement to index.

    resolveElement.$Index = index; // m. Set the [[Values]] internal slot of resolveElement to values.

    resolveElement.$Values = values; // n. Set the [[Capabilities]] internal slot of resolveElement to resultCapability.

    resolveElement.$Capabilities = resultCapability; // o. Set the [[RemainingElements]] internal slot of resolveElement to remainingElementsCount.

    resolveElement.$RemainingElements = remainingElementsCount; // p. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.

    remainingElementsCount.value = remainingElementsCount.value + 1; // q. Perform ? Invoke(nextPromise, "then", « resolveElement, resultCapability.[[Reject]] »).

    (0, _call.Invoke)(realm, nextPromise, "then", [resolveElement, resultCapability.reject]); // r. Set index to index + 1.

    index = index + 1;
  }

  (0, _invariant.default)(false);
} // ECMA262 25.4.4.3.1


function PerformPromiseRace(realm, iteratorRecord, resultCapability, C) {
  // 1. Assert: constructor is a constructor function.
  (0, _invariant.default)((0, _is.IsConstructor)(realm, C), "constructor is a constructor function"); // 2. Assert: resultCapability is a PromiseCapability Record.

  resultCapability; // 3. Repeat

  while (true) {
    // a. Let next be IteratorStep(iteratorRecord.[[Iterator]]).
    let next;

    try {
      next = (0, _iterator.IteratorStep)(realm, iteratorRecord.$Iterator);
    } catch (e) {
      if (e instanceof _completions.AbruptCompletion) {
        // b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
        iteratorRecord.$Done = true;
      } // c. ReturnIfAbrupt(next).


      throw e;
    } // d. If next is false, then


    if (next === false) {
      // i. Set iteratorRecord.[[Done]] to true.
      iteratorRecord.$Done = true; // ii. Return resultCapability.[[Promise]].

      (0, _invariant.default)(resultCapability.promise instanceof _index.ObjectValue);
      return resultCapability.promise;
    } // e. Let nextValue be IteratorValue(next).


    let nextValue;

    try {
      nextValue = (0, _iterator.IteratorValue)(realm, next);
    } catch (e) {
      if (e instanceof _completions.AbruptCompletion) {
        // f. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
        iteratorRecord.$Done = true;
      } // g. ReturnIfAbrupt(nextValue).


      throw e;
    } // h. Let nextPromise be ? Invoke(C, "resolve", « nextValue »).


    let nextPromise = (0, _call.Invoke)(realm, C, "resolve", [nextValue]); // i. Perform ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], resultCapability.[[Reject]] »).

    (0, _call.Invoke)(realm, nextPromise, "then", [resultCapability.resolve, resultCapability.reject]);
  }

  (0, _invariant.default)(false);
} // ECMA262 25.4.5.3.1


function PerformPromiseThen(realm, promise, onFulfilled, onRejected, resultCapability) {
  // 1. Assert: IsPromise(promise) is true.
  (0, _invariant.default)((0, _is.IsPromise)(realm, promise), "IsPromise(promise) is true"); // 2. Assert: resultCapability is a PromiseCapability record.

  resultCapability; // 3. If IsCallable(onFulfilled) is false, then

  if ((0, _is.IsCallable)(realm, onFulfilled) === false) {
    // a. Let onFulfilled be "Identity".
    onFulfilled = new _index.StringValue(realm, "Identity");
  } // 4. If IsCallable(onRejected) is false, then


  if ((0, _is.IsCallable)(realm, onRejected)) {
    // a. Let onRejected be "Thrower".
    onRejected = new _index.StringValue(realm, "Thrower");
  } // 5. Let fulfillReaction be the PromiseReaction { [[Capabilities]]: resultCapability, [[Handler]]: onFulfilled }.


  let fulfillReaction = {
    capabilities: resultCapability,
    handler: onFulfilled
  }; // 6. Let rejectReaction be the PromiseReaction { [[Capabilities]]: resultCapability, [[Handler]]: onRejected}.

  let rejectReaction = {
    capabilities: resultCapability,
    handler: onRejected
  }; // 7. If the value of promise's [[PromiseState]] internal slot is "pending", then

  if (promise.$PromiseState === "pending") {
    // a. Append fulfillReaction as the last element of the List that is the value of promise's [[PromiseFulfillReactions]] internal slot.
    _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseFulfillReactions");

    (0, _invariant.default)(promise.$PromiseFulfillReactions);
    promise.$PromiseFulfillReactions.push(fulfillReaction); // b. Append rejectReaction as the last element of the List that is the value of promise's [[PromiseRejectReactions]] internal slot.

    _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseRejectReactions");

    (0, _invariant.default)(promise.$PromiseRejectReactions);
    promise.$PromiseRejectReactions.push(rejectReaction);
  } else if (promise.$PromiseState === "fulfilled") {
    // 8. Else if the value of promise's [[PromiseState]] internal slot is "fulfilled", then
    // a. Let value be the value of promise's [[PromiseResult]] internal slot.
    let value = promise.$PromiseResult; // b. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « fulfillReaction, value »).

    EnqueueJob(realm, "PromiseJobs", PromiseReactionJob, [fulfillReaction, value]);
  } else {
    // 9. Else,
    // a. Assert: The value of promise's [[PromiseState]] internal slot is "rejected".
    (0, _invariant.default)(promise.$PromiseState === "rejected"); // b. Let reason be the value of promise's [[PromiseResult]] internal slot.

    let reason = promise.$PromiseResult; // c. If the value of promise's [[PromiseIsHandled]] internal slot is false, perform HostPromiseRejectionTracker(promise, "handle").

    if (promise.$PromiseIsHandled === false) HostPromiseRejectionTracker(realm, promise, "handle"); // d. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « rejectReaction, reason »).

    EnqueueJob(realm, "PromiseJobs", PromiseReactionJob, [rejectReaction, reason]);
  } // 10. Set promise's [[PromiseIsHandled]] internal slot to true.


  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseIsHandled").$PromiseIsHandled = true; // 11. Return resultCapability.[[Promise]].

  (0, _invariant.default)(resultCapability.promise instanceof _index.ObjectValue);
  return resultCapability.promise;
} // ECMA262 25.4.2.1


function PromiseReactionJob(realm, reaction, argument) {
  return realm.intrinsics.undefined;
} // ECMA262 25.4.1.3.2


function createResolveFunction(realm) {
  // 2. Let resolve be a new built-in function object as defined in Promise Resolve Functions (25.4.1.3.2).
  let resolve = new _index.NativeFunctionValue(realm, undefined, undefined, 1, (context, [resolution]) => {
    // 1. Assert: F has a [[Promise]] internal slot whose value is an Object.
    (0, _invariant.default)(resolve.$Promise instanceof _index.ObjectValue, "F has a [[Promise]] internal slot whose value is an Object"); // 2. Let promise be the value of F's [[Promise]] internal slot.

    let promise = resolve.$Promise; // 3. Let alreadyResolved be the value of F's [[AlreadyResolved]] internal slot.

    let alreadyResolved = resolve.$AlreadyResolved;
    (0, _invariant.default)(alreadyResolved !== undefined); // 4. If alreadyResolved.[[Value]] is true, return undefined.

    if (alreadyResolved.value === true) return realm.intrinsics.undefined; // 5. Set alreadyResolved.[[Value]] to true.

    alreadyResolved.value = true; // 6. If SameValue(resolution, promise) is true, then

    if ((0, _abstract.SameValue)(realm, resolution.throwIfNotConcrete(), promise)) {
      // a. Let selfResolutionError be a newly created TypeError object.
      let selfResolutionError = (0, _construct.Construct)(realm, realm.intrinsics.TypeError, [new _index.StringValue(realm, "resolve")]); // b. Return RejectPromise(promise, selfResolutionError).

      return RejectPromise(realm, promise, selfResolutionError);
    } // 7. If Type(resolution) is not Object, then


    if (!(resolution instanceof _index.ObjectValue)) {
      // a. Return FulfillPromise(promise, resolution).
      return FulfillPromise(realm, promise, resolution);
    } // 8. Let then be Get(resolution, "then").


    let then;

    try {
      then = (0, _get.Get)(realm, resolution, "then");
    } catch (e) {
      // 9. If then is an abrupt completion, then
      if (e instanceof _completions.AbruptCompletion) {
        // a. Return RejectPromise(promise, then.[[Value]]).
        return RejectPromise(realm, promise, e);
      } else throw e;
    } // 10. Let thenAction be then.[[Value]].


    let thenAction = then; // 11. If IsCallable(thenAction) is false, then

    if ((0, _is.IsCallable)(realm, thenAction)) {
      // a. Return FulfillPromise(promise, resolution).
      return FulfillPromise(realm, promise, resolution);
    } // 12. Perform EnqueueJob("PromiseJobs", PromiseResolveThenableJob, « promise, resolution, thenAction »).


    EnqueueJob(realm, "PromiseJobs", PromiseResolveThenableJob, [promise, resolution, thenAction]); // 13. Return undefined.

    return realm.intrinsics.undefined;
  }, false);
  return resolve;
} // ECMA262 25.4.1.3.1


function createRejectFunction(realm) {
  // 5. Let reject be a new built-in function object as defined in Promise Reject Functions (25.4.1.3.1).
  let reject = new _index.NativeFunctionValue(realm, undefined, undefined, 1, (context, [reason]) => {
    // 1. Assert: F has a [[Promise]] internal slot whose value is an Object.
    (0, _invariant.default)(reject.$Promise instanceof _index.ObjectValue, "F has a [[Promise]] internal slot whose value is an Object"); // 2. Let promise be the value of F's [[Promise]] internal slot.

    let promise = reject.$Promise; // 3. Let alreadyResolved be the value of F's [[AlreadyResolved]] internal slot.

    let alreadyResolved = reject.$AlreadyResolved;
    (0, _invariant.default)(alreadyResolved !== undefined); // 4. If alreadyResolved.[[Value]] is true, return undefined.

    if (alreadyResolved.value === true) return realm.intrinsics.undefined; // 5. Set alreadyResolved.[[Value]] to true.

    alreadyResolved.value = true; // 6. Return RejectPromise(promise, reason).

    return RejectPromise(realm, promise, reason);
  }, false);
  return reject;
} // ECMA262 25.4.1.3


function CreateResolvingFunctions(realm, promise) {
  // 1. Let alreadyResolved be a new Record { [[Value]]: false }.
  let alreadyResolved = {
    value: false
  }; // 2. Let resolve be a new built-in function object as defined in Promise Resolve Functions (25.4.1.3.2).

  let resolve = createResolveFunction(realm); // 3. Set the [[Promise]] internal slot of resolve to promise.

  resolve.$Promise = promise; // 4. Set the [[AlreadyResolved]] internal slot of resolve to alreadyResolved.

  resolve.$AlreadyResolved = alreadyResolved; // 5. Let reject be a new built-in function object as defined in Promise Reject Functions (25.4.1.3.1).

  let reject = createRejectFunction(realm); // 6. Set the [[Promise]] internal slot of reject to promise.

  reject.$Promise = promise; // 7. Set the [[AlreadyResolved]] internal slot of reject to alreadyResolved.

  reject.$AlreadyResolved = alreadyResolved; // 8. Return a new Record { [[Resolve]]: resolve, [[Reject]]: reject }.

  return {
    resolve: resolve,
    reject: reject
  };
} // ECMA262 25.4.1.4


function FulfillPromise(realm, promise, value) {
  // 1. Assert: The value of promise.[[PromiseState]] is "pending".
  (0, _invariant.default)(promise.$PromiseState === "pending"); // 2. Let reactions be promise.[[PromiseFulfillReactions]].

  let reactions = promise.$PromiseFulfillReactions;
  (0, _invariant.default)(reactions); // 3. Set promise.[[PromiseResult]] to value.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseResult").$PromiseResult = value; // 4. Set promise.[[PromiseFulfillReactions]] to undefined.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseFulfillReactions").$PromiseFulfillReactions = undefined; // 5. Set promise.[[PromiseRejectReactions]] to undefined.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseRejectReactions").$PromiseRejectReactions = undefined; // 6. Set promise.[[PromiseState]] to "fulfilled".

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseState").$PromiseState = "fulfilled"; // 7. Return TriggerPromiseReactions(reactions, value).

  return TriggerPromiseReactions(realm, reactions, value);
} // ECMA262 25.4.1.7


function RejectPromise(realm, promise, reason) {
  // 1. Assert: The value of promise.[[PromiseState]] is "pending".
  (0, _invariant.default)(promise.$PromiseState === "pending"); // 2. Let reactions be promise.[[PromiseRejectReactions]].

  let reactions = promise.$PromiseFulfillReactions;
  (0, _invariant.default)(reactions); // 3. Set promise.[[PromiseResult]] to reason.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseResult").$PromiseResult = reason; // 4. Set promise.[[PromiseFulfillReactions]] to undefined.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseFulfillReactions").$PromiseFulfillReactions = undefined; // 5. Set promise.[[PromiseRejectReactions]] to undefined.

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseRejectReactions").$PromiseRejectReactions = undefined; // 6. Set promise.[[PromiseState]] to "rejected".

  _singletons.Properties.ThrowIfInternalSlotNotWritable(realm, promise, "$PromiseState").$PromiseState = "rejected"; // 7. If promise.[[PromiseIsHandled]] is false, perform HostPromiseRejectionTracker(promise, "reject").

  if (promise.$PromiseIsHandled === false) HostPromiseRejectionTracker(realm, promise, "reject"); // 8. Return TriggerPromiseReactions(reactions, reason).

  return TriggerPromiseReactions(realm, reactions, reason);
} // ECMA262 25.4.1.8


function TriggerPromiseReactions(realm, reactions, argument) {
  // 1. Repeat for each reaction in reactions, in original insertion order
  for (let reaction of reactions) {
    // a. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « reaction, argument »).
    EnqueueJob(realm, "PromiseJobs", PromiseReactionJob, [reaction, argument]);
  } // 2. Return undefined.


  return realm.intrinsics.undefined;
} // ECMA262 25.4.1.9


function HostPromiseRejectionTracker(realm, promise, operation) {} // ECMA262 25.4.2.2


function PromiseResolveThenableJob(realm, promiseToResolve, thenable, then) {}
//# sourceMappingURL=promise.js.map