@zeppos/zeus-cli 1.3.5 → 1.3.7

package/private-modules/zeppos-app-utils/dist/public/template/os2.0/app/fetch-api/todo-list/shared/es6-promise.js

@@ -1,1178 +0,0 @@
-/*!
- * @overview es6-promise - a tiny implementation of Promises/A+.
- * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
- * @license   Licensed under MIT license
- *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
- * @version   v4.2.8+1e68dce6
- */
-
-;(function (global, factory) {
-  global.ES6Promise = factory()
-})(globalThis, function () {
-  'use strict'
-
-  function objectOrFunction(x) {
-    var type = typeof x
-    return x !== null && (type === 'object' || type === 'function')
-  }
-
-  function isFunction(x) {
-    return typeof x === 'function'
-  }
-
-  var _isArray = void 0
-  if (Array.isArray) {
-    _isArray = Array.isArray
-  } else {
-    _isArray = function (x) {
-      return Object.prototype.toString.call(x) === '[object Array]'
-    }
-  }
-
-  var isArray = _isArray
-
-  var len = 0
-  var vertxNext = void 0
-  var customSchedulerFn = void 0
-
-  var asap = function asap(callback, arg) {
-    queue[len] = callback
-    queue[len + 1] = arg
-    len += 2
-    if (len === 2) {
-      // If len is 2, that means that we need to schedule an async flush.
-      // If additional callbacks are queued before the queue is flushed, they
-      // will be processed by this flush that we are scheduling.
-      if (customSchedulerFn) {
-        customSchedulerFn(flush)
-      } else {
-        scheduleFlush()
-      }
-    }
-  }
-
-  function setScheduler(scheduleFn) {
-    customSchedulerFn = scheduleFn
-  }
-
-  function setAsap(asapFn) {
-    asap = asapFn
-  }
-
-  var browserWindow = typeof window !== 'undefined' ? window : undefined
-  var browserGlobal = browserWindow || {}
-  var BrowserMutationObserver =
-    browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver
-  var isNode =
-    typeof self === 'undefined' &&
-    typeof process !== 'undefined' &&
-    {}.toString.call(process) === '[object process]'
-
-  // test for web worker but not in IE10
-  var isWorker =
-    typeof Uint8ClampedArray !== 'undefined' &&
-    typeof importScripts !== 'undefined' &&
-    typeof MessageChannel !== 'undefined'
-
-  // node
-  function useNextTick() {
-    // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-    // see https://github.com/cujojs/when/issues/410 for details
-    return function () {
-      return process.nextTick(flush)
-    }
-  }
-
-  // vertx
-  function useVertxTimer() {
-    if (typeof vertxNext !== 'undefined') {
-      return function () {
-        vertxNext(flush)
-      }
-    }
-
-    return useSetTimeout()
-  }
-
-  function useMutationObserver() {
-    var iterations = 0
-    var observer = new BrowserMutationObserver(flush)
-    var node = document.createTextNode('')
-    observer.observe(node, { characterData: true })
-
-    return function () {
-      node.data = iterations = ++iterations % 2
-    }
-  }
-
-  // web worker
-  function useMessageChannel() {
-    var channel = new MessageChannel()
-    channel.port1.onmessage = flush
-    return function () {
-      return channel.port2.postMessage(0)
-    }
-  }
-
-  function useSetTimeout() {
-    // Store setTimeout reference so es6-promise will be unaffected by
-    // other code modifying setTimeout (like sinon.useFakeTimers())
-    var globalSetTimeout = setTimeout
-    return function () {
-      return globalSetTimeout(flush, 1)
-    }
-  }
-
-  var queue = new Array(1000)
-  function flush() {
-    for (var i = 0; i < len; i += 2) {
-      var callback = queue[i]
-      var arg = queue[i + 1]
-
-      callback(arg)
-
-      queue[i] = undefined
-      queue[i + 1] = undefined
-    }
-
-    len = 0
-  }
-
-  function attemptVertx() {
-    try {
-      var vertx = Function('return this')().require('vertx')
-      vertxNext = vertx.runOnLoop || vertx.runOnContext
-      return useVertxTimer()
-    } catch (e) {
-      return useSetTimeout()
-    }
-  }
-
-  var scheduleFlush = void 0
-  // Decide what async method to use to triggering processing of queued callbacks:
-  if (isNode) {
-    scheduleFlush = useNextTick()
-  } else if (BrowserMutationObserver) {
-    scheduleFlush = useMutationObserver()
-  } else if (isWorker) {
-    scheduleFlush = useMessageChannel()
-  } else if (browserWindow === undefined && typeof require === 'function') {
-    scheduleFlush = attemptVertx()
-  } else {
-    scheduleFlush = useSetTimeout()
-  }
-
-  function then(onFulfillment, onRejection) {
-    var parent = this
-
-    var child = new this.constructor(noop)
-
-    if (child[PROMISE_ID] === undefined) {
-      makePromise(child)
-    }
-
-    var _state = parent._state
-
-    if (_state) {
-      var callback = arguments[_state - 1]
-      asap(function () {
-        return invokeCallback(_state, child, callback, parent._result)
-      })
-    } else {
-      subscribe(parent, child, onFulfillment, onRejection)
-    }
-
-    return child
-  }
-
-  /**
-  `Promise.resolve` returns a promise that will become resolved with the
-  passed `value`. It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    resolve(1);
-  });
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.resolve(1);
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  @method resolve
-  @static
-  @param {Any} value value that the returned promise will be resolved with
-  Useful for tooling.
-  @return {Promise} a promise that will become fulfilled with the given
-  `value`
-*/
-  function resolve$1(object) {
-    /*jshint validthis:true */
-    var Constructor = this
-
-    if (object && typeof object === 'object' && object.constructor === Constructor) {
-      return object
-    }
-
-    var promise = new Constructor(noop)
-    resolve(promise, object)
-    return promise
-  }
-
-  var PROMISE_ID = Math.random().toString(36).substring(2)
-
-  function noop() {}
-
-  var PENDING = void 0
-  var FULFILLED = 1
-  var REJECTED = 2
-
-  function selfFulfillment() {
-    return new TypeError('You cannot resolve a promise with itself')
-  }
-
-  function cannotReturnOwn() {
-    return new TypeError('A promises callback cannot return that same promise.')
-  }
-
-  function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
-    try {
-      then$$1.call(value, fulfillmentHandler, rejectionHandler)
-    } catch (e) {
-      return e
-    }
-  }
-
-  function handleForeignThenable(promise, thenable, then$$1) {
-    asap(function (promise) {
-      var sealed = false
-      var error = tryThen(
-        then$$1,
-        thenable,
-        function (value) {
-          if (sealed) {
-            return
-          }
-          sealed = true
-          if (thenable !== value) {
-            resolve(promise, value)
-          } else {
-            fulfill(promise, value)
-          }
-        },
-        function (reason) {
-          if (sealed) {
-            return
-          }
-          sealed = true
-
-          reject(promise, reason)
-        },
-        'Settle: ' + (promise._label || ' unknown promise')
-      )
-
-      if (!sealed && error) {
-        sealed = true
-        reject(promise, error)
-      }
-    }, promise)
-  }
-
-  function handleOwnThenable(promise, thenable) {
-    if (thenable._state === FULFILLED) {
-      fulfill(promise, thenable._result)
-    } else if (thenable._state === REJECTED) {
-      reject(promise, thenable._result)
-    } else {
-      subscribe(
-        thenable,
-        undefined,
-        function (value) {
-          return resolve(promise, value)
-        },
-        function (reason) {
-          return reject(promise, reason)
-        }
-      )
-    }
-  }
-
-  function handleMaybeThenable(promise, maybeThenable, then$$1) {
-    if (
-      maybeThenable.constructor === promise.constructor &&
-      then$$1 === then &&
-      maybeThenable.constructor.resolve === resolve$1
-    ) {
-      handleOwnThenable(promise, maybeThenable)
-    } else {
-      if (then$$1 === undefined) {
-        fulfill(promise, maybeThenable)
-      } else if (isFunction(then$$1)) {
-        handleForeignThenable(promise, maybeThenable, then$$1)
-      } else {
-        fulfill(promise, maybeThenable)
-      }
-    }
-  }
-
-  function resolve(promise, value) {
-    if (promise === value) {
-      reject(promise, selfFulfillment())
-    } else if (objectOrFunction(value)) {
-      var then$$1 = void 0
-      try {
-        then$$1 = value.then
-      } catch (error) {
-        reject(promise, error)
-        return
-      }
-      handleMaybeThenable(promise, value, then$$1)
-    } else {
-      fulfill(promise, value)
-    }
-  }
-
-  function publishRejection(promise) {
-    if (promise._onerror) {
-      promise._onerror(promise._result)
-    }
-
-    publish(promise)
-  }
-
-  function fulfill(promise, value) {
-    if (promise._state !== PENDING) {
-      return
-    }
-
-    promise._result = value
-    promise._state = FULFILLED
-
-    if (promise._subscribers.length !== 0) {
-      asap(publish, promise)
-    }
-  }
-
-  function reject(promise, reason) {
-    if (promise._state !== PENDING) {
-      return
-    }
-    promise._state = REJECTED
-    promise._result = reason
-
-    asap(publishRejection, promise)
-  }
-
-  function subscribe(parent, child, onFulfillment, onRejection) {
-    var _subscribers = parent._subscribers
-    var length = _subscribers.length
-
-    parent._onerror = null
-
-    _subscribers[length] = child
-    _subscribers[length + FULFILLED] = onFulfillment
-    _subscribers[length + REJECTED] = onRejection
-
-    if (length === 0 && parent._state) {
-      asap(publish, parent)
-    }
-  }
-
-  function publish(promise) {
-    var subscribers = promise._subscribers
-    var settled = promise._state
-
-    if (subscribers.length === 0) {
-      return
-    }
-
-    var child = void 0,
-      callback = void 0,
-      detail = promise._result
-
-    for (var i = 0; i < subscribers.length; i += 3) {
-      child = subscribers[i]
-      callback = subscribers[i + settled]
-
-      if (child) {
-        invokeCallback(settled, child, callback, detail)
-      } else {
-        callback(detail)
-      }
-    }
-
-    promise._subscribers.length = 0
-  }
-
-  function invokeCallback(settled, promise, callback, detail) {
-    var hasCallback = isFunction(callback),
-      value = void 0,
-      error = void 0,
-      succeeded = true
-
-    if (hasCallback) {
-      try {
-        value = callback(detail)
-      } catch (e) {
-        succeeded = false
-        error = e
-      }
-
-      if (promise === value) {
-        reject(promise, cannotReturnOwn())
-        return
-      }
-    } else {
-      value = detail
-    }
-
-    if (promise._state !== PENDING) {
-      // noop
-    } else if (hasCallback && succeeded) {
-      resolve(promise, value)
-    } else if (succeeded === false) {
-      reject(promise, error)
-    } else if (settled === FULFILLED) {
-      fulfill(promise, value)
-    } else if (settled === REJECTED) {
-      reject(promise, value)
-    }
-  }
-
-  function initializePromise(promise, resolver) {
-    try {
-      resolver(
-        function resolvePromise(value) {
-          resolve(promise, value)
-        },
-        function rejectPromise(reason) {
-          reject(promise, reason)
-        }
-      )
-    } catch (e) {
-      reject(promise, e)
-    }
-  }
-
-  var id = 0
-  function nextId() {
-    return id++
-  }
-
-  function makePromise(promise) {
-    promise[PROMISE_ID] = id++
-    promise._state = undefined
-    promise._result = undefined
-    promise._subscribers = []
-  }
-
-  function validationError() {
-    return new Error('Array Methods must be provided an Array')
-  }
-
-  var Enumerator = (function () {
-    function Enumerator(Constructor, input) {
-      this._instanceConstructor = Constructor
-      this.promise = new Constructor(noop)
-
-      if (!this.promise[PROMISE_ID]) {
-        makePromise(this.promise)
-      }
-
-      if (isArray(input)) {
-        this.length = input.length
-        this._remaining = input.length
-
-        this._result = new Array(this.length)
-
-        if (this.length === 0) {
-          fulfill(this.promise, this._result)
-        } else {
-          this.length = this.length || 0
-          this._enumerate(input)
-          if (this._remaining === 0) {
-            fulfill(this.promise, this._result)
-          }
-        }
-      } else {
-        reject(this.promise, validationError())
-      }
-    }
-
-    Enumerator.prototype._enumerate = function _enumerate(input) {
-      for (var i = 0; this._state === PENDING && i < input.length; i++) {
-        this._eachEntry(input[i], i)
-      }
-    }
-
-    Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
-      var c = this._instanceConstructor
-      var resolve$$1 = c.resolve
-
-      if (resolve$$1 === resolve$1) {
-        var _then = void 0
-        var error = void 0
-        var didError = false
-        try {
-          _then = entry.then
-        } catch (e) {
-          didError = true
-          error = e
-        }
-
-        if (_then === then && entry._state !== PENDING) {
-          this._settledAt(entry._state, i, entry._result)
-        } else if (typeof _then !== 'function') {
-          this._remaining--
-          this._result[i] = entry
-        } else if (c === Promise$1) {
-          var promise = new c(noop)
-          if (didError) {
-            reject(promise, error)
-          } else {
-            handleMaybeThenable(promise, entry, _then)
-          }
-          this._willSettleAt(promise, i)
-        } else {
-          this._willSettleAt(
-            new c(function (resolve$$1) {
-              return resolve$$1(entry)
-            }),
-            i
-          )
-        }
-      } else {
-        this._willSettleAt(resolve$$1(entry), i)
-      }
-    }
-
-    Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
-      var promise = this.promise
-
-      if (promise._state === PENDING) {
-        this._remaining--
-
-        if (state === REJECTED) {
-          reject(promise, value)
-        } else {
-          this._result[i] = value
-        }
-      }
-
-      if (this._remaining === 0) {
-        fulfill(promise, this._result)
-      }
-    }
-
-    Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
-      var enumerator = this
-
-      subscribe(
-        promise,
-        undefined,
-        function (value) {
-          return enumerator._settledAt(FULFILLED, i, value)
-        },
-        function (reason) {
-          return enumerator._settledAt(REJECTED, i, reason)
-        }
-      )
-    }
-
-    return Enumerator
-  })()
-
-  /**
-  `Promise.all` accepts an array of promises, and returns a new promise which
-  is fulfilled with an array of fulfillment values for the passed promises, or
-  rejected with the reason of the first passed promise to be rejected. It casts all
-  elements of the passed iterable to promises as it runs this algorithm.
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = resolve(2);
-  let promise3 = resolve(3);
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // The array here would be [ 1, 2, 3 ];
-  });
-  ```
-
-  If any of the `promises` given to `all` are rejected, the first promise
-  that is rejected will be given as an argument to the returned promises's
-  rejection handler. For example:
-
-  Example:
-
-  ```javascript
-  let promise1 = resolve(1);
-  let promise2 = reject(new Error("2"));
-  let promise3 = reject(new Error("3"));
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // Code here never runs because there are rejected promises!
-  }, function(error) {
-    // error.message === "2"
-  });
-  ```
-
-  @method all
-  @static
-  @param {Array} entries array of promises
-  @param {String} label optional string for labeling the promise.
-  Useful for tooling.
-  @return {Promise} promise that is fulfilled when all `promises` have been
-  fulfilled, or rejected if any of them become rejected.
-  @static
-*/
-  function all(entries) {
-    return new Enumerator(this, entries).promise
-  }
-
-  /**
-  `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.
-*/
-  function race(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.reject` returns a promise rejected with the passed `reason`.
-  It is shorthand for the following:
-
-  ```javascript
-  let promise = new Promise(function(resolve, reject){
-    reject(new Error('WHOOPS'));
-  });
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  let promise = Promise.reject(new Error('WHOOPS'));
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  @method reject
-  @static
-  @param {Any} reason value that the returned promise will be rejected with.
-  Useful for tooling.
-  @return {Promise} a promise rejected with the given `reason`.
-*/
-  function reject$1(reason) {
-    /*jshint validthis:true */
-    var Constructor = this
-    var promise = new Constructor(noop)
-    reject(promise, reason)
-    return promise
-  }
-
-  function needsResolver() {
-    throw new TypeError(
-      'You must pass a resolver function as the first argument to the promise constructor'
-    )
-  }
-
-  function needsNew() {
-    throw new TypeError(
-      "Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."
-    )
-  }
-
-  /**
-  Promise objects represent the eventual result of an asynchronous operation. The
-  primary way of interacting with a promise is through its `then` method, which
-  registers callbacks to receive either a promise's eventual value or the reason
-  why the promise cannot be fulfilled.
-
-  Terminology
-  -----------
-
-  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-  - `thenable` is an object or function that defines a `then` method.
-  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-  - `exception` is a value that is thrown using the throw statement.
-  - `reason` is a value that indicates why a promise was rejected.
-  - `settled` the final resting state of a promise, fulfilled or rejected.
-
-  A promise can be in one of three states: pending, fulfilled, or rejected.
-
-  Promises that are fulfilled have a fulfillment value and are in the fulfilled
-  state.  Promises that are rejected have a rejection reason and are in the
-  rejected state.  A fulfillment value is never a thenable.
-
-  Promises can also be said to *resolve* a value.  If this value is also a
-  promise, then the original promise's settled state will match the value's
-  settled state.  So a promise that *resolves* a promise that rejects will
-  itself reject, and a promise that *resolves* a promise that fulfills will
-  itself fulfill.
-
-
-  Basic Usage:
-  ------------
-
-  ```js
-  let promise = new Promise(function(resolve, reject) {
-    // on success
-    resolve(value);
-
-    // on failure
-    reject(reason);
-  });
-
-  promise.then(function(value) {
-    // on fulfillment
-  }, function(reason) {
-    // on rejection
-  });
-  ```
-
-  Advanced Usage:
-  ---------------
-
-  Promises shine when abstracting away asynchronous interactions such as
-  `XMLHttpRequest`s.
-
-  ```js
-  function getJSON(url) {
-    return new Promise(function(resolve, reject){
-      let xhr = new XMLHttpRequest();
-
-      xhr.open('GET', url);
-      xhr.onreadystatechange = handler;
-      xhr.responseType = 'json';
-      xhr.setRequestHeader('Accept', 'application/json');
-      xhr.send();
-
-      function handler() {
-        if (this.readyState === this.DONE) {
-          if (this.status === 200) {
-            resolve(this.response);
-          } else {
-            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-          }
-        }
-      };
-    });
-  }
-
-  getJSON('/posts.json').then(function(json) {
-    // on fulfillment
-  }, function(reason) {
-    // on rejection
-  });
-  ```
-
-  Unlike callbacks, promises are great composable primitives.
-
-  ```js
-  Promise.all([
-    getJSON('/posts'),
-    getJSON('/comments')
-  ]).then(function(values){
-    values[0] // => postsJSON
-    values[1] // => commentsJSON
-
-    return values;
-  });
-  ```
-
-  @class Promise
-  @param {Function} resolver
-  Useful for tooling.
-  @constructor
-*/
-
-  var Promise$1 = (function () {
-    function Promise(resolver) {
-      this[PROMISE_ID] = nextId()
-      this._result = this._state = undefined
-      this._subscribers = []
-
-      if (noop !== resolver) {
-        typeof resolver !== 'function' && needsResolver()
-        this instanceof Promise ? initializePromise(this, resolver) : needsNew()
-      }
-    }
-
-    /**
-  The primary way of interacting with a promise is through its `then` method,
-  which registers callbacks to receive either a promise's eventual value or the
-  reason why the promise cannot be fulfilled.
-   ```js
-  findUser().then(function(user){
-    // user is available
-  }, function(reason){
-    // user is unavailable, and you are given the reason why
-  });
-  ```
-   Chaining
-  --------
-   The return value of `then` is itself a promise.  This second, 'downstream'
-  promise is resolved with the return value of the first promise's fulfillment
-  or rejection handler, or rejected if the handler throws an exception.
-   ```js
-  findUser().then(function (user) {
-    return user.name;
-  }, function (reason) {
-    return 'default name';
-  }).then(function (userName) {
-    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-    // will be `'default name'`
-  });
-   findUser().then(function (user) {
-    throw new Error('Found user, but still unhappy');
-  }, function (reason) {
-    throw new Error('`findUser` rejected and we're unhappy');
-  }).then(function (value) {
-    // never reached
-  }, function (reason) {
-    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
-  });
-  ```
-  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-   ```js
-  findUser().then(function (user) {
-    throw new PedagogicalException('Upstream error');
-  }).then(function (value) {
-    // never reached
-  }).then(function (value) {
-    // never reached
-  }, function (reason) {
-    // The `PedgagocialException` is propagated all the way down to here
-  });
-  ```
-   Assimilation
-  ------------
-   Sometimes the value you want to propagate to a downstream promise can only be
-  retrieved asynchronously. This can be achieved by returning a promise in the
-  fulfillment or rejection handler. The downstream promise will then be pending
-  until the returned promise is settled. This is called *assimilation*.
-   ```js
-  findUser().then(function (user) {
-    return findCommentsByAuthor(user);
-  }).then(function (comments) {
-    // The user's comments are now available
-  });
-  ```
-   If the assimliated promise rejects, then the downstream promise will also reject.
-   ```js
-  findUser().then(function (user) {
-    return findCommentsByAuthor(user);
-  }).then(function (comments) {
-    // If `findCommentsByAuthor` fulfills, we'll have the value here
-  }, function (reason) {
-    // If `findCommentsByAuthor` rejects, we'll have the reason here
-  });
-  ```
-   Simple Example
-  --------------
-   Synchronous Example
-   ```javascript
-  let result;
-   try {
-    result = findResult();
-    // success
-  } catch(reason) {
-    // failure
-  }
-  ```
-   Errback Example
-   ```js
-  findResult(function(result, err){
-    if (err) {
-      // failure
-    } else {
-      // success
-    }
-  });
-  ```
-   Promise Example;
-   ```javascript
-  findResult().then(function(result){
-    // success
-  }, function(reason){
-    // failure
-  });
-  ```
-   Advanced Example
-  --------------
-   Synchronous Example
-   ```javascript
-  let author, books;
-   try {
-    author = findAuthor();
-    books  = findBooksByAuthor(author);
-    // success
-  } catch(reason) {
-    // failure
-  }
-  ```
-   Errback Example
-   ```js
-   function foundBooks(books) {
-   }
-   function failure(reason) {
-   }
-   findAuthor(function(author, err){
-    if (err) {
-      failure(err);
-      // failure
-    } else {
-      try {
-        findBoooksByAuthor(author, function(books, err) {
-          if (err) {
-            failure(err);
-          } else {
-            try {
-              foundBooks(books);
-            } catch(reason) {
-              failure(reason);
-            }
-          }
-        });
-      } catch(error) {
-        failure(err);
-      }
-      // success
-    }
-  });
-  ```
-   Promise Example;
-   ```javascript
-  findAuthor().
-    then(findBooksByAuthor).
-    then(function(books){
-      // found books
-  }).catch(function(reason){
-    // something went wrong
-  });
-  ```
-   @method then
-  @param {Function} onFulfilled
-  @param {Function} onRejected
-  Useful for tooling.
-  @return {Promise}
-  */
-
-    /**
-  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-  as the catch block of a try/catch statement.
-  ```js
-  function findAuthor(){
-  throw new Error('couldn't find that author');
-  }
-  // synchronous
-  try {
-  findAuthor();
-  } catch(reason) {
-  // something went wrong
-  }
-  // async with promises
-  findAuthor().catch(function(reason){
-  // something went wrong
-  });
-  ```
-  @method catch
-  @param {Function} onRejection
-  Useful for tooling.
-  @return {Promise}
-  */
-
-    Promise.prototype.catch = function _catch(onRejection) {
-      return this.then(null, onRejection)
-    }
-
-    /**
-    `finally` will be invoked regardless of the promise's fate just as native
-    try/catch/finally behaves
-  
-    Synchronous example:
-  
-    ```js
-    findAuthor() {
-      if (Math.random() > 0.5) {
-        throw new Error();
-      }
-      return new Author();
-    }
-  
-    try {
-      return findAuthor(); // succeed or fail
-    } catch(error) {
-      return findOtherAuther();
-    } finally {
-      // always runs
-      // doesn't affect the return value
-    }
-    ```
-  
-    Asynchronous example:
-  
-    ```js
-    findAuthor().catch(function(reason){
-      return findOtherAuther();
-    }).finally(function(){
-      // author was either found, or not
-    });
-    ```
-  
-    @method finally
-    @param {Function} callback
-    @return {Promise}
-  */
-
-    Promise.prototype.finally = function _finally(callback) {
-      var promise = this
-      var constructor = promise.constructor
-
-      if (isFunction(callback)) {
-        return promise.then(
-          function (value) {
-            return constructor.resolve(callback()).then(function () {
-              return value
-            })
-          },
-          function (reason) {
-            return constructor.resolve(callback()).then(function () {
-              throw reason
-            })
-          }
-        )
-      }
-
-      return promise.then(callback, callback)
-    }
-
-    return Promise
-  })()
-
-  Promise$1.prototype.then = then
-  Promise$1.all = all
-  Promise$1.race = race
-  Promise$1.resolve = resolve$1
-  Promise$1.reject = reject$1
-  Promise$1._setScheduler = setScheduler
-  Promise$1._setAsap = setAsap
-  Promise$1._asap = asap
-  Promise$1.debug = function _debug() {
-    return '[object ES6Promise]'
-  }
-
-  /*global self*/
-  function polyfill() {
-    var local = globalThis
-
-    local.Promise = Promise$1
-  }
-
-  // Strange compat..
-  Promise$1.polyfill = polyfill
-  Promise$1.Promise = Promise$1
-
-  return Promise$1
-})
-
-//# sourceMappingURL=es6-promise.map