RSVP bundled with smarter variable renaming

rsvp.bundle.js

(function() {
  function objectOrFunction(x) {
    return typeof x === 'function' || (typeof x === 'object' && x !== null);
  }

  function isFunction(x) {
    return typeof x === 'function';
  }

  function isMaybeThenable(x) {
    return typeof x === 'object' && x !== null;
  }

  var _isArray;
  if (!Array.isArray) {
    _isArray = function (x) {
      return Object.prototype.toString.call(x) === '[object Array]';
    };
  } else {
    _isArray = Array.isArray;
  }

  var isArray = _isArray;

  var now = Date.now || function() { return new Date().getTime(); };

  function F() { }

  var o_create = (Object.create || function (o) {
    if (arguments.length > 1) {
      throw new Error('Second argument not supported');
    }
    if (typeof o !== 'object') {
      throw new TypeError('Argument must be an object');
    }
    F.prototype = o;
    return new F();
  });
  function indexOf(callbacks, callback) {
    for (var i=0, l=callbacks.length; i<l; i++) {
      if (callbacks[i] === callback) { return i; }
    }

    return -1;
  }

  function callbacksFor(object) {
    var callbacks = object._promiseCallbacks;

    if (!callbacks) {
      callbacks = object._promiseCallbacks = {};
    }

    return callbacks;
  }

  var $DefaultExport = {

    /**
      `RSVP.EventTarget.mixin` extends an object with EventTarget methods. For
      Example:

      ```javascript
      var object = {};

      RSVP.EventTarget.mixin(object);

      object.on('finished', function(event) {
        // handle event
      });

      object.trigger('finished', { detail: value });
      ```

      `EventTarget.mixin` also works with prototypes:

      ```javascript
      var Person = function() {};
      RSVP.EventTarget.mixin(Person.prototype);

      var yehuda = new Person();
      var tom = new Person();

      yehuda.on('poke', function(event) {
        console.log('Yehuda says OW');
      });

      tom.on('poke', function(event) {
        console.log('Tom says OW');
      });

      yehuda.trigger('poke');
      tom.trigger('poke');
      ```

      @method mixin
      @for RSVP.EventTarget
      @private
      @param {Object} object object to extend with EventTarget methods
    */
    'mixin': function(object) {
      object['on']      = this['on'];
      object['off']     = this['off'];
      object['trigger'] = this['trigger'];
      object._promiseCallbacks = undefined;
      return object;
    },

    /**
      Registers a callback to be executed when `eventName` is triggered

      ```javascript
      object.on('event', function(eventInfo){
        // handle the event
      });

      object.trigger('event');
      ```

      @method on
      @for RSVP.EventTarget
      @private
      @param {String} eventName name of the event to listen for
      @param {Function} callback function to be called when the event is triggered.
    */
    'on': function(eventName, callback) {
      var allCallbacks = callbacksFor(this), callbacks;

      callbacks = allCallbacks[eventName];

      if (!callbacks) {
        callbacks = allCallbacks[eventName] = [];
      }

      if (indexOf(callbacks, callback) === -1) {
        callbacks.push(callback);
      }
    },

    /**
      You can use `off` to stop firing a particular callback for an event:

      ```javascript
      function doStuff() { // do stuff! }
      object.on('stuff', doStuff);

      object.trigger('stuff'); // doStuff will be called

      // Unregister ONLY the doStuff callback
      object.off('stuff', doStuff);
      object.trigger('stuff'); // doStuff will NOT be called
      ```

      If you don't pass a `callback` argument to `off`, ALL callbacks for the
      event will not be executed when the event fires. For example:

      ```javascript
      var callback1 = function(){};
      var callback2 = function(){};

      object.on('stuff', callback1);
      object.on('stuff', callback2);

      object.trigger('stuff'); // callback1 and callback2 will be executed.

      object.off('stuff');
      object.trigger('stuff'); // callback1 and callback2 will not be executed!
      ```

      @method off
      @for RSVP.EventTarget
      @private
      @param {String} eventName event to stop listening to
      @param {Function} callback optional argument. If given, only the function
      given will be removed from the event's callback queue. If no `callback`
      argument is given, all callbacks will be removed from the event's callback
      queue.
    */
    'off': function(eventName, callback) {
      var allCallbacks = callbacksFor(this), callbacks, index;

      if (!callback) {
        allCallbacks[eventName] = [];
        return;
      }

      callbacks = allCallbacks[eventName];

      index = indexOf(callbacks, callback);

      if (index !== -1) { callbacks.splice(index, 1); }
    },

    /**
      Use `trigger` to fire custom events. For example:

      ```javascript
      object.on('foo', function(){
        console.log('foo event happened!');
      });
      object.trigger('foo');
      // 'foo event happened!' logged to the console
      ```

      You can also pass a value as a second argument to `trigger` that will be
      passed as an argument to all event listeners for the event:

      ```javascript
      object.on('foo', function(value){
        console.log(value.name);
      });

      object.trigger('foo', { name: 'bar' });
      // 'bar' logged to the console
      ```

      @method trigger
      @for RSVP.EventTarget
      @private
      @param {String} eventName name of the event to be triggered
      @param {Any} options optional value to be passed to any event handlers for
      the given `eventName`
    */
    'trigger': function(eventName, options) {
      var allCallbacks = callbacksFor(this), callbacks, callback;

      if (callbacks = allCallbacks[eventName]) {
        // Don't cache the callbacks.length since it may grow
        for (var i=0; i<callbacks.length; i++) {
          callback = callbacks[i];

          callback(options);
        }
      }
    }
  };

  var config = {
    instrument: false
  };

  $DefaultExport['mixin'](config);

  function configure(name, value) {
    if (name === 'onerror') {
      // handle for legacy users that expect the actual
      // error to be passed to their function added via
      // `RSVP.configure('onerror', someFunctionHere);`
      config['on']('error', value);
      return;
    }

    if (arguments.length === 2) {
      config[name] = value;
    } else {
      return config[name];
    }
  }

  var $instrument$$queue = [];

  function $instrument$$scheduleFlush() {
    setTimeout(function() {
      var entry;
      for (var i = 0; i < $instrument$$queue.length; i++) {
        entry = $instrument$$queue[i];

        var payload = entry.payload;

        payload.guid = payload.key + payload.id;
        payload.childGuid = payload.key + payload.childId;
        if (payload.error) {
          payload.stack = payload.error.stack;
        }

        config['trigger'](entry.name, entry.payload);
      }
      $instrument$$queue.length = 0;
    }, 50);
  }

  function instrument(eventName, promise, child) {
    if (1 === $instrument$$queue.push({
        name: eventName,
        payload: {
          key: promise._guidKey,
          id:  promise._id,
          eventName: eventName,
          detail: promise._result,
          childId: child && child._id,
          label: promise._label,
          timeStamp: now(),
          error: config["instrument-with-stack"] ? new Error(promise._label) : null
        }})) {
          $instrument$$scheduleFlush();
        }
    }

  function  withOwnPromise() {
    return new TypeError('A promises callback cannot return that same promise.');
  }

  function noop() {}

  var PENDING   = void 0;
  var FULFILLED = 1;
  var REJECTED  = 2;

  var $internal$$GET_THEN_ERROR = new ErrorObject();

  function $internal$$getThen(promise) {
    try {
      return promise.then;
    } catch(error) {
      $internal$$GET_THEN_ERROR.error = error;
      return $internal$$GET_THEN_ERROR;
    }
  }

  function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
    try {
      then.call(value, fulfillmentHandler, rejectionHandler);
    } catch(e) {
      return e;
    }
  }

  function handleForeignThenable(promise, thenable, then) {
    config.async(function(promise) {
      var sealed = false;
      var error = tryThen(then, thenable, function(value) {
        if (sealed) { return; }
        sealed = true;
        if (thenable !== value) {
          $internal$$resolve(promise, value);
        } else {
          fulfill(promise, value);
        }
      }, function(reason) {
        if (sealed) { return; }
        sealed = true;

        $internal$$reject(promise, reason);
      }, 'Settle: ' + (promise._label || ' unknown promise'));

      if (!sealed && error) {
        sealed = true;
        $internal$$reject(promise, error);
      }
    }, promise);
  }

  function handleOwnThenable(promise, thenable) {
    if (thenable._state === FULFILLED) {
      fulfill(promise, thenable._result);
    } else if (thenable._state === REJECTED) {
      thenable._onError = null;
      $internal$$reject(promise, thenable._result);
    } else {
      subscribe(thenable, undefined, function(value) {
        if (thenable !== value) {
          $internal$$resolve(promise, value);
        } else {
          fulfill(promise, value);
        }
      }, function(reason) {
        $internal$$reject(promise, reason);
      });
    }
  }

  function handleMaybeThenable(promise, maybeThenable) {
    if (maybeThenable.constructor === promise.constructor) {
      handleOwnThenable(promise, maybeThenable);
    } else {
      var then = $internal$$getThen(maybeThenable);

      if (then === $internal$$GET_THEN_ERROR) {
        $internal$$reject(promise, $internal$$GET_THEN_ERROR.error);
      } else if (then === undefined) {
        fulfill(promise, maybeThenable);
      } else if (isFunction(then)) {
        handleForeignThenable(promise, maybeThenable, then);
      } else {
        fulfill(promise, maybeThenable);
      }
    }
  }

  function $internal$$resolve(promise, value) {
    if (promise === value) {
      fulfill(promise, value);
    } else if (objectOrFunction(value)) {
      handleMaybeThenable(promise, value);
    } 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) {
      if (config.instrument) {
        instrument('fulfilled', promise);
      }
    } else {
      config.async(publish, promise);
    }
  }

  function $internal$$reject(promise, reason) {
    if (promise._state !== PENDING) { return; }
    promise._state = REJECTED;
    promise._result = reason;
    config.async(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) {
      config.async(publish, parent);
    }
  }

  function publish(promise) {
    var subscribers = promise._subscribers;
    var settled = promise._state;

    if (config.instrument) {
      instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
    }

    if (subscribers.length === 0) { return; }

    var child, callback, 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 ErrorObject() {
    this.error = null;
  }

  var TRY_CATCH_ERROR = new ErrorObject();

  function tryCatch(callback, detail) {
    try {
      return callback(detail);
    } catch(e) {
      TRY_CATCH_ERROR.error = e;
      return TRY_CATCH_ERROR;
    }
  }

  function invokeCallback(settled, promise, callback, detail) {
    var hasCallback = isFunction(callback),
        value, error, succeeded, failed;

    if (hasCallback) {
      value = tryCatch(callback, detail);

      if (value === TRY_CATCH_ERROR) {
        failed = true;
        error = value.error;
        value = null;
      } else {
        succeeded = true;
      }

      if (promise === value) {
        $internal$$reject(promise, withOwnPromise());
        return;
      }

    } else {
      value = detail;
      succeeded = true;
    }

    if (promise._state !== PENDING) {
      // noop
    } else if (hasCallback && succeeded) {
      $internal$$resolve(promise, value);
    } else if (failed) {
      $internal$$reject(promise, error);
    } else if (settled === FULFILLED) {
      fulfill(promise, value);
    } else if (settled === REJECTED) {
      $internal$$reject(promise, value);
    }
  }

  function initializePromise(promise, resolver) {
    var resolved = false;
    try {
      resolver(function resolvePromise(value){
        if (resolved) { return; }
        resolved = true;
        $internal$$resolve(promise, value);
      }, function rejectPromise(reason) {
        if (resolved) { return; }
        resolved = true;
        $internal$$reject(promise, reason);
      });
    } catch(e) {
      $internal$$reject(promise, e);
    }
  }

  function $promise$reject$$reject(reason, label) {
    /*jshint validthis:true */
    var Constructor = this;
    var promise = new Constructor(noop, label);
    $internal$$reject(promise, reason);
    return promise;
  }
  function rethrow(reason) {
    setTimeout(function() {
      throw reason;
    });
    throw reason;
  }
  function makeSettledResult(state, position, value) {
    if (state === FULFILLED) {
      return {
        state: 'fulfilled',
        value: value
      };
    } else {
      return {
        state: 'rejected',
        reason: value
      };
    }
  }

  function Enumerator(Constructor, input, abortOnReject, label) {
    this._instanceConstructor = Constructor;
    this.promise = new Constructor(noop, label);
    this._abortOnReject = abortOnReject;

    if (this._validateInput(input)) {
      this._input     = input;
      this.length     = input.length;
      this._remaining = input.length;

      this._init();

      if (this.length === 0) {
        fulfill(this.promise, this._result);
      } else {
        this.length = this.length || 0;
        this._enumerate();
        if (this._remaining === 0) {
          fulfill(this.promise, this._result);
        }
      }
    } else {
      $internal$$reject(this.promise, this._validationError());
    }
  }

  Enumerator.prototype._validateInput = function(input) {
    return isArray(input);
  };

  Enumerator.prototype._validationError = function() {
    return new Error('Array Methods must be provided an Array');
  };

  Enumerator.prototype._init = function() {
    this._result = new Array(this.length);
  };

  Enumerator.prototype._enumerate = function() {
    var length  = this.length;
    var promise = this.promise;
    var input   = this._input;

    for (var i = 0; promise._state === PENDING && i < length; i++) {
      this._eachEntry(input[i], i);
    }
  };

  Enumerator.prototype._eachEntry = function(entry, i) {
    var c = this._instanceConstructor;
    if (isMaybeThenable(entry)) {
      if (entry.constructor === c && entry._state !== PENDING) {
        entry._onError = null;
        this._settledAt(entry._state, i, entry._result);
      } else {
        this._willSettleAt(c.resolve(entry), i);
      }
    } else {
      this._remaining--;
      this._result[i] = this._makeResult(FULFILLED, i, entry);
    }
  };

  Enumerator.prototype._settledAt = function(state, i, value) {
    var promise = this.promise;

    if (promise._state === PENDING) {
      this._remaining--;

      if (this._abortOnReject && state === REJECTED) {
        $internal$$reject(promise, value);
      } else {
        this._result[i] = this._makeResult(state, i, value);
      }
    }

    if (this._remaining === 0) {
      fulfill(promise, this._result);
    }
  };

  Enumerator.prototype._makeResult = function(state, i, value) {
    return value;
  };

  Enumerator.prototype._willSettleAt = function(promise, i) {
    var enumerator = this;

    subscribe(promise, undefined, function(value) {
      enumerator._settledAt(FULFILLED, i, value);
    }, function(reason) {
      enumerator._settledAt(REJECTED, i, reason);
    });
  };
  function $promise$all$$all(entries, label) {
    return new Enumerator(this, entries, true /* abort on reject */, label).promise;
  }
  function $promise$race$$race(entries, label) {
    /*jshint validthis:true */
    var Constructor = this;

    var promise = new Constructor(noop, label);

    if (!isArray(entries)) {
      $internal$$reject(promise, new TypeError('You must pass an array to race.'));
      return promise;
    }

    var length = entries.length;

    function onFulfillment(value) {
      $internal$$resolve(promise, value);
    }

    function onRejection(reason) {
      $internal$$reject(promise, reason);
    }

    for (var i = 0; promise._state === PENDING && i < length; i++) {
      subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
    }

    return promise;
  }
  function $promise$resolve$$resolve(object, label) {
    /*jshint validthis:true */
    var Constructor = this;

    if (object && typeof object === 'object' && object.constructor === Constructor) {
      return object;
    }

    var promise = new Constructor(noop, label);
    $internal$$resolve(promise, object);
    return promise;
  }

  var guidKey = 'rsvp_' + now() + '-';
  var counter = 0;

  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
    var 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){
        var 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 RSVP.Promise
    @param {function} resolver
    @param {String} label optional string for labeling the promise.
    Useful for tooling.
    @constructor
  */
  function Promise(resolver, label) {
    this._id = counter++;
    this._label = label;
    this._state = undefined;
    this._result = undefined;
    this._subscribers = [];

    if (config.instrument) {
      instrument('created', this);
    }

    if (noop !== resolver) {
      if (!isFunction(resolver)) {
        needsResolver();
      }

      if (!(this instanceof Promise)) {
        needsNew();
      }

      initializePromise(this, resolver);
    }
  }

  // deprecated
  Promise.cast = $promise$resolve$$resolve;
  Promise.all = $promise$all$$all;
  Promise.race = $promise$race$$race;
  Promise.resolve = $promise$resolve$$resolve;
  Promise.reject = $promise$reject$$reject;

  Promise.prototype = {
    constructor: Promise,

    _guidKey: guidKey,

    _onError: function (reason) {
      config.async(function(promise) {
        setTimeout(function() {
          if (promise._onError) {
            config['trigger']('error', reason);
          }
        }, 0);
      }, this);
    },

  /**
    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
    var 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
    var 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
    @param {String} label optional string for labeling the promise.
    Useful for tooling.
    @return {Promise}
  */
    then: function(onFulfillment, onRejection, label) {
      var parent = this;
      var state = parent._state;

      if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
        if (config.instrument) {
          instrument('chained', this, this);
        }
        return this;
      }

      parent._onError = null;

      var child = new this.constructor(noop, label);
      var result = parent._result;

      if (config.instrument) {
        instrument('chained', parent, child);
      }

      if (state) {
        var callback = arguments[state - 1];
        config.async(function(){
          invokeCallback(state, child, callback, result);
        });
      } else {
        subscribe(parent, child, onFulfillment, onRejection);
      }

      return child;
    },

  /**
    `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
    @param {String} label optional string for labeling the promise.
    Useful for tooling.
    @return {Promise}
  */
    'catch': function(onRejection, label) {
      return this.then(null, onRejection, label);
    },

  /**
    `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
    @param {String} label optional string for labeling the promise.
    Useful for tooling.
    @return {Promise}
  */
    'finally': function(callback, label) {
      var constructor = this.constructor;

      return this.then(function(value) {
        return constructor.resolve(callback()).then(function(){
          return value;
        });
      }, function(reason) {
        return constructor.resolve(callback()).then(function(){
          throw reason;
        });
      }, label);
    }
  };
  function defer(label) {
    var deferred = { };

    deferred['promise'] = new Promise(function(resolve, reject) {
      deferred['resolve'] = resolve;
      deferred['reject'] = reject;
    }, label);

    return deferred;
  }
  function $race$$race(array, label) {
    return Promise.race(array, label);
  }

  function AllSettled(Constructor, entries, label) {
    this._superConstructor(Constructor, entries, false /* don't abort on reject */, label);
  }

  AllSettled.prototype = o_create(Enumerator.prototype);
  AllSettled.prototype._superConstructor = Enumerator;
  AllSettled.prototype._makeResult = makeSettledResult;
  AllSettled.prototype._validationError = function() {
    return new Error('allSettled must be called with an array');
  };

  function allSettled(entries, label) {
    return new AllSettled(Promise, entries, label).promise;
  }

  function PromiseHash(Constructor, object, label) {
    this._superConstructor(Constructor, object, true, label);
  }

  PromiseHash.prototype = o_create(Enumerator.prototype);
  PromiseHash.prototype._superConstructor = Enumerator;
  PromiseHash.prototype._init = function() {
    this._result = {};
  };

  PromiseHash.prototype._validateInput = function(input) {
    return input && typeof input === 'object';
  };

  PromiseHash.prototype._validationError = function() {
    return new Error('Promise.hash must be called with an object');
  };

  PromiseHash.prototype._enumerate = function() {
    var promise = this.promise;
    var input   = this._input;
    var results = [];

    for (var key in input) {
      if (promise._state === PENDING && input.hasOwnProperty(key)) {
        results.push({
          position: key,
          entry: input[key]
        });
      }
    }

    var length = results.length;
    this._remaining = length;
    var result;

    for (var i = 0; promise._state === PENDING && i < length; i++) {
      result = results[i];
      this._eachEntry(result.entry, result.position);
    }
  };
  function hash(object, label) {
    return new PromiseHash(Promise, object, label).promise;
  }
  function $resolve$$resolve(value, label) {
    return Promise.resolve(value, label);
  }

  function Result() {
    this.value = undefined;
  }

  var ERROR = new Result();
  var $node$$GET_THEN_ERROR = new Result();

  function $node$$getThen(obj) {
    try {
     return obj.then;
    } catch(error) {
      ERROR.value= error;
      return ERROR;
    }
  }


  function tryApply(f, s, a) {
    try {
      f.apply(s, a);
    } catch(error) {
      ERROR.value = error;
      return ERROR;
    }
  }

  function makeObject(_, argumentNames) {
    var obj = {};
    var name;
    var i;
    var length = _.length;
    var args = new Array(length);

    for (var x = 0; x < length; x++) {
      args[x] = _[x];
    }

    for (i = 0; i < argumentNames.length; i++) {
      name = argumentNames[i];
      obj[name] = args[i + 1];
    }

    return obj;
  }

  function arrayResult(_) {
    var length = _.length;
    var args = new Array(length - 1);

    for (var i = 1; i < length; i++) {
      args[i - 1] = _[i];
    }

    return args;
  }

  function wrapThenable(then, promise) {
    return {
      then: function(onFulFillment, onRejection) {
        return then.call(promise, onFulFillment, onRejection);
      }
    };
  }

  function denodeify(nodeFunc, options) {
    var fn = function() {
      var self = this;
      var l = arguments.length;
      var args = new Array(l + 1);
      var arg;
      var promiseInput = false;

      for (var i = 0; i < l; ++i) {
        arg = arguments[i];

        if (!promiseInput) {
          // TODO: clean this up
          promiseInput = needsPromiseInput(arg);
          if (promiseInput === $node$$GET_THEN_ERROR) {
            var p = new Promise(noop);
            $internal$$reject(p, $node$$GET_THEN_ERROR.value);
            return p;
          } else if (promiseInput && promiseInput !== true) {
            arg = wrapThenable(promiseInput, arg);
          }
        }
        args[i] = arg;
      }

      var promise = new Promise(noop);

      args[l] = function(err, val) {
        if (err)
          $internal$$reject(promise, err);
        else if (options === undefined)
          $internal$$resolve(promise, val);
        else if (options === true)
          $internal$$resolve(promise, arrayResult(arguments));
        else if (isArray(options))
          $internal$$resolve(promise, makeObject(arguments, options));
        else
          $internal$$resolve(promise, val);
      };

      if (promiseInput) {
        return handlePromiseInput(promise, args, nodeFunc, self);
      } else {
        return handleValueInput(promise, args, nodeFunc, self);
      }
    };

    fn.__proto__ = nodeFunc;

    return fn;
  }

  function handleValueInput(promise, args, nodeFunc, self) {
    var result = tryApply(nodeFunc, self, args);
    if (result === ERROR) {
      $internal$$reject(promise, result.value);
    }
    return promise;
  }

  function handlePromiseInput(promise, args, nodeFunc, self){
    return Promise.all(args).then(function(args){
      var result = tryApply(nodeFunc, self, args);
      if (result === ERROR) {
        $internal$$reject(promise, result.value);
      }
      return promise;
    });
  }

  function needsPromiseInput(arg) {
    if (arg && typeof arg === 'object') {
      if (arg.constructor === Promise) {
        return true;
      } else {
        return $node$$getThen(arg);
      }
    } else {
      return false;
    }
  }
  var len = 0;
  var toString = {}.toString;
  var vertxNext;
  function asap(callback, arg) {
    $asap$$queue[len] = callback;
    $asap$$queue[len + 1] = arg;
    len += 2;
    if (len === 2) {
      // If len is 1, 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.
      $asap$$scheduleFlush();
    }
  }

  var browserWindow = (typeof window !== 'undefined') ? window : undefined;
  var browserGlobal = browserWindow || {};
  var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
  var isNode = 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() {
    var nextTick = process.nextTick;
    // node version 0.10.x displays a deprecation warning when nextTick is used recursively
    // setImmediate should be used instead instead
    var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
    if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
      nextTick = setImmediate;
    }
    return function() {
      nextTick(flush);
    };
  }

  // vertx
  function useVertxTimer() {
    return function() {
      vertxNext(flush);
    };
  }

  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 () {
      channel.port2.postMessage(0);
    };
  }

  function useSetTimeout() {
    return function() {
      setTimeout(flush, 1);
    };
  }

  var $asap$$queue = new Array(1000);
  function flush() {
    for (var i = 0; i < len; i+=2) {
      var callback = $asap$$queue[i];
      var arg = $asap$$queue[i+1];

      callback(arg);

      $asap$$queue[i] = undefined;
      $asap$$queue[i+1] = undefined;
    }

    len = 0;
  }

  function attemptVertex() {
    try {
      var r = require;
      var vertx = r('vertx');
      vertxNext = vertx.runOnLoop || vertx.runOnContext;
      return useVertxTimer();
    } catch(e) {
      return useSetTimeout();
    }
  }

  var $asap$$scheduleFlush;
  // Decide what async method to use to triggering processing of queued callbacks:
  if (isNode) {
    $asap$$scheduleFlush = useNextTick();
  } else if (BrowserMutationObserver) {
    $asap$$scheduleFlush = useMutationObserver();
  } else if (isWorker) {
    $asap$$scheduleFlush = useMessageChannel();
  } else if (browserWindow === undefined && typeof require === 'function') {
    $asap$$scheduleFlush = attemptVertex();
  } else {
    $asap$$scheduleFlush = useSetTimeout();
  }
  function $all$$all(array, label) {
    return Promise.all(array, label);
  }
  function $reject$$reject(reason, label) {
    return Promise.reject(reason, label);
  }
  function map(promises, mapFn, label) {
    return Promise.all(promises, label).then(function(values) {
      if (!isFunction(mapFn)) {
        throw new TypeError("You must pass a function as map's second argument.");
      }

      var length = values.length;
      var results = new Array(length);

      for (var i = 0; i < length; i++) {
        results[i] = mapFn(values[i]);
      }

      return Promise.all(results, label);
    });
  }

  function HashSettled(Constructor, object, label) {
    this._superConstructor(Constructor, object, false, label);
  }

  HashSettled.prototype = o_create(PromiseHash.prototype);
  HashSettled.prototype._superConstructor = Enumerator;
  HashSettled.prototype._makeResult = makeSettledResult;

  HashSettled.prototype._validationError = function() {
    return new Error('hashSettled must be called with an object');
  };

  function hashSettled(object, label) {
    return new HashSettled(Promise, object, label).promise;
  }
  function filter(promises, filterFn, label) {
    return Promise.all(promises, label).then(function(values) {
      if (!isFunction(filterFn)) {
        throw new TypeError("You must pass a function as filter's second argument.");
      }

      var length = values.length;
      var filtered = new Array(length);

      for (var i = 0; i < length; i++) {
        filtered[i] = filterFn(values[i]);
      }

      return Promise.all(filtered, label).then(function(filtered) {
        var results = new Array(length);
        var newLength = 0;

        for (var i = 0; i < length; i++) {
          if (filtered[i]) {
            results[newLength] = values[i];
            newLength++;
          }
        }

        results.length = newLength;

        return results;
      });
    });
  }

  // default async is asap;
  config.async = asap;
  var cast = $resolve$$resolve;
  function async(callback, arg) {
    config.async(callback, arg);
  }

  function on() {
    config['on'].apply(config, arguments);
  }

  function off() {
    config['off'].apply(config, arguments);
  }

  // Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
  if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
    var callbacks = window['__PROMISE_INSTRUMENTATION__'];
    configure('instrument', true);
    for (var eventName in callbacks) {
      if (callbacks.hasOwnProperty(eventName)) {
        on(eventName, callbacks[eventName]);
      }
    }
  }

  var RSVP = {
    'race': $race$$race,
    'Promise': Promise,
    'allSettled': allSettled,
    'hash': hash,
    'hashSettled': hashSettled,
    'denodeify': denodeify,
    'on': on,
    'off': off,
    'map': map,
    'filter': filter,
    'resolve': $resolve$$resolve,
    'reject': $reject$$reject,
    'all': $all$$all,
    'rethrow': rethrow,
    'defer': defer,
    'EventTarget': $DefaultExport,
    'configure': configure,
    'async': async
  };

  /* global define:true module:true window: true */
  if (typeof define === 'function' && define['amd']) {
    define(function() { return RSVP; });
  } else if (typeof module !== 'undefined' && module['exports']) {
    module['exports'] = RSVP;
  } else if (typeof this !== 'undefined') {
    this['RSVP'] = RSVP;
  }
})();