https://waynemcgregor.com/ui/js/fragments.js

744  len += 2;
745  if (len === 2) {
746    // If len is 2, that means that we need to schedule an async flush.
747    // If additional callbacks are queued before the queue is flushed, they
748    // will be processed by this flush that we are scheduling.
749    if (customSchedulerFn) {
750      customSchedulerFn(flush);
751    } else {
752      scheduleFlush();
753    }
754  }
755};
756
757function setScheduler(scheduleFn) {
758  customSchedulerFn = scheduleFn;
759}
760
761function setAsap(asapFn) {
762  asap = asapFn;
763}
764
765var browserWindow = typeof window !== 'undefined' ? window : undefined;
766var browserGlobal = browserWindow || {};
767var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
768var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
769
770// test for web worker but not in IE10
771var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
772
773// node
774function useNextTick() {
775  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
776  // see https://github.com/cujojs/when/issues/410 for details
777  return function () {
778    return process.nextTick(flush);
779  };
780}
781
782// vertx
783function useVertxTimer() {
784  if (typeof vertxNext !== 'undefined') {
785    return function () {
786      vertxNext(flush);
787    };
788  }
789
790  return useSetTimeout();
791}
792
793function useMutationObserver() {
794  var iterations = 0;
795  var observer = new BrowserMutationObserver(flush);
796  var node = document.createTextNode('');
797  observer.observe(node, { characterData: true });
798
799  return function () {
800    node.data = iterations = ++iterations % 2;
801  };
802}
803
804// web worker
805function useMessageChannel() {
806  var channel = new MessageChannel();
807  channel.port1.onmessage = flush;
808  return function () {
809    return channel.port2.postMessage(0);
810  };
811}
812
813function useSetTimeout() {
814  // Store setTimeout reference so es6-promise will be unaffected by
815  // other code modifying setTimeout (like sinon.useFakeTimers())
816  var globalSetTimeout = setTimeout;
817  return function () {
818    return globalSetTimeout(flush, 1);
819  };
820}
821
822var queue = new Array(1000);
823function flush() {
824  for (var i = 0; i < len; i += 2) {
825    var callback = queue[i];
826    var arg = queue[i + 1];
827
828    callback(arg);
829
830    queue[i] = undefined;
831    queue[i + 1] = undefined;
832  }
833
834  len = 0;
835}
836
837function attemptVertx() {
838  try {
839    var vertx = Function('return this')().require('vertx');
840    vertxNext = vertx.runOnLoop || vertx.runOnContext;
841    return useVertxTimer();
842  } catch (e) {
843    return useSetTimeout();
844  }
845}
846
847var scheduleFlush = void 0;
848// Decide what async method to use to triggering processing of queued callbacks:
849if (isNode) {
850  scheduleFlush = useNextTick();
851} else if (BrowserMutationObserver) {
852  scheduleFlush = useMutationObserver();
853} else if (isWorker) {
854  scheduleFlush = useMessageChannel();
855} else if (browserWindow === undefined && typeof require

855 === 'function') {
856  scheduleFlush = attemptVertx();
857} else {
858  scheduleFlush = useSetTimeout();
859}
860
861function then(onFulfillment, onRejection) {
862  var parent = this;
863
864  var child = new this.constructor(noop);
865
866  if (child[PROMISE_ID] === undefined) {
867    makePromise(child);
868  }
869
870  var _state = parent._state;
871
872
873  if (_state) {
874    var callback = arguments[_state - 1];
875    asap(function () {
876      return invokeCallback(_state, child, callback, parent._result);
877    });
878  } else {
879    subscribe(parent, child, onFulfillment, onRejection);
880  }
881
882  return child;
883}
884
885/**
886  `Promise.resolve` returns a promise that will become resolved with the
887  passed `value`. It is shorthand for the following:
888
889  ```javascript
890  let promise = new Promise(function(resolve, reject){
891    resolve(1);
892  });
893
894  promise.then(function(value){
895    // value === 1
896  });
897  ```
898
899  Instead of writing the above, your code now simply becomes the following:
900
901  ```javascript
902  let promise = Promise.resolve(1);
903
904  promise.then(function(value){
905    // value === 1
906  });
907  ```
908
909  @method resolve
910  @static
911  @param {Any} value value that the returned promise will be resolved with
912  Useful for tooling.
913  @return {Promise} a promise that will become fulfilled with the given
914  `value`
915*/
916function resolve$1(object) {
917  /*jshint validthis:true */
918  var Constructor = this;
919
920  if (object && typeof object === 'object' && object.constructor === Constructor) {
921    return object;
922  }
923
924  var promise = new Constructor(noop);
925  resolve(promise, object);
926  return promise;
927}
928
929var PROMISE_ID = Math.random().toString(36).substring(2);
930
931function noop() {}
932
933var PENDING = void 0;
934var FULFILLED = 1;
935var REJECTED = 2;
936
937var TRY_CATCH_ERROR = { error: null };
938
939function selfFulfillment() {
940  return new TypeError("You cannot resolve a promise with itself");
941}
942
943function cannotReturnOwn() {
944  return new TypeError('A promises callback cannot return that same promise.');
945}
946
947function getThen(promise) {
948  try {
949    return promise.then;
950  } catch (error) {
951    TRY_CATCH_ERROR.error = error;
952    return TRY_CATCH_ERROR;
953  }
954}
955
956function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
957  try {
958    then$$1.call(value, fulfillmentHandler, rejectionHandler);
959  } catch (e) {
960    return e;
961  }
962}
963
964function handleForeignThenable(promise, thenable, then$$1) {
965  asap(function (promise) {
966    var sealed = false;
967    var error = tryThen(then$$1, thenable, function (value) {
968      if (sealed) {
969        return;
970      }
971      sealed = true;
972      if (thenable !== value) {
973        resolve(promise, value);
974      } else {
975        fulfill(promise, value);
976      }
977    }, function (reason) {
978      if (sealed) {
979        return;
980      }
981      sealed = true;
982
983      reject(promise, reason);
984    }, 'Settle: ' + (promise._label || ' unknown promise'));
985
986    if (!sealed && error) {
987      sealed = true;
988      reject(promise, error);
989    }
990  }, promise);
991}
992
993function handleOwnThenable(promise, thenable) {
994  if (thenable._state === FULFILLED) {
995    fulfill(promise, thenable._result);
996  } else if (thenable._state === REJECTED) {
997    reject(promise, thenable._result);
998  } else {
999    subscribe(thenable, undefined, function (value) {
1000      return resolve(promise, value);
1001    }, function (reason) {
1002      return reject(promise, reason);
1003    });
1004  }
1005}
1006
1007function handleMaybeThenable(promise, maybeThenable, then$$1) {
1008  if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
1009    handleOwnThenable(promise, maybeThenable);
1010  } else {
1011    if (then$$1 === TRY_CATCH_ERROR) {
1012      reject(promise, TRY_CATCH_ERROR.error);
1013      TRY_CATCH_ERROR.error = null;
1014    } else if (then$$1 === undefined) {
1015      fulfill(promise, maybeThenable);
1016    } else if (isFunction(then$$1)) {
1017      handleForeignThenable(promise, maybeThenable, then$$1);
1018    } else {
1019      fulfill(promise, maybeThenable);
1020    }
1021  }
1022}
1023
1024function resolve(promise, value) {
1025  if (promise === value) {
1026    reject(promise, selfFulfillment());
1027  } else if (objectOrFunction(value)) {
1028    handleMaybeThenable(promise, value, getThen(value));
1029  } else {
1030    fulfill(promise, value);
1031  }
1032}
1033
1034function publishRejection(promise) {
1035  if (promise._onerror) {
1036    promise._onerror(promise._result);
1037  }
1038
1039  publish(promise);
1040}
1041
1042function fulfill(promise, value) {
1043  if (promise._state !== PENDING) {
1044    return;
1045  }
1046
1047  promise._result = value;
1048  promise._state = FULFILLED;
1049
1050  if (promise._subscribers.length !== 0) {
1051    asap(publish, promise);
1052  }
1053}
1054
1055function reject(promise, reason) {
1056  if (promise._state !== PENDING) {
1057    return;
1058  }
1059  promise._state = REJECTED;
1060  promise._result = reason;
1061
1062  asap(publishRejection, promise);
1063}
1064
1065function subscribe(parent, child, onFulfillment, onRejection) {
1066  var _subscribers = parent._subscribers;
1067  var length = _subscribers.length;
1068
1069
1070  parent._onerror = null;
1071
1072  _subscribers[length] = child;
1073  _subscribers[length + FULFILLED] = onFulfillment;
1074  _subscribers[length + REJECTED] = onRejection;
1075
1076  if (length === 0 && parent._state) {
1077    asap(publish, parent);
1078  }
1079}
1080
1081function publish(promise) {
1082  var subscribers = promise._subscribers;
1083  var settled = promise._state;
1084
1085  if (subscribers.length === 0) {
1086    return;
1087  }
1088
1089  var child = void 0,
1090      callback = void 0,
1091      detail = promise._result;
1092
1093  for (var i = 0; i < subscribers.length; i += 3) {
1094    child = subscribers[i];
1095    callback = subscribers[i + settled];
1096
1097    if (child) {
1098      invokeCallback(settled, child, callback, detail);
1099    } else {
1100      callback(detail);
1101    }
1102  }
1103
1104  promise._subscribers.length = 0;
1105}
1106
1107function tryCatch(callback, detail) {
1108  try {
1109    return callback(detail);
1110  } catch (e) {
1111    TRY_CATCH_ERROR.error = e;
1112    return TRY_CATCH_ERROR;
1113  }
1114}
1115
1116function invokeCallback(settled, promise, callback, detail) {
1117  var hasCallback = isFunction(callback),
1118      value = void 0,
1119      error = void 0,
1120      succeeded = void 0,
1121      failed = void 0;
1122
1123  if (hasCallback) {
1124    value = tryCatch(callback, detail);
1125
1126    if (value === TRY_CATCH_ERROR) {
1127      failed = true;
1128      error = value.error;
1129      value.error = null;
1130    } else {
1131      succeeded = true;
1132    }
1133
1134    if (promise === value) {
1135      reject(promise, cannotReturnOwn());
1136      return;
1137    }
1138  } else {
1139    value = detail;
1140    succeeded = true;
1141  }
1142
1143  if (promise._state !== PENDING) {
1144    // noop
1145  } else if (hasCallback && succeeded) {
1146    resolve(promise, value);
1147  } else if (failed) {
1148    reject(promise, error);
1149  } else if (settled === FULFILLED) {
1150    fulfill(promise, value);
1151  } else if (settled === REJECTED) {
1152    reject(promise, value);
1153  }
1154}
1155
1156function initializePromise(promise, resolver) {
1157  try {
1158    resolver(function resolvePromise(value) {
1159      resolve(promise, value);
1160    }, function rejectPromise(reason) {
1161      reject(promise, reason);
1162    });
1163  } catch (e) {
1164    reject(promise, e);
1165  }
1166}
1167
1168var id = 0;
1169function nextId() {
1170  return id++;
1171}
1172
1173function makePromise(promise) {
1174  promise[PROMISE_ID] = id++;
1175  promise._state = undefined;
1176  promise._result = undefined;
1177  promise._subscribers = [];
1178}
1179
1180function validationError() {
1181  return new Error('Array Methods must be provided an Array');
1182}
1183
1184var Enumerator = function () {
1185  function Enumerator(Constructor, input) {
1186    this._instanceConstructor = Constructor;
1187    this.promise = new Constructor(noop);
1188
1189    if (!this.promise[PROMISE_ID]) {
1190      makePromise(this.promise);
1191    }
1192
1193    if (isArray(input)) {
1194      this.length = input.length;
1195      this._remaining = input.length;
1196
1197      this._result = new Array(this.length);
1198
1199      if (this.length === 0) {
1200        fulfill(this.promise, this._result);
1201      } else {
1202        this.length = this.length || 0;
1203        this._enumerate(input);
1204        if (this._remaining === 0) {
1205          fulfill(this.promise, this._result);
1206        }
1207      }
1208    } else {
1209      reject(this.promise, validationError());
1210    }
1211  }
1212
1213  Enumerator.prototype._enumerate = function _enumerate(input) {
1214    for (var i = 0; this._state === PENDING && i < input.length; i++) {
1215      this._eachEntry(input[i], i);
1216    }
1217  };
1218
1219  Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
1220    var c = this._instanceConstructor;
1221    var resolve$$1 = c.resolve;
1222
1223
1224    if (resolve$$1 === resolve$1) {
1225      var _then = getThen(entry);
1226
1227      if (_then === then && entry._state !== PENDING) {
1228        this._settledAt(entry._state, i, entry._result);
1229      } else if (typeof _then !== 'function') {
1230        this._remaining--;
1231        this._result[i] = entry;
1232      } else if (c === Promise$

1234
1235        this._willSettleAt(promise, i);
1236      } else {
1237        this._willSettleAt(new c(function (resolve$$1) {
1238          return resolve$$1(entry);
1239        }), i);
1240      }
1241    } else {
1242      this._willSettleAt(resolve$$1(entry), i);
1243    }
1244  };
1245
1246  Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
1247    var promise = this.promise;
1248
1249
1250    if (promise._state === PENDING) {
1251      this._remaining--;
1252
1253      if (state === REJECTED) {
1254        reject(promise, value);
1255      } else {
1256        this._result[i] = value;
1257      }
1258    }
1259
1260    if (this._remaining === 0) {
1261      fulfill(promise, this._result);
1262    }
1263  };
1264
1265  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
1266    var enumerator = this;
1267
1268    subscribe(promise, undefined, function (value) {
1269      return enumerator._settledAt(FULFILLED, i, value);
1270    }, function (reason) {
1271      return enumerator._settledAt(REJECTED, i, reason);
1272    });
1273  };
1274
1275  return Enumerator;
1276}();
1277
1278/**
1279  `Promise.all` accepts an array of promises, and returns a new promise which
1280  is fulfilled with an array of fulfillment values for the passed promises, or
1281  rejected with the reason of the first passed promise to be rejected. It casts all
1282  elements of the passed iterable to promises as it runs this algorithm.
1283
1284  Example:
1285
1286  ```javascript
1287  let promise1 = resolve(1);
1288  let promise2 = resolve(2);
1289  let promise3 = resolve(3);
1290  let promises = [ promise1, promise2, promise3 ];
1291
1292  Promise.all(promises).then(function(array){
1293    // The array here would be [ 1, 2, 3 ];
1294  });
1295  ```
1296
1297  If any of the `promises` given to `all` are rejected, the first promise
1298  that is rejected will be given as an argument to the returned promises's
1299  rejection handler. For example:
1300
1301  Example:
1302
1303  ```javascript
1304  let promise1 = resolve(1);
1305  let promise2 = reject(new Error("2"));
1306  let promise3 = reject(new Error("3"));
1307  let promises = [ promise1, promise2, promise3 ];
1308
1309  Promise.all(promises).then(function(array){
1310    // Code here never runs because there are rejected promises!
1311  }, function(error) {
1312    // error.message === "2"
1313  });
1314  ```
1315
1316  @method all
1317  @static
1318  @param {Array} entries array of promises
1319  @param {String} label optional string for labeling the promise.
1320  Useful for tooling.
1321  @return {Promise} promise that is fulfilled when all `promises` have been
1322  fulfilled, or rejected if any of them become rejected.
1323  @static
1324*/
1325function all(entries) {
1326  return new Enumerator(this, entries).promise;
1327}
1328
1329/**
1330  `Promise.race` returns a new promise which is settled in the same way as the
1331  first passed promise to settle.
1332
1333  Example:
1334
1335  ```javascript
1336  let promise1 = new Promise(function(resolve, reject){
1337    setTimeout(function(){
1338      resolve('promise 1');
1339    }, 200);
1340  });
1341
1342  let promise2 = new Promise(function(resolve, reject){
1343    setTimeout(function(){
1344      resolve('promise 2');
1345    }, 100);
1346  });
1347
1348  Promise.race([promise1, promise2]).then(function(result){
1349    // result === 'promise 2' because it was resolved before promise1
1350    // was resolved.
1351  });
1352  ```
1353
1354  `Promise.race` is deterministic in that only the state of the first
1355  settled promise matters. For example, even if other promises given to the
1356  `promises` array argument are resolved, but the first settled promise has
1357  become rejected before the other promises became fulfilled, the returned
1358  promise will become rejected:
1359
1360  ```javascript
1361  let promise1 = new Promise(function(resolve, reject){
1362    setTimeout(function(){
1363      resolve('promise 1');
1364    }, 200);
1365  });
1366
1367  let promise2 = new Promise(function(resolve, reject){
1368    setTimeout(function(){
1369      reject(new Error('promise 2'));
1370    }, 100);
1371  });
1372
1373  Promise.race([promise1, promise2]).then(function(result){
1374    // Code here never runs
1375  }, function(reason){
1376    // reason.message === 'promise 2' because promise 2 became rejected before
1377    // promise 1 became fulfilled
1378  });
1379  ```
1380
1381  An example real-world use case is implementing timeouts:
1382
1383  ```javascript
1384  Promise.race([ajax('foo.json'), timeout(5000)])
1385  ```
1386
1387  @method race
1388  @static
1389  @param {Array} promises array of promises to observe
1390  Useful for tooling.
1391  @return {Promise} a promise which settles in the same way as the first passed
1392  promise to settle.
1393*/
1394function race(entries) {
1395  /*jshint validthis:true */
1396  var Constructor = this;
1397
1398  if (!isArray(entries)) {
1399    return new Constructor(function (_, reject) {
1400      return reject(new TypeError('You must pass an array to race.'));
1401    });
1402  } else {
1403    return new Constructor(function (resolve, reject) {
1404      var length = entries.length;
1405      for (var i = 0; i < length; i++) {
1406        Constructor.resolve(entries[i]).then(resolve, reject);
1407      }
1408    });
1409  }
1410}
1411
1412/**
1413  `Promise.reject` returns a promise rejected with the passed `reason`.
1414  It is shorthand for the following:
1415
1416  ```javascript
1417  let promise = new Promise(function(resolve, reject){
1418    reject(new Error('WHOOPS'));
1419  });
1420
1421  promise.then(function(value){
1422    // Code here doesn't run because the promise is rejected!
1423  }, function(reason){
1424    // reason.message === 'WHOOPS'
1425  });
1426  ```
1427
1428  Instead of writing the above, your code now simply becomes the following:
1429
1430  ```javascript
1431  let promise = Promise.reject(new Error('WHOOPS'));
1432
1433  promise.then(function(value){
1434    // Code here doesn't run because the promise is rejected!
1435  }, function(reason){
1436    // reason.message === 'WHOOPS'
1437  });
1438  ```
1439
1440  @method reject
1441  @static
1442  @param {Any} reason value that the returned promise will be rejected with.
1443  Useful for tooling.
1444  @return {Promise} a promise rejected with the given `reason`.
1445*/
1446function reject$1(reason) {
1447  /*jshint validthis:true */
1448  var Constructor = this;
1449  var promise = new Constructor(noop);
1450  reject(promise, reason);
1451  return promise;
1452}
1453
1454function needsResolver() {
1455  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
1456}
1457
1458function needsNew() {
1459  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object c

1459onstructor cannot be called as a function.");
1460}
1461
1462/**
1463  Promise objects represent the eventual result of an asynchronous operation. The
1464  primary way of interacting with a promise is through its `then` method, which
1465  registers callbacks to receive either a promise's eventual value or the reason
1466  why the promise cannot be fulfilled.
1467
1468  Terminology
1469  -----------
1470
1471  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
1472  - `thenable` is an object or function that defines a `then` method.
1473  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
1474  - `exception` is a value that is thrown using the throw statement.
1475  - `reason` is a value that indicates why a promise was rejected.
1476  - `settled` the final resting state of a promise, fulfilled or rejected.
1477
1478  A promise can be in one of three states: pending, fulfilled, or rejected.
1479
1480  Promises that are fulfilled have a fulfillment value and are in the fulfilled
1481  state.  Promises that are rejected have a rejection reason and are in the
1482  rejected state.  A fulfillment value is never a thenable.
1483
1484  Promises can also be said to *resolve* a value.  If this value is also a
1485  promise, then the original promise's settled state will match the value's
1486  settled state.  So a promise that *resolves* a promise that rejects will
1487  itself reject, and a promise that *resolves* a promise that fulfills will
1488  itself fulfill.
1489
1490
1491  Basic Usage:
1492  ------------
1493
1494  ```js
1495  let promise = new Promise(function(resolve, reject) {
1496    // on success
1497    resolve(value);
1498
1499    // on failure
1500    reject(reason);
1501  });
1502
1503  promise.then(function(value) {
1504    // on fulfillment
1505  }, function(reason) {
1506    // on rejection
1507  });
1508  ```
1509
1510  Advanced Usage:
1511  ---------------
1512
1513  Promises shine when abstracting away asynchronous interactions such as
1514  `XMLHttpRequest`s.
1515
1516  ```js
1517  function getJSON(url) {
1518    return new Promise(function(resolve, reject){
1519      let xhr = new XMLHttpRequest();
1520
1521      xhr.open('GET', url);
1522      xhr.onreadystatechange = handler;
1523      xhr.responseType = 'json';
1524      xhr.setRequestHeader('Accept', 'application/json');
1525      xhr.send();
1526
1527      function handler() {
1528        if (this.readyState === this.DONE) {
1529          if (this.status === 200) {
1530            resolve(this.response);
1531          } else {
1532            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
1533          }
1534        }
1535      };
1536    });
1537  }
1538
1539  getJSON('/posts.json').then(function(json) {
1540    // on fulfillment
1541  }, function(reason) {
1542    // on rejection
1543  });
1544  ```
1545
1546  Unlike callbacks, promises are great composable primitives.
1547
1548  ```js
1549  Promise.all([
1550    getJSON('/posts'),
1551    getJSON('/comments')
1552  ]).then(function(values){
1553    values[0] // => postsJSON
1554    values[1] // => commentsJSON
1555
1556    return values;
1557  });
1558  ```
1559
1560  @class Promise
1561  @param {Function} resolver
1562  Useful for tooling.
1563  @constructor
1564*/
1565
1566var Promise$2 = function () {
1567  function Promise(resolver) {
1568    this[PROMISE_ID] = nextId();
1569    this._result = this._state = undefined;
1570    this._subscribers = [];
1571
1572    if (noop !== resolver) {
1573      typeof resolver !== 'function' && needsResolver();
1574      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
1575    }
1576  }
1577
1578  /**
1579  The primary way of interacting with a promise is through its `then` method,
1580  which registers callbacks to receive either a promise's eventual value or the
1581  reason why the promise cannot be fulfilled.
1582   ```js
1583  findUser().then(function(user){
1584    // user is available
1585  }, function(reason){
1586    // user is unavailable, and you are given the reason why
1587  });
1588  ```
1589   Chaining
1590  --------
1591   The return value of `then` is itself a promise.  This second, 'downstream'
1592  promise is resolved with the return value of the first promise's fulfillment
1593  or rejection handler, or rejected if the handler throws an exception.
1594   ```js
1595  findUser().then(function (user) {
1596    return user.name;
1597  }, function (reason) {
1598    return 'default name';
1599  }).then(function (userName) {
1600    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
1601    // will be `'default name'`
1602  });
1603   findUser().then(function (user) {
1604    throw new Error('Found user, but still unhappy');
1605  }, function (reason) {
1606    throw new Error('`findUser` rejected and we're unhappy');
1607  }).then(function (value) {
1608    // never reached
1609  }, function (reason) {
1610    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
1611    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
1612  });
1613  ```
1614  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
1615   ```js
1616  findUser().then(function (user) {
1617    throw new PedagogicalException('Upstream error');
1618  }).then(function (value) {
1619    // never reached
1620  }).then(function (value) {
1621    // never reached
1622  }, function (reason) {
1623    // The `PedgagocialException` is propagated all the way down to here
1624  });
1625  ```
1626   Assimilation
1627  ------------
1628   Sometimes the value you want to propagate to a downstream promise can only be
1629  retrieved asynchronously. This can be achieved by returning a promise in the
1630  fulfillment or rejection handler. The downstream promise will then be pending
1631  until the returned promise is settled. This is called *assimilation*.
1632   ```js
1633  findUser().then(function (user) {
1634    return findCommentsByAuthor(user);
1635  }).then(function (comments) {
1636    // The user's comments are now available
1637  });
1638  ```
1639   If the assimliated promise rejects, then the downstream promise will also reject.
1640   ```js
1641  findUser().then(function (user) {
1642    return findCommentsByAuthor(user);
1643  }).then(function (comments) {
1644    // If `findCommentsByAuthor` fulfills, we'll have the value here
1645  }, function (reason) {
1646    // If `findCommentsByAuthor` rejects, we'll have the reason here
1647  });
1648  ```
1649   Simple Example
1650  --------------
1651   Synchronous Example
1652   ```javascript
1653  let result;
1654   try {
1655    result = findResult();
1656    // success
1657  } catch(reason) {
1658    // failure
1659  }
1660  ```
1661   Errback Example
1662   ```js
1663  findResult(function(result, err){
1664    if (err) {
1665      // failure
1666    } else {
1667      // success
1668    }
1669  });
1670  ```
1671   Promise Example;
1672   ```javascript
1673  findResult().then(function(result){
1674    // success
1675  }, function(reason){
1676    // failure
1677  });
1678  ```
1679   Advanced Example
1680  --------------
1681   Synchronous Example
1682   ```javascript
1683  let author, books;
1684   try {
1685    author = findAuthor();
1686    books  = findBooksByAuthor(author);
1687    // success
1688  } catch(reason) {
1689    // failure
1690  }
1691  ```
1692   Errback Example
1693   ```js
1694   function foundBooks(books) {
1695   }
1696   function failure(reason) {
1697   }
1698   findAuthor(function(author, err){
1699    if (err) {
1700      failure(err);
1701      // failure
1702    } else {
1703      try {
1704        findBoooksByAuthor(author, function(books, err) {
1705          if (err) {
1706            failure(err);
1707          } else {
1708            try {
1709              foundBooks(books);
1710            } catch(reason) {
1711              failure(reason);
1712            }
1713          }
1714        });
1715      } catch(error) {
1716        failure(err);
1717      }
1718      // success
1719    }
1720  });
1721  ```
1722   Promise Example;
1723   ```javascript
1724  findAuthor().
1725    then(findBooksByAuthor).
1726    then(function(books){
1727      // found books
1728  }).catch(function(reason){
1729    // something went wrong
1730  });
1731  ```
1732   @method then
1733  @param {Function} onFulfilled
1734  @param {Function} onRejected
1735  Useful for tooling.
1736  @return {Promise}
1737  */
1738
1739  /**
1740  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
1741  as the catch block of a try/catch statement.
1742  ```js
1743  function findAuthor(){
1744  throw new Error('couldn't find that author');
1745  }
1746  // synchronous
1747  try {
1748  findAuthor();
1749  } catch(reason) {
1750  // something went wrong
1751  }
1752  // async with promises
1753  findAuthor().catch(function(reason){
1754  // something went wrong
1755  });
1756  ```
1757  @method catch
1758  @param {Function} onRejection
1759  Useful for tooling.
1760  @return {Promise}
1761  */
1762
1763
1764  Promise.prototype.catch = function _catch(onRejection) {
1765    return this.then(null, onRejection);
1766  };
1767
1768  /**
1769    `finally` will be invoked regardless of the promise's fate just as native
1770    try/catch/finally behaves
1771  
1772    Synchronous example:
1773  
1774    ```js
1775    findAuthor() {
1776      if (Math.random() > 0.5) {
1777        throw new Error();
1778      }
1779      return new Author();
1780    }
1781  
1782    try {
1783      return findAuthor(); // succeed or fail
1784    } catch(error) {
1785      return findOtherAuther();
1786    } finally {
1787      // always runs
1788      // doesn't affect the return value
1789    }
1790    ```
1791  
1792    Asynchronous example:
1793  
1794    ```js
1795    findAuthor().catch(function(reason){
1796      return findOtherAuther();
1797    }).finally(function(){
1798      // author was either found, or not
1799    });
1800    ```
1801  
1802    @method finally
1803    @param {Function} callback
1804    @return {Promise}
1805  */
1806
1807
1808  Promise.prototype.finally = function _finally(callback) {
1809    var promise = this;
1810    var constructor = promise.constructor;
1811
1812    if (isFunction(callback)) {
1813      return promise.then(function (value) {
1814        return constructor.resolve(callback()).then(function () {
1815          return value;
1816        });
1817      }, function (reason) {
1818        return constructor.resolve(callback()).then(function () {
1819          throw reason;
1820        });
1821      });
1822    }
1823
1824    return promise.then(callback, callback);
1825  };
1826
1827  return Promise;
1828}();
1829
1830Promise$2.prototype.then = then;
1831Promise$2.all = all;
1832Promise$2.race = race;
1833Promise$2.resolve = resolve$1;
1834Promise$2.reject = reject$1;
1835Promise$2._setScheduler = setScheduler;
1836Promise$2._setAsap = setAsap;
1837Promise$2._asap = asap;
1838
1839/*global self*/
1840function polyfill() {
1841  var local = void 0;
1842
1843  if (typeof global !== 'undefined') {
1844    local = global;
1845  } else if (typeof self !== 'undefined') {
1846    local = self;
1847  } else {
1848    try {
1849      local = Function('return this')();
1850    } catch (e) {
1851      throw new Error('polyfill failed because global object is unavailable in this environment');
1852    }
1853  }
1854
1855  var P = local.Promise;
1856
1857  if (P) {
1858    var promiseToString = null;
1859    try {
1860      promiseToString = Object.prototype.toString.call(P.resolve());
1861    } catch (e) {
1862      // silently ignored
1863    }
1864
1865    if (promiseToString === '[object Promise]' && !P.cast) {
1866      return;
1867    }
1868  }
1869
1870  local.Promise = Promise$2;
1871}
1872
1873// Strange compat..
1874Promise$2.polyfill = polyfill;
1875Promise$2.Promise = Promise$2;
1876
1877Promise$2.polyfill();
1878
1879return Promise$2;
1880
1881})));
1882
1883
1884
1885//# sourceMappingURL=es6-promise.auto.map