Publish build version of rsvp.

.gitignore

@@ -2,4 +2,3 @@
 /promises_tests
 /main.js
 /tmp
-/dist

dist/commonjs/main.js

+"use strict";
+var EventTarget = require("./rsvp/events").EventTarget;
+var CancellationError = require("./rsvp/cancellation_error").CancellationError;
+var Promise = require("./rsvp/promise").Promise;
+var denodeify = require("./rsvp/node").denodeify;
+var __dependency1__ = require("./rsvp/all");
+var all = __dependency1__.all;
+var any = __dependency1__.any;
+var __dependency2__ = require("./rsvp/queue");
+var Queue = __dependency2__.Queue;
+var ResolvedQueueError = __dependency2__.ResolvedQueueError;
+var __dependency3__ = require("./rsvp/timeout");
+var delay = __dependency3__.delay;
+var timeout = __dependency3__.timeout;
+var hash = require("./rsvp/hash").hash;
+var rethrow = require("./rsvp/rethrow").rethrow;
+var defer = require("./rsvp/defer").defer;
+var config = require("./rsvp/config").config;
+var resolve = require("./rsvp/resolve").resolve;
+var reject = require("./rsvp/reject").reject;
+
+function configure(name, value) {
+  config[name] = value;
+}
+
+
+exports.CancellationError = CancellationError;
+exports.Promise = Promise;
+exports.EventTarget = EventTarget;
+exports.all = all;
+exports.any = any;
+exports.Queue = Queue;
+exports.ResolvedQueueError = ResolvedQueueError;
+exports.delay = delay;
+exports.timeout = timeout;
+exports.hash = hash;
+exports.rethrow = rethrow;
+exports.defer = defer;
+exports.denodeify = denodeify;
+exports.configure = configure;
+exports.resolve = resolve;
+exports.reject = reject;
\ No newline at end of file

dist/commonjs/rsvp/all.js

+"use strict";
+var Promise = require("./promise").Promise;
+/* global toString */
+
+
+function promiseAtLeast(expected_count, promises) {
+  if (Object.prototype.toString.call(promises) !== "[object Array]") {
+    throw new TypeError('You must pass an array to all.');
+  }
+
+  function canceller() {
+    var promise;
+    for (var i = 0; i < promises.length; i++) {
+      promise = promises[i];
+
+      if (promise && typeof promise.then === 'function' &&
+          typeof promise.cancel === 'function') {
+        promise.cancel();
+      }
+    }
+  }
+
+  return new Promise(function(resolve, reject, notify) {
+    var results = [], remaining = promises.length,
+    promise, remaining_count = promises.length - expected_count;
+
+    if (remaining === 0) {
+      if (expected_count === 1) {
+        resolve();
+      } else {
+        resolve([]);
+      }
+    }
+
+    function resolver(index) {
+      return function(value) {
+        resolveAll(index, value);
+      };
+    }
+
+    function resolveAll(index, value) {
+      results[index] = value;
+      if (--remaining === remaining_count) {
+        if (remaining_count === 0) {
+          resolve(results);
+        } else {
+          resolve(value);
+          canceller();
+        }
+      }
+    }
+
+    function notifier(index) {
+      return function(value) {
+        notify({"index": index, "value": value});
+      };
+    }
+
+    function cancelAll(rejectionValue) {
+      reject(rejectionValue);
+      canceller();
+    }
+
+    for (var i = 0; i < promises.length; i++) {
+      promise = promises[i];
+
+      if (promise && typeof promise.then === 'function') {
+        promise.then(resolver(i), cancelAll, notifier(i));
+      } else {
+        resolveAll(i, promise);
+      }
+    }
+  }, canceller
+  );
+}
+
+function all(promises) {
+  return promiseAtLeast(promises.length, promises);
+}
+
+function any(promises) {
+  return promiseAtLeast(1, promises);
+}
+
+
+exports.all = all;
+exports.any = any;
\ No newline at end of file

dist/commonjs/rsvp/async.js

+"use strict";
+var browserGlobal = (typeof window !== 'undefined') ? window : {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var async;
+var local = (typeof global !== 'undefined') ? global : this;
+
+// old node
+function useNextTick() {
+  return function(callback, arg) {
+    process.nextTick(function() {
+      callback(arg);
+    });
+  };
+}
+
+// node >= 0.10.x
+function useSetImmediate() {
+  return function(callback, arg) {
+    /* global  setImmediate */
+    setImmediate(function(){
+      callback(arg);
+    });
+  };
+}
+
+function useMutationObserver() {
+  var queue = [];
+
+  var observer = new BrowserMutationObserver(function() {
+    var toProcess = queue.slice();
+    queue = [];
+
+    toProcess.forEach(function(tuple) {
+      var callback = tuple[0], arg= tuple[1];
+      callback(arg);
+    });
+  });
+
+  var element = document.createElement('div');
+  observer.observe(element, { attributes: true });
+
+  // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
+  window.addEventListener('unload', function(){
+    observer.disconnect();
+    observer = null;
+  }, false);
+
+  return function(callback, arg) {
+    queue.push([callback, arg]);
+    element.setAttribute('drainQueue', 'drainQueue');
+  };
+}
+
+function useSetTimeout() {
+  return function(callback, arg) {
+    local.setTimeout(function() {
+      callback(arg);
+    }, 1);
+  };
+}
+
+if (typeof setImmediate === 'function') {
+  async = useSetImmediate();
+} else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+  async = useNextTick();
+} else if (BrowserMutationObserver) {
+  async = useMutationObserver();
+} else {
+  async = useSetTimeout();
+}
+
+
+exports.async = async;
\ No newline at end of file

dist/commonjs/rsvp/cancellation_error.js

+"use strict";
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+function CancellationError(message) {
+  this.name = "cancel";
+  if ((message !== undefined) && (typeof message !== "string")) {
+    throw new TypeError('You must pass a string.');
+  }
+  this.message = message || "Default Message";
+}
+CancellationError.prototype = new Error();
+CancellationError.prototype.constructor = CancellationError;
+
+
+exports.CancellationError = CancellationError;
\ No newline at end of file

dist/commonjs/rsvp/config.js

+"use strict";
+var async = require("./async").async;
+
+var config = {};
+config.async = async;
+
+
+exports.config = config;
\ No newline at end of file

dist/commonjs/rsvp/defer.js

+"use strict";
+var Promise = require("./promise").Promise;
+
+function defer() {
+  var deferred = {
+    // pre-allocate shape
+    resolve: undefined,
+    reject:  undefined,
+    promise: undefined
+  };
+
+  deferred.promise = new Promise(function(resolve, reject) {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+
+  return deferred;
+}
+
+
+exports.defer = defer;
\ No newline at end of file

dist/commonjs/rsvp/events.js

+"use strict";
+var Event = function(type, options) {
+  this.type = type;
+
+  for (var option in options) {
+    if (!options.hasOwnProperty(option)) { continue; }
+
+    this[option] = options[option];
+  }
+};
+
+var indexOf = function(callbacks, callback) {
+  for (var i=0, l=callbacks.length; i<l; i++) {
+    if (callbacks[i][0] === callback) { return i; }
+  }
+
+  return -1;
+};
+
+var callbacksFor = function(object) {
+  var callbacks = object._promiseCallbacks;
+
+  if (!callbacks) {
+    callbacks = object._promiseCallbacks = {};
+  }
+
+  return callbacks;
+};
+
+var EventTarget = {
+  mixin: function(object) {
+    object.on = this.on;
+    object.off = this.off;
+    object.trigger = this.trigger;
+    return object;
+  },
+
+  on: function(eventNames, callback, binding) {
+    var allCallbacks = callbacksFor(this), callbacks, eventName;
+    eventNames = eventNames.split(/\s+/);
+    binding = binding || this;
+
+    while (eventName = eventNames.shift()) {
+      callbacks = allCallbacks[eventName];
+
+      if (!callbacks) {
+        callbacks = allCallbacks[eventName] = [];
+      }
+
+      if (indexOf(callbacks, callback) === -1) {
+        callbacks.push([callback, binding]);
+      }
+    }
+  },
+
+  off: function(eventNames, callback) {
+    var allCallbacks = callbacksFor(this), callbacks, eventName, index;
+    eventNames = eventNames.split(/\s+/);
+
+    while (eventName = eventNames.shift()) {
+      if (!callback) {
+        allCallbacks[eventName] = [];
+        continue;
+      }
+
+      callbacks = allCallbacks[eventName];
+
+      index = indexOf(callbacks, callback);
+
+      if (index !== -1) { callbacks.splice(index, 1); }
+    }
+  },
+
+  trigger: function(eventName, options) {
+    var allCallbacks = callbacksFor(this),
+        callbacks, callbackTuple, callback, binding, event;
+
+    if (callbacks = allCallbacks[eventName]) {
+      // Don't cache the callbacks.length since it may grow
+      for (var i=0; i<callbacks.length; i++) {
+        callbackTuple = callbacks[i];
+        callback = callbackTuple[0];
+        binding = callbackTuple[1];
+
+        if (typeof options !== 'object') {
+          options = { detail: options };
+        }
+
+        event = new Event(eventName, options);
+        callback.call(binding, event);
+      }
+    }
+  }
+};
+
+
+exports.EventTarget = EventTarget;
\ No newline at end of file

dist/commonjs/rsvp/hash.js

+"use strict";
+var defer = require("./defer").defer;
+
+function size(object) {
+  var s = 0;
+
+  for (var prop in object) {
+    s++;
+  }
+
+  return s;
+}
+
+function hash(promises) {
+  var results = {}, deferred = defer(), remaining = size(promises);
+
+  if (remaining === 0) {
+    deferred.resolve({});
+  }
+
+  var resolver = function(prop) {
+    return function(value) {
+      resolveAll(prop, value);
+    };
+  };
+
+  var resolveAll = function(prop, value) {
+    results[prop] = value;
+    if (--remaining === 0) {
+      deferred.resolve(results);
+    }
+  };
+
+  var rejectAll = function(error) {
+    deferred.reject(error);
+  };
+
+  for (var prop in promises) {
+    if (promises[prop] && typeof promises[prop].then === 'function') {
+      promises[prop].then(resolver(prop), rejectAll);
+    } else {
+      resolveAll(prop, promises[prop]);
+    }
+  }
+
+  return deferred.promise;
+}
+
+
+exports.hash = hash;
\ No newline at end of file

dist/commonjs/rsvp/node.js

+"use strict";
+var Promise = require("./promise").Promise;
+var all = require("./all").all;
+
+function makeNodeCallbackFor(resolve, reject) {
+  return function (error, value) {
+    if (error) {
+      reject(error);
+    } else if (arguments.length > 2) {
+      resolve(Array.prototype.slice.call(arguments, 1));
+    } else {
+      resolve(value);
+    }
+  };
+}
+
+function denodeify(nodeFunc) {
+  return function()  {
+    var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
+    var thisArg = this;
+
+    var promise = new Promise(function(nodeResolve, nodeReject) {
+      resolve = nodeResolve;
+      reject = nodeReject;
+    });
+
+    all(nodeArgs).then(function(nodeArgs) {
+      nodeArgs.push(makeNodeCallbackFor(resolve, reject));
+
+      try {
+        nodeFunc.apply(thisArg, nodeArgs);
+      } catch(e) {
+        reject(e);
+      }
+    });
+
+    return promise;
+  };
+}
+
+
+exports.denodeify = denodeify;
\ No newline at end of file

dist/commonjs/rsvp/promise.js

+"use strict";
+var config = require("./config").config;
+var EventTarget = require("./events").EventTarget;
+var CancellationError = require("./cancellation_error").CancellationError;
+
+function objectOrFunction(x) {
+  return isFunction(x) || (typeof x === "object" && x !== null);
+}
+
+function isFunction(x){
+  return typeof x === "function";
+}
+
+var Promise = function(resolver, canceller) {
+  var promise = this,
+  resolved = false;
+
+  if (typeof resolver !== 'function') {
+    throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
+  }
+
+  if ((canceller !== undefined) && (typeof canceller !== 'function')) {
+    throw new TypeError('You can only pass a canceller function' +
+      ' as the second argument to the promise constructor');
+  }
+
+  if (!(promise instanceof Promise)) {
+    return new Promise(resolver, canceller);
+  }
+
+  var resolvePromise = function(value) {
+    if (resolved) { return; }
+    resolved = true;
+    resolve(promise, value);
+  };
+
+  var rejectPromise = function(value) {
+    if (resolved) { return; }
+    resolved = true;
+    reject(promise, value);
+  };
+
+  var notifyPromise = function(value) {
+    if (resolved) { return; }
+    notify(promise, value);
+  };
+
+  this.on('promise:failed', function(event) {
+    this.trigger('error', { detail: event.detail });
+  }, this);
+
+  this.on('error', onerror);
+
+  this.cancel = function () {
+    // For now, simply reject the promise and does not propagate the cancel
+    // to parent or children
+    if (resolved) { return; }
+    if (canceller !== undefined) {
+      try {
+        canceller();
+      } catch (e) {
+        rejectPromise(e);
+        return;
+      }
+    }
+    // Trigger cancel?
+    rejectPromise(new CancellationError());
+  };
+
+  try {
+    resolver(resolvePromise, rejectPromise, notifyPromise);
+  } catch(e) {
+    rejectPromise(e);
+  }
+};
+
+function onerror(event) {
+  if (config.onerror) {
+    config.onerror(event.detail);
+  }
+}
+
+var invokeCallback = function(type, promise, callback, event) {
+  var hasCallback = isFunction(callback),
+      value, error, succeeded, failed;
+
+  if (promise.isFulfilled) { return; }
+  if (promise.isRejected) { return; }
+
+  if (hasCallback) {
+    try {
+      value = callback(event.detail);
+      succeeded = true;
+    } catch(e) {
+      failed = true;
+      error = e;
+    }
+  } else {
+    value = event.detail;
+    succeeded = true;
+  }
+
+  if (handleThenable(promise, value)) {
+    return;
+  } else if (hasCallback && succeeded) {
+    resolve(promise, value);
+  } else if (failed) {
+    reject(promise, error);
+  } else if (type === 'resolve') {
+    resolve(promise, value);
+  } else if (type === 'reject') {
+    reject(promise, value);
+  }
+};
+
+
+var invokeNotifyCallback = function(promise, callback, event) {
+  var value;
+  if (typeof callback === 'function') {
+    try {
+      value = callback(event.detail);
+    } catch (e) {
+      // stop propagating
+      return;
+    }
+    notify(promise, value);
+  } else {
+    notify(promise, event.detail);
+  }
+};
+
+Promise.prototype = {
+  constructor: Promise,
+
+  isRejected: undefined,
+  isFulfilled: undefined,
+  rejectedReason: undefined,
+  fulfillmentValue: undefined,
+
+  then: function(done, fail, progress) {
+    this.off('error', onerror);
+
+    var thenPromise = new this.constructor(function() {},
+        function () {
+          thenPromise.trigger('promise:cancelled', {});
+        });
+
+    if (this.isFulfilled) {
+      config.async(function(promise) {
+        invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
+      }, this);
+    }
+
+    if (this.isRejected) {
+      config.async(function(promise) {
+        invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
+      }, this);
+    }
+
+    this.on('promise:resolved', function(event) {
+      invokeCallback('resolve', thenPromise, done, event);
+    });
+
+    this.on('promise:failed', function(event) {
+      invokeCallback('reject', thenPromise, fail, event);
+    });
+
+    this.on('promise:notified', function (event) {
+      invokeNotifyCallback(thenPromise, progress, event);
+    });
+
+    return thenPromise;
+  },
+
+  fail: function(fail) {
+    return this.then(null, fail);
+  },
+
+  always: function(fail) {
+    return this.then(fail, fail);
+  }
+};
+
+EventTarget.mixin(Promise.prototype);
+
+function resolve(promise, value) {
+  if (promise === value) {
+    fulfill(promise, value);
+  } else if (!handleThenable(promise, value)) {
+    fulfill(promise, value);
+  }
+}
+
+function handleThenable(promise, value) {
+  var then = null,
+  resolved;
+
+  try {
+    if (promise === value) {
+      throw new TypeError("A promises callback cannot return that same promise.");
+    }
+
+    if (objectOrFunction(value)) {
+      then = value.then;
+
+      if (isFunction(then)) {
+        promise.on('promise:cancelled', function(event) {
+          if (isFunction(value.cancel)) {
+            value.cancel();
+          }
+        });
+        then.call(value, function(val) {
+          if (resolved) { return true; }
+          resolved = true;
+
+          if (value !== val) {
+            resolve(promise, val);
+          } else {
+            fulfill(promise, val);
+          }
+        }, function(val) {
+          if (resolved) { return true; }
+          resolved = true;
+
+          reject(promise, val);
+        });
+
+        return true;
+      }
+    }
+  } catch (error) {
+    reject(promise, error);
+    return true;
+  }
+
+  return false;
+}
+
+function fulfill(promise, value) {
+  config.async(function() {
+    if (promise.isFulfilled) { return; }
+    if (promise.isRejected) { return; }
+    promise.trigger('promise:resolved', { detail: value });
+    promise.isFulfilled = true;
+    promise.fulfillmentValue = value;
+  });
+}
+
+function reject(promise, value) {
+  config.async(function() {
+    if (promise.isFulfilled) { return; }
+    if (promise.isRejected) { return; }
+    promise.trigger('promise:failed', { detail: value });
+    promise.isRejected = true;
+    promise.rejectedReason = value;
+  });
+}
+
+function notify(promise, value) {
+  config.async(function() {
+    promise.trigger('promise:notified', { detail: value });
+  });
+}
+
+
+exports.Promise = Promise;
\ No newline at end of file

dist/commonjs/rsvp/queue.js

+"use strict";
+var Promise = require("./promise").Promise;
+var delay = require("./timeout").delay;
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+function ResolvedQueueError(message) {
+  this.name = "resolved";
+  if ((message !== undefined) && (typeof message !== "string")) {
+    throw new TypeError('You must pass a string.');
+  }
+  this.message = message || "Default Message";
+}
+ResolvedQueueError.prototype = new Error();
+ResolvedQueueError.prototype.constructor = ResolvedQueueError;
+
+var Queue = function() {
+  var queue = this,
+    promise_list = [],
+    promise,
+    fulfill,
+    reject,
+    resolved;
+
+  if (!(this instanceof Queue)) {
+    return new Queue();
+  }
+
+  function canceller() {
+    for (var i = 0; i < 2; i++) {
+      promise_list[i].cancel();
+    }
+  }
+
+  promise = new Promise(function(done, fail) {
+    fulfill = function (fulfillmentValue) {
+      if (resolved) {return;}
+      queue.isFulfilled = true;
+      queue.fulfillmentValue = fulfillmentValue;
+      resolved = true;
+      return done(fulfillmentValue);
+    };
+    reject = function (rejectedReason) {
+      if (resolved) {return;}
+      queue.isRejected = true;
+      queue.rejectedReason = rejectedReason ;
+      resolved = true;
+      return fail(rejectedReason);
+    };
+  }, canceller);
+
+  promise_list.push(delay());
+  promise_list.push(promise_list[0].then(function () {
+    promise_list.splice(0, 2);
+    if (promise_list.length === 0) {
+      fulfill();
+    }
+  }));
+
+  queue.cancel = function () {
+    if (resolved) {return;}
+    resolved = true;
+    promise.cancel();
+    promise.fail(function (rejectedReason) {
+      queue.isRejected = true;
+      queue.rejectedReason = rejectedReason;
+    });
+  };
+  queue.then = function () {
+    return promise.then.apply(promise, arguments);
+  };
+
+  queue.push = function(done, fail) {
+    var last_promise = promise_list[promise_list.length - 1],
+      next_promise;
+
+    if (resolved) {
+      throw new ResolvedQueueError();
+    }
+
+    next_promise = last_promise.then(done, fail);
+    promise_list.push(next_promise);
+
+    // Handle pop
+    promise_list.push(next_promise.then(function (fulfillmentValue) {
+      promise_list.splice(0, 2);
+      if (promise_list.length === 0) {
+        fulfill(fulfillmentValue);
+      } else {
+        return fulfillmentValue;
+      }
+    }, function (rejectedReason) {
+      promise_list.splice(0, 2);
+      if (promise_list.length === 0) {
+        reject(rejectedReason);
+      } else {
+        throw rejectedReason;
+      }
+    }));
+
+    return this;
+  };
+};
+
+Queue.prototype = Object.create(Promise.prototype);
+Queue.prototype.constructor = Queue;
+
+
+exports.Queue = Queue;
+exports.ResolvedQueueError = ResolvedQueueError;
\ No newline at end of file

dist/commonjs/rsvp/reject.js

+"use strict";
+var Promise = require("./promise").Promise;
+
+function reject(reason) {
+  return new Promise(function (resolve, reject) {
+    reject(reason);
+  });
+}
+
+
+exports.reject = reject;
\ No newline at end of file

dist/commonjs/rsvp/resolve.js

+"use strict";
+var Promise = require("./promise").Promise;
+
+function resolve(thenable) {
+  return new Promise(function(resolve, reject) {
+    resolve(thenable);
+  });
+}
+
+
+exports.resolve = resolve;
\ No newline at end of file

dist/commonjs/rsvp/rethrow.js

+"use strict";
+var local = (typeof global === "undefined") ? this : global;
+
+function rethrow(reason) {
+  local.setTimeout(function() {
+    throw reason;
+  });
+  throw reason;
+}
+
+
+exports.rethrow = rethrow;
\ No newline at end of file

dist/commonjs/rsvp/timeout.js

+"use strict";
+var Promise = require("./promise").Promise;
+
+function promiseSetTimeout(millisecond, should_reject, message) {
+  var timeout_id;
+
+  function resolver(resolve, reject) {
+    timeout_id = setTimeout(function () {
+      if (should_reject) {
+        reject(message);
+      } else {
+        resolve(message);
+      }
+    }, millisecond);
+  }
+  function canceller() {
+    clearTimeout(timeout_id);
+  }
+  return new Promise(resolver, canceller);
+}
+
+function delay(millisecond, message) {
+  return promiseSetTimeout(millisecond, false, message);
+}
+
+function timeout(millisecond) {
+  return promiseSetTimeout(millisecond, true,
+                           "Timed out after " + millisecond + " ms");
+}
+
+Promise.prototype.delay = function(millisecond) {
+  return this.then(function (fulfillmentValue) {
+    return delay(millisecond, fulfillmentValue);
+  });
+};
+
+
+exports.delay = delay;
+exports.timeout = timeout;
\ No newline at end of file

dist/rsvp-2.0.4.amd.js

+define("rsvp/all",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    /* global toString */
+
+
+    function promiseAtLeast(expected_count, promises) {
+      if (Object.prototype.toString.call(promises) !== "[object Array]") {
+        throw new TypeError('You must pass an array to all.');
+      }
+
+      function canceller() {
+        var promise;
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && typeof promise.then === 'function' &&
+              typeof promise.cancel === 'function') {
+            promise.cancel();
+          }
+        }
+      }
+
+      return new Promise(function(resolve, reject, notify) {
+        var results = [], remaining = promises.length,
+        promise, remaining_count = promises.length - expected_count;
+
+        if (remaining === 0) {
+          if (expected_count === 1) {
+            resolve();
+          } else {
+            resolve([]);
+          }
+        }
+
+        function resolver(index) {
+          return function(value) {
+            resolveAll(index, value);
+          };
+        }
+
+        function resolveAll(index, value) {
+          results[index] = value;
+          if (--remaining === remaining_count) {
+            if (remaining_count === 0) {
+              resolve(results);
+            } else {
+              resolve(value);
+              canceller();
+            }
+          }
+        }
+
+        function notifier(index) {
+          return function(value) {
+            notify({"index": index, "value": value});
+          };
+        }
+
+        function cancelAll(rejectionValue) {
+          reject(rejectionValue);
+          canceller();
+        }
+
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && typeof promise.then === 'function') {
+            promise.then(resolver(i), cancelAll, notifier(i));
+          } else {
+            resolveAll(i, promise);
+          }
+        }
+      }, canceller
+      );
+    }
+
+    function all(promises) {
+      return promiseAtLeast(promises.length, promises);
+    }
+
+    function any(promises) {
+      return promiseAtLeast(1, promises);
+    }
+
+
+    __exports__.all = all;
+    __exports__.any = any;
+  });
+define("rsvp/async",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var browserGlobal = (typeof window !== 'undefined') ? window : {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var async;
+    var local = (typeof global !== 'undefined') ? global : this;
+
+    // old node
+    function useNextTick() {
+      return function(callback, arg) {
+        process.nextTick(function() {
+          callback(arg);
+        });
+      };
+    }
+
+    // node >= 0.10.x
+    function useSetImmediate() {
+      return function(callback, arg) {
+        /* global  setImmediate */
+        setImmediate(function(){
+          callback(arg);
+        });
+      };
+    }
+
+    function useMutationObserver() {
+      var queue = [];
+
+      var observer = new BrowserMutationObserver(function() {
+        var toProcess = queue.slice();
+        queue = [];
+
+        toProcess.forEach(function(tuple) {
+          var callback = tuple[0], arg= tuple[1];
+          callback(arg);
+        });
+      });
+
+      var element = document.createElement('div');
+      observer.observe(element, { attributes: true });
+
+      // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
+      window.addEventListener('unload', function(){
+        observer.disconnect();
+        observer = null;
+      }, false);
+
+      return function(callback, arg) {
+        queue.push([callback, arg]);
+        element.setAttribute('drainQueue', 'drainQueue');
+      };
+    }
+
+    function useSetTimeout() {
+      return function(callback, arg) {
+        local.setTimeout(function() {
+          callback(arg);
+        }, 1);
+      };
+    }
+
+    if (typeof setImmediate === 'function') {
+      async = useSetImmediate();
+    } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+      async = useNextTick();
+    } else if (BrowserMutationObserver) {
+      async = useMutationObserver();
+    } else {
+      async = useSetTimeout();
+    }
+
+
+    __exports__.async = async;
+  });
+define("rsvp/cancellation_error",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+    function CancellationError(message) {
+      this.name = "cancel";
+      if ((message !== undefined) && (typeof message !== "string")) {
+        throw new TypeError('You must pass a string.');
+      }
+      this.message = message || "Default Message";
+    }
+    CancellationError.prototype = new Error();
+    CancellationError.prototype.constructor = CancellationError;
+
+
+    __exports__.CancellationError = CancellationError;
+  });
+define("rsvp/config",
+  ["rsvp/async","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var async = __dependency1__.async;
+
+    var config = {};
+    config.async = async;
+
+
+    __exports__.config = config;
+  });
+define("rsvp/defer",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function defer() {
+      var deferred = {
+        // pre-allocate shape
+        resolve: undefined,
+        reject:  undefined,
+        promise: undefined
+      };
+
+      deferred.promise = new Promise(function(resolve, reject) {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+      });
+
+      return deferred;
+    }
+
+
+    __exports__.defer = defer;
+  });
+define("rsvp/events",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var Event = function(type, options) {
+      this.type = type;
+
+      for (var option in options) {
+        if (!options.hasOwnProperty(option)) { continue; }
+
+        this[option] = options[option];
+      }
+    };
+
+    var indexOf = function(callbacks, callback) {
+      for (var i=0, l=callbacks.length; i<l; i++) {
+        if (callbacks[i][0] === callback) { return i; }
+      }
+
+      return -1;
+    };
+
+    var callbacksFor = function(object) {
+      var callbacks = object._promiseCallbacks;
+
+      if (!callbacks) {
+        callbacks = object._promiseCallbacks = {};
+      }
+
+      return callbacks;
+    };
+
+    var EventTarget = {
+      mixin: function(object) {
+        object.on = this.on;
+        object.off = this.off;
+        object.trigger = this.trigger;
+        return object;
+      },
+
+      on: function(eventNames, callback, binding) {
+        var allCallbacks = callbacksFor(this), callbacks, eventName;
+        eventNames = eventNames.split(/\s+/);
+        binding = binding || this;
+
+        while (eventName = eventNames.shift()) {
+          callbacks = allCallbacks[eventName];
+
+          if (!callbacks) {
+            callbacks = allCallbacks[eventName] = [];
+          }
+
+          if (indexOf(callbacks, callback) === -1) {
+            callbacks.push([callback, binding]);
+          }
+        }
+      },
+
+      off: function(eventNames, callback) {
+        var allCallbacks = callbacksFor(this), callbacks, eventName, index;
+        eventNames = eventNames.split(/\s+/);
+
+        while (eventName = eventNames.shift()) {
+          if (!callback) {
+            allCallbacks[eventName] = [];
+            continue;
+          }
+
+          callbacks = allCallbacks[eventName];
+
+          index = indexOf(callbacks, callback);
+
+          if (index !== -1) { callbacks.splice(index, 1); }
+        }
+      },
+
+      trigger: function(eventName, options) {
+        var allCallbacks = callbacksFor(this),
+            callbacks, callbackTuple, callback, binding, event;
+
+        if (callbacks = allCallbacks[eventName]) {
+          // Don't cache the callbacks.length since it may grow
+          for (var i=0; i<callbacks.length; i++) {
+            callbackTuple = callbacks[i];
+            callback = callbackTuple[0];
+            binding = callbackTuple[1];
+
+            if (typeof options !== 'object') {
+              options = { detail: options };
+            }
+
+            event = new Event(eventName, options);
+            callback.call(binding, event);
+          }
+        }
+      }
+    };
+
+
+    __exports__.EventTarget = EventTarget;
+  });
+define("rsvp/hash",
+  ["rsvp/defer","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var defer = __dependency1__.defer;
+
+    function size(object) {
+      var s = 0;
+
+      for (var prop in object) {
+        s++;
+      }
+
+      return s;
+    }
+
+    function hash(promises) {
+      var results = {}, deferred = defer(), remaining = size(promises);
+
+      if (remaining === 0) {
+        deferred.resolve({});
+      }
+
+      var resolver = function(prop) {
+        return function(value) {
+          resolveAll(prop, value);
+        };
+      };
+
+      var resolveAll = function(prop, value) {
+        results[prop] = value;
+        if (--remaining === 0) {
+          deferred.resolve(results);
+        }
+      };
+
+      var rejectAll = function(error) {
+        deferred.reject(error);
+      };
+
+      for (var prop in promises) {
+        if (promises[prop] && typeof promises[prop].then === 'function') {
+          promises[prop].then(resolver(prop), rejectAll);
+        } else {
+          resolveAll(prop, promises[prop]);
+        }
+      }
+
+      return deferred.promise;
+    }
+
+
+    __exports__.hash = hash;
+  });
+define("rsvp/node",
+  ["rsvp/promise","rsvp/all","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    var all = __dependency2__.all;
+
+    function makeNodeCallbackFor(resolve, reject) {
+      return function (error, value) {
+        if (error) {
+          reject(error);
+        } else if (arguments.length > 2) {
+          resolve(Array.prototype.slice.call(arguments, 1));
+        } else {
+          resolve(value);
+        }
+      };
+    }
+
+    function denodeify(nodeFunc) {
+      return function()  {
+        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
+        var thisArg = this;
+
+        var promise = new Promise(function(nodeResolve, nodeReject) {
+          resolve = nodeResolve;
+          reject = nodeReject;
+        });
+
+        all(nodeArgs).then(function(nodeArgs) {
+          nodeArgs.push(makeNodeCallbackFor(resolve, reject));
+
+          try {
+            nodeFunc.apply(thisArg, nodeArgs);
+          } catch(e) {
+            reject(e);
+          }
+        });
+
+        return promise;
+      };
+    }
+
+
+    __exports__.denodeify = denodeify;
+  });
+define("rsvp/promise",
+  ["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var config = __dependency1__.config;
+    var EventTarget = __dependency2__.EventTarget;
+    var CancellationError = __dependency3__.CancellationError;
+
+    function objectOrFunction(x) {
+      return isFunction(x) || (typeof x === "object" && x !== null);
+    }
+
+    function isFunction(x){
+      return typeof x === "function";
+    }
+
+    var Promise = function(resolver, canceller) {
+      var promise = this,
+      resolved = false;
+
+      if (typeof resolver !== 'function') {
+        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
+      }
+
+      if ((canceller !== undefined) && (typeof canceller !== 'function')) {
+        throw new TypeError('You can only pass a canceller function' +
+          ' as the second argument to the promise constructor');
+      }
+
+      if (!(promise instanceof Promise)) {
+        return new Promise(resolver, canceller);
+      }
+
+      var resolvePromise = function(value) {
+        if (resolved) { return; }
+        resolved = true;
+        resolve(promise, value);
+      };
+
+      var rejectPromise = function(value) {
+        if (resolved) { return; }
+        resolved = true;
+        reject(promise, value);
+      };
+
+      var notifyPromise = function(value) {
+        if (resolved) { return; }
+        notify(promise, value);
+      };
+
+      this.on('promise:failed', function(event) {
+        this.trigger('error', { detail: event.detail });
+      }, this);
+
+      this.on('error', onerror);
+
+      this.cancel = function () {
+        // For now, simply reject the promise and does not propagate the cancel
+        // to parent or children
+        if (resolved) { return; }
+        if (canceller !== undefined) {
+          try {
+            canceller();
+          } catch (e) {
+            rejectPromise(e);
+            return;
+          }
+        }
+        // Trigger cancel?
+        rejectPromise(new CancellationError());
+      };
+
+      try {
+        resolver(resolvePromise, rejectPromise, notifyPromise);
+      } catch(e) {
+        rejectPromise(e);
+      }
+    };
+
+    function onerror(event) {
+      if (config.onerror) {
+        config.onerror(event.detail);
+      }
+    }
+
+    var invokeCallback = function(type, promise, callback, event) {
+      var hasCallback = isFunction(callback),
+          value, error, succeeded, failed;
+
+      if (promise.isFulfilled) { return; }
+      if (promise.isRejected) { return; }
+
+      if (hasCallback) {
+        try {
+          value = callback(event.detail);
+          succeeded = true;
+        } catch(e) {
+          failed = true;
+          error = e;
+        }
+      } else {
+        value = event.detail;
+        succeeded = true;
+      }
+
+      if (handleThenable(promise, value)) {
+        return;
+      } else if (hasCallback && succeeded) {
+        resolve(promise, value);
+      } else if (failed) {
+        reject(promise, error);
+      } else if (type === 'resolve') {
+        resolve(promise, value);
+      } else if (type === 'reject') {
+        reject(promise, value);
+      }
+    };
+
+
+    var invokeNotifyCallback = function(promise, callback, event) {
+      var value;
+      if (typeof callback === 'function') {
+        try {
+          value = callback(event.detail);
+        } catch (e) {
+          // stop propagating
+          return;
+        }
+        notify(promise, value);
+      } else {
+        notify(promise, event.detail);
+      }
+    };
+
+    Promise.prototype = {
+      constructor: Promise,
+
+      isRejected: undefined,
+      isFulfilled: undefined,
+      rejectedReason: undefined,
+      fulfillmentValue: undefined,
+
+      then: function(done, fail, progress) {
+        this.off('error', onerror);
+
+        var thenPromise = new this.constructor(function() {},
+            function () {
+              thenPromise.trigger('promise:cancelled', {});
+            });
+
+        if (this.isFulfilled) {
+          config.async(function(promise) {
+            invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
+          }, this);
+        }
+
+        if (this.isRejected) {
+          config.async(function(promise) {
+            invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
+          }, this);
+        }
+
+        this.on('promise:resolved', function(event) {
+          invokeCallback('resolve', thenPromise, done, event);
+        });
+
+        this.on('promise:failed', function(event) {
+          invokeCallback('reject', thenPromise, fail, event);
+        });
+
+        this.on('promise:notified', function (event) {
+          invokeNotifyCallback(thenPromise, progress, event);
+        });
+
+        return thenPromise;
+      },
+
+      fail: function(fail) {
+        return this.then(null, fail);
+      },
+
+      always: function(fail) {
+        return this.then(fail, fail);
+      }
+    };
+
+    EventTarget.mixin(Promise.prototype);
+
+    function resolve(promise, value) {
+      if (promise === value) {
+        fulfill(promise, value);
+      } else if (!handleThenable(promise, value)) {
+        fulfill(promise, value);
+      }
+    }
+
+    function handleThenable(promise, value) {
+      var then = null,
+      resolved;
+
+      try {
+        if (promise === value) {
+          throw new TypeError("A promises callback cannot return that same promise.");
+        }
+
+        if (objectOrFunction(value)) {
+          then = value.then;
+
+          if (isFunction(then)) {
+            promise.on('promise:cancelled', function(event) {
+              if (isFunction(value.cancel)) {
+                value.cancel();
+              }
+            });
+            then.call(value, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              if (value !== val) {
+                resolve(promise, val);
+              } else {
+                fulfill(promise, val);
+              }
+            }, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              reject(promise, val);
+            });
+
+            return true;
+          }
+        }
+      } catch (error) {
+        reject(promise, error);
+        return true;
+      }
+
+      return false;
+    }
+
+    function fulfill(promise, value) {
+      config.async(function() {
+        if (promise.isFulfilled) { return; }
+        if (promise.isRejected) { return; }
+        promise.trigger('promise:resolved', { detail: value });
+        promise.isFulfilled = true;
+        promise.fulfillmentValue = value;
+      });
+    }
+
+    function reject(promise, value) {
+      config.async(function() {
+        if (promise.isFulfilled) { return; }
+        if (promise.isRejected) { return; }
+        promise.trigger('promise:failed', { detail: value });
+        promise.isRejected = true;
+        promise.rejectedReason = value;
+      });
+    }
+
+    function notify(promise, value) {
+      config.async(function() {
+        promise.trigger('promise:notified', { detail: value });
+      });
+    }
+
+
+    __exports__.Promise = Promise;
+  });
+define("rsvp/queue",
+  ["rsvp/promise","rsvp/timeout","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    var delay = __dependency2__.delay;
+
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+    function ResolvedQueueError(message) {
+      this.name = "resolved";
+      if ((message !== undefined) && (typeof message !== "string")) {
+        throw new TypeError('You must pass a string.');
+      }
+      this.message = message || "Default Message";
+    }
+    ResolvedQueueError.prototype = new Error();
+    ResolvedQueueError.prototype.constructor = ResolvedQueueError;
+
+    var Queue = function() {
+      var queue = this,
+        promise_list = [],
+        promise,
+        fulfill,
+        reject,
+        resolved;
+
+      if (!(this instanceof Queue)) {
+        return new Queue();
+      }
+
+      function canceller() {
+        for (var i = 0; i < 2; i++) {
+          promise_list[i].cancel();
+        }
+      }
+
+      promise = new Promise(function(done, fail) {
+        fulfill = function (fulfillmentValue) {
+          if (resolved) {return;}
+          queue.isFulfilled = true;
+          queue.fulfillmentValue = fulfillmentValue;
+          resolved = true;
+          return done(fulfillmentValue);
+        };
+        reject = function (rejectedReason) {
+          if (resolved) {return;}
+          queue.isRejected = true;
+          queue.rejectedReason = rejectedReason ;
+          resolved = true;
+          return fail(rejectedReason);
+        };
+      }, canceller);
+
+      promise_list.push(delay());
+      promise_list.push(promise_list[0].then(function () {
+        promise_list.splice(0, 2);
+        if (promise_list.length === 0) {
+          fulfill();
+        }
+      }));
+
+      queue.cancel = function () {
+        if (resolved) {return;}
+        resolved = true;
+        promise.cancel();
+        promise.fail(function (rejectedReason) {
+          queue.isRejected = true;
+          queue.rejectedReason = rejectedReason;
+        });
+      };
+      queue.then = function () {
+        return promise.then.apply(promise, arguments);
+      };
+
+      queue.push = function(done, fail) {
+        var last_promise = promise_list[promise_list.length - 1],
+          next_promise;
+
+        if (resolved) {
+          throw new ResolvedQueueError();
+        }
+
+        next_promise = last_promise.then(done, fail);
+        promise_list.push(next_promise);
+
+        // Handle pop
+        promise_list.push(next_promise.then(function (fulfillmentValue) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            fulfill(fulfillmentValue);
+          } else {
+            return fulfillmentValue;
+          }
+        }, function (rejectedReason) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            reject(rejectedReason);
+          } else {
+            throw rejectedReason;
+          }
+        }));
+
+        return this;
+      };
+    };
+
+    Queue.prototype = Object.create(Promise.prototype);
+    Queue.prototype.constructor = Queue;
+
+
+    __exports__.Queue = Queue;
+    __exports__.ResolvedQueueError = ResolvedQueueError;
+  });
+define("rsvp/reject",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function reject(reason) {
+      return new Promise(function (resolve, reject) {
+        reject(reason);
+      });
+    }
+
+
+    __exports__.reject = reject;
+  });
+define("rsvp/resolve",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function resolve(thenable) {
+      return new Promise(function(resolve, reject) {
+        resolve(thenable);
+      });
+    }
+
+
+    __exports__.resolve = resolve;
+  });
+define("rsvp/rethrow",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var local = (typeof global === "undefined") ? this : global;
+
+    function rethrow(reason) {
+      local.setTimeout(function() {
+        throw reason;
+      });
+      throw reason;
+    }
+
+
+    __exports__.rethrow = rethrow;
+  });
+define("rsvp/timeout",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function promiseSetTimeout(millisecond, should_reject, message) {
+      var timeout_id;
+
+      function resolver(resolve, reject) {
+        timeout_id = setTimeout(function () {
+          if (should_reject) {
+            reject(message);
+          } else {
+            resolve(message);
+          }
+        }, millisecond);
+      }
+      function canceller() {
+        clearTimeout(timeout_id);
+      }
+      return new Promise(resolver, canceller);
+    }
+
+    function delay(millisecond, message) {
+      return promiseSetTimeout(millisecond, false, message);
+    }
+
+    function timeout(millisecond) {
+      return promiseSetTimeout(millisecond, true,
+                               "Timed out after " + millisecond + " ms");
+    }
+
+    Promise.prototype.delay = function(millisecond) {
+      return this.then(function (fulfillmentValue) {
+        return delay(millisecond, fulfillmentValue);
+      });
+    };
+
+
+    __exports__.delay = delay;
+    __exports__.timeout = timeout;
+  });
+define("rsvp",
+  ["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
+    "use strict";
+    var EventTarget = __dependency1__.EventTarget;
+    var CancellationError = __dependency2__.CancellationError;
+    var Promise = __dependency3__.Promise;
+    var denodeify = __dependency4__.denodeify;
+    var all = __dependency5__.all;
+    var any = __dependency5__.any;
+    var Queue = __dependency6__.Queue;
+    var ResolvedQueueError = __dependency6__.ResolvedQueueError;
+    var delay = __dependency7__.delay;
+    var timeout = __dependency7__.timeout;
+    var hash = __dependency8__.hash;
+    var rethrow = __dependency9__.rethrow;
+    var defer = __dependency10__.defer;
+    var config = __dependency11__.config;
+    var resolve = __dependency12__.resolve;
+    var reject = __dependency13__.reject;
+
+    function configure(name, value) {
+      config[name] = value;
+    }
+
+
+    __exports__.CancellationError = CancellationError;
+    __exports__.Promise = Promise;
+    __exports__.EventTarget = EventTarget;
+    __exports__.all = all;
+    __exports__.any = any;
+    __exports__.Queue = Queue;
+    __exports__.ResolvedQueueError = ResolvedQueueError;
+    __exports__.delay = delay;
+    __exports__.timeout = timeout;
+    __exports__.hash = hash;
+    __exports__.rethrow = rethrow;
+    __exports__.defer = defer;
+    __exports__.denodeify = denodeify;
+    __exports__.configure = configure;
+    __exports__.resolve = resolve;
+    __exports__.reject = reject;
+  });
\ No newline at end of file

dist/rsvp-2.0.4.js

+(function(globals) {
+var define, requireModule;
+
+(function() {
+  var registry = {}, seen = {};
+
+  define = function(name, deps, callback) {
+    registry[name] = { deps: deps, callback: callback };
+  };
+
+  requireModule = function(name) {
+    if (seen[name]) { return seen[name]; }
+    seen[name] = {};
+
+    var mod = registry[name];
+    if (!mod) {
+      throw new Error("Module '" + name + "' not found.");
+    }
+
+    var deps = mod.deps,
+        callback = mod.callback,
+        reified = [],
+        exports;
+
+    for (var i=0, l=deps.length; i<l; i++) {
+      if (deps[i] === 'exports') {
+        reified.push(exports = {});
+      } else {
+        reified.push(requireModule(deps[i]));
+      }
+    }
+
+    var value = callback.apply(this, reified);
+    return seen[name] = exports || value;
+  };
+})();
+
+define("rsvp/all",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    /* global toString */
+
+
+    function promiseAtLeast(expected_count, promises) {
+      if (Object.prototype.toString.call(promises) !== "[object Array]") {
+        throw new TypeError('You must pass an array to all.');
+      }
+
+      function canceller() {
+        var promise;
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && typeof promise.then === 'function' &&
+              typeof promise.cancel === 'function') {
+            promise.cancel();
+          }
+        }
+      }
+
+      return new Promise(function(resolve, reject, notify) {
+        var results = [], remaining = promises.length,
+        promise, remaining_count = promises.length - expected_count;
+
+        if (remaining === 0) {
+          if (expected_count === 1) {
+            resolve();
+          } else {
+            resolve([]);
+          }
+        }
+
+        function resolver(index) {
+          return function(value) {
+            resolveAll(index, value);
+          };
+        }
+
+        function resolveAll(index, value) {
+          results[index] = value;
+          if (--remaining === remaining_count) {
+            if (remaining_count === 0) {
+              resolve(results);
+            } else {
+              resolve(value);
+              canceller();
+            }
+          }
+        }
+
+        function notifier(index) {
+          return function(value) {
+            notify({"index": index, "value": value});
+          };
+        }
+
+        function cancelAll(rejectionValue) {
+          reject(rejectionValue);
+          canceller();
+        }
+
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && typeof promise.then === 'function') {
+            promise.then(resolver(i), cancelAll, notifier(i));
+          } else {
+            resolveAll(i, promise);
+          }
+        }
+      }, canceller
+      );
+    }
+
+    function all(promises) {
+      return promiseAtLeast(promises.length, promises);
+    }
+
+    function any(promises) {
+      return promiseAtLeast(1, promises);
+    }
+
+
+    __exports__.all = all;
+    __exports__.any = any;
+  });
+define("rsvp/async",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var browserGlobal = (typeof window !== 'undefined') ? window : {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var async;
+    var local = (typeof global !== 'undefined') ? global : this;
+
+    // old node
+    function useNextTick() {
+      return function(callback, arg) {
+        process.nextTick(function() {
+          callback(arg);
+        });
+      };
+    }
+
+    // node >= 0.10.x
+    function useSetImmediate() {
+      return function(callback, arg) {
+        /* global  setImmediate */
+        setImmediate(function(){
+          callback(arg);
+        });
+      };
+    }
+
+    function useMutationObserver() {
+      var queue = [];
+
+      var observer = new BrowserMutationObserver(function() {
+        var toProcess = queue.slice();
+        queue = [];
+
+        toProcess.forEach(function(tuple) {
+          var callback = tuple[0], arg= tuple[1];
+          callback(arg);
+        });
+      });
+
+      var element = document.createElement('div');
+      observer.observe(element, { attributes: true });
+
+      // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
+      window.addEventListener('unload', function(){
+        observer.disconnect();
+        observer = null;
+      }, false);
+
+      return function(callback, arg) {
+        queue.push([callback, arg]);
+        element.setAttribute('drainQueue', 'drainQueue');
+      };
+    }
+
+    function useSetTimeout() {
+      return function(callback, arg) {
+        local.setTimeout(function() {
+          callback(arg);
+        }, 1);
+      };
+    }
+
+    if (typeof setImmediate === 'function') {
+      async = useSetImmediate();
+    } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+      async = useNextTick();
+    } else if (BrowserMutationObserver) {
+      async = useMutationObserver();
+    } else {
+      async = useSetTimeout();
+    }
+
+
+    __exports__.async = async;
+  });
+define("rsvp/cancellation_error",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+    function CancellationError(message) {
+      this.name = "cancel";
+      if ((message !== undefined) && (typeof message !== "string")) {
+        throw new TypeError('You must pass a string.');
+      }
+      this.message = message || "Default Message";
+    }
+    CancellationError.prototype = new Error();
+    CancellationError.prototype.constructor = CancellationError;
+
+
+    __exports__.CancellationError = CancellationError;
+  });
+define("rsvp/config",
+  ["rsvp/async","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var async = __dependency1__.async;
+
+    var config = {};
+    config.async = async;
+
+
+    __exports__.config = config;
+  });
+define("rsvp/defer",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function defer() {
+      var deferred = {
+        // pre-allocate shape
+        resolve: undefined,
+        reject:  undefined,
+        promise: undefined
+      };
+
+      deferred.promise = new Promise(function(resolve, reject) {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+      });
+
+      return deferred;
+    }
+
+
+    __exports__.defer = defer;
+  });
+define("rsvp/events",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var Event = function(type, options) {
+      this.type = type;
+
+      for (var option in options) {
+        if (!options.hasOwnProperty(option)) { continue; }
+
+        this[option] = options[option];
+      }
+    };
+
+    var indexOf = function(callbacks, callback) {
+      for (var i=0, l=callbacks.length; i<l; i++) {
+        if (callbacks[i][0] === callback) { return i; }
+      }
+
+      return -1;
+    };
+
+    var callbacksFor = function(object) {
+      var callbacks = object._promiseCallbacks;
+
+      if (!callbacks) {
+        callbacks = object._promiseCallbacks = {};
+      }
+
+      return callbacks;
+    };
+
+    var EventTarget = {
+      mixin: function(object) {
+        object.on = this.on;
+        object.off = this.off;
+        object.trigger = this.trigger;
+        return object;
+      },
+
+      on: function(eventNames, callback, binding) {
+        var allCallbacks = callbacksFor(this), callbacks, eventName;
+        eventNames = eventNames.split(/\s+/);
+        binding = binding || this;
+
+        while (eventName = eventNames.shift()) {
+          callbacks = allCallbacks[eventName];
+
+          if (!callbacks) {
+            callbacks = allCallbacks[eventName] = [];
+          }
+
+          if (indexOf(callbacks, callback) === -1) {
+            callbacks.push([callback, binding]);
+          }
+        }
+      },
+
+      off: function(eventNames, callback) {
+        var allCallbacks = callbacksFor(this), callbacks, eventName, index;
+        eventNames = eventNames.split(/\s+/);
+
+        while (eventName = eventNames.shift()) {
+          if (!callback) {
+            allCallbacks[eventName] = [];
+            continue;
+          }
+
+          callbacks = allCallbacks[eventName];
+
+          index = indexOf(callbacks, callback);
+
+          if (index !== -1) { callbacks.splice(index, 1); }
+        }
+      },
+
+      trigger: function(eventName, options) {
+        var allCallbacks = callbacksFor(this),
+            callbacks, callbackTuple, callback, binding, event;
+
+        if (callbacks = allCallbacks[eventName]) {
+          // Don't cache the callbacks.length since it may grow
+          for (var i=0; i<callbacks.length; i++) {
+            callbackTuple = callbacks[i];
+            callback = callbackTuple[0];
+            binding = callbackTuple[1];
+
+            if (typeof options !== 'object') {
+              options = { detail: options };
+            }
+
+            event = new Event(eventName, options);
+            callback.call(binding, event);
+          }
+        }
+      }
+    };
+
+
+    __exports__.EventTarget = EventTarget;
+  });
+define("rsvp/hash",
+  ["rsvp/defer","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var defer = __dependency1__.defer;
+
+    function size(object) {
+      var s = 0;
+
+      for (var prop in object) {
+        s++;
+      }
+
+      return s;
+    }
+
+    function hash(promises) {
+      var results = {}, deferred = defer(), remaining = size(promises);
+
+      if (remaining === 0) {
+        deferred.resolve({});
+      }
+
+      var resolver = function(prop) {
+        return function(value) {
+          resolveAll(prop, value);
+        };
+      };
+
+      var resolveAll = function(prop, value) {
+        results[prop] = value;
+        if (--remaining === 0) {
+          deferred.resolve(results);
+        }
+      };
+
+      var rejectAll = function(error) {
+        deferred.reject(error);
+      };
+
+      for (var prop in promises) {
+        if (promises[prop] && typeof promises[prop].then === 'function') {
+          promises[prop].then(resolver(prop), rejectAll);
+        } else {
+          resolveAll(prop, promises[prop]);
+        }
+      }
+
+      return deferred.promise;
+    }
+
+
+    __exports__.hash = hash;
+  });
+define("rsvp/node",
+  ["rsvp/promise","rsvp/all","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    var all = __dependency2__.all;
+
+    function makeNodeCallbackFor(resolve, reject) {
+      return function (error, value) {
+        if (error) {
+          reject(error);
+        } else if (arguments.length > 2) {
+          resolve(Array.prototype.slice.call(arguments, 1));
+        } else {
+          resolve(value);
+        }
+      };
+    }
+
+    function denodeify(nodeFunc) {
+      return function()  {
+        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
+        var thisArg = this;
+
+        var promise = new Promise(function(nodeResolve, nodeReject) {
+          resolve = nodeResolve;
+          reject = nodeReject;
+        });
+
+        all(nodeArgs).then(function(nodeArgs) {
+          nodeArgs.push(makeNodeCallbackFor(resolve, reject));
+
+          try {
+            nodeFunc.apply(thisArg, nodeArgs);
+          } catch(e) {
+            reject(e);
+          }
+        });
+
+        return promise;
+      };
+    }
+
+
+    __exports__.denodeify = denodeify;
+  });
+define("rsvp/promise",
+  ["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var config = __dependency1__.config;
+    var EventTarget = __dependency2__.EventTarget;
+    var CancellationError = __dependency3__.CancellationError;
+
+    function objectOrFunction(x) {
+      return isFunction(x) || (typeof x === "object" && x !== null);
+    }
+
+    function isFunction(x){
+      return typeof x === "function";
+    }
+
+    var Promise = function(resolver, canceller) {
+      var promise = this,
+      resolved = false;
+
+      if (typeof resolver !== 'function') {
+        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
+      }
+
+      if ((canceller !== undefined) && (typeof canceller !== 'function')) {
+        throw new TypeError('You can only pass a canceller function' +
+          ' as the second argument to the promise constructor');
+      }
+
+      if (!(promise instanceof Promise)) {
+        return new Promise(resolver, canceller);
+      }
+
+      var resolvePromise = function(value) {
+        if (resolved) { return; }
+        resolved = true;
+        resolve(promise, value);
+      };
+
+      var rejectPromise = function(value) {
+        if (resolved) { return; }
+        resolved = true;
+        reject(promise, value);
+      };
+
+      var notifyPromise = function(value) {
+        if (resolved) { return; }
+        notify(promise, value);
+      };
+
+      this.on('promise:failed', function(event) {
+        this.trigger('error', { detail: event.detail });
+      }, this);
+
+      this.on('error', onerror);
+
+      this.cancel = function () {
+        // For now, simply reject the promise and does not propagate the cancel
+        // to parent or children
+        if (resolved) { return; }
+        if (canceller !== undefined) {
+          try {
+            canceller();
+          } catch (e) {
+            rejectPromise(e);
+            return;
+          }
+        }
+        // Trigger cancel?
+        rejectPromise(new CancellationError());
+      };
+
+      try {
+        resolver(resolvePromise, rejectPromise, notifyPromise);
+      } catch(e) {
+        rejectPromise(e);
+      }
+    };
+
+    function onerror(event) {
+      if (config.onerror) {
+        config.onerror(event.detail);
+      }
+    }
+
+    var invokeCallback = function(type, promise, callback, event) {
+      var hasCallback = isFunction(callback),
+          value, error, succeeded, failed;
+
+      if (promise.isFulfilled) { return; }
+      if (promise.isRejected) { return; }
+
+      if (hasCallback) {
+        try {
+          value = callback(event.detail);
+          succeeded = true;
+        } catch(e) {
+          failed = true;
+          error = e;
+        }
+      } else {
+        value = event.detail;
+        succeeded = true;
+      }
+
+      if (handleThenable(promise, value)) {
+        return;
+      } else if (hasCallback && succeeded) {
+        resolve(promise, value);
+      } else if (failed) {
+        reject(promise, error);
+      } else if (type === 'resolve') {
+        resolve(promise, value);
+      } else if (type === 'reject') {
+        reject(promise, value);
+      }
+    };
+
+
+    var invokeNotifyCallback = function(promise, callback, event) {
+      var value;
+      if (typeof callback === 'function') {
+        try {
+          value = callback(event.detail);
+        } catch (e) {
+          // stop propagating
+          return;
+        }
+        notify(promise, value);
+      } else {
+        notify(promise, event.detail);
+      }
+    };
+
+    Promise.prototype = {
+      constructor: Promise,
+
+      isRejected: undefined,
+      isFulfilled: undefined,
+      rejectedReason: undefined,
+      fulfillmentValue: undefined,
+
+      then: function(done, fail, progress) {
+        this.off('error', onerror);
+
+        var thenPromise = new this.constructor(function() {},
+            function () {
+              thenPromise.trigger('promise:cancelled', {});
+            });
+
+        if (this.isFulfilled) {
+          config.async(function(promise) {
+            invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
+          }, this);
+        }
+
+        if (this.isRejected) {
+          config.async(function(promise) {
+            invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
+          }, this);
+        }
+
+        this.on('promise:resolved', function(event) {
+          invokeCallback('resolve', thenPromise, done, event);
+        });
+
+        this.on('promise:failed', function(event) {
+          invokeCallback('reject', thenPromise, fail, event);
+        });
+
+        this.on('promise:notified', function (event) {
+          invokeNotifyCallback(thenPromise, progress, event);
+        });
+
+        return thenPromise;
+      },
+
+      fail: function(fail) {
+        return this.then(null, fail);
+      },
+
+      always: function(fail) {
+        return this.then(fail, fail);
+      }
+    };
+
+    EventTarget.mixin(Promise.prototype);
+
+    function resolve(promise, value) {
+      if (promise === value) {
+        fulfill(promise, value);
+      } else if (!handleThenable(promise, value)) {
+        fulfill(promise, value);
+      }
+    }
+
+    function handleThenable(promise, value) {
+      var then = null,
+      resolved;
+
+      try {
+        if (promise === value) {
+          throw new TypeError("A promises callback cannot return that same promise.");
+        }
+
+        if (objectOrFunction(value)) {
+          then = value.then;
+
+          if (isFunction(then)) {
+            promise.on('promise:cancelled', function(event) {
+              if (isFunction(value.cancel)) {
+                value.cancel();
+              }
+            });
+            then.call(value, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              if (value !== val) {
+                resolve(promise, val);
+              } else {
+                fulfill(promise, val);
+              }
+            }, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              reject(promise, val);
+            });
+
+            return true;
+          }
+        }
+      } catch (error) {
+        reject(promise, error);
+        return true;
+      }
+
+      return false;
+    }
+
+    function fulfill(promise, value) {
+      config.async(function() {
+        if (promise.isFulfilled) { return; }
+        if (promise.isRejected) { return; }
+        promise.trigger('promise:resolved', { detail: value });
+        promise.isFulfilled = true;
+        promise.fulfillmentValue = value;
+      });
+    }
+
+    function reject(promise, value) {
+      config.async(function() {
+        if (promise.isFulfilled) { return; }
+        if (promise.isRejected) { return; }
+        promise.trigger('promise:failed', { detail: value });
+        promise.isRejected = true;
+        promise.rejectedReason = value;
+      });
+    }
+
+    function notify(promise, value) {
+      config.async(function() {
+        promise.trigger('promise:notified', { detail: value });
+      });
+    }
+
+
+    __exports__.Promise = Promise;
+  });
+define("rsvp/queue",
+  ["rsvp/promise","rsvp/timeout","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+    var delay = __dependency2__.delay;
+
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+    function ResolvedQueueError(message) {
+      this.name = "resolved";
+      if ((message !== undefined) && (typeof message !== "string")) {
+        throw new TypeError('You must pass a string.');
+      }
+      this.message = message || "Default Message";
+    }
+    ResolvedQueueError.prototype = new Error();
+    ResolvedQueueError.prototype.constructor = ResolvedQueueError;
+
+    var Queue = function() {
+      var queue = this,
+        promise_list = [],
+        promise,
+        fulfill,
+        reject,
+        resolved;
+
+      if (!(this instanceof Queue)) {
+        return new Queue();
+      }
+
+      function canceller() {
+        for (var i = 0; i < 2; i++) {
+          promise_list[i].cancel();
+        }
+      }
+
+      promise = new Promise(function(done, fail) {
+        fulfill = function (fulfillmentValue) {
+          if (resolved) {return;}
+          queue.isFulfilled = true;
+          queue.fulfillmentValue = fulfillmentValue;
+          resolved = true;
+          return done(fulfillmentValue);
+        };
+        reject = function (rejectedReason) {
+          if (resolved) {return;}
+          queue.isRejected = true;
+          queue.rejectedReason = rejectedReason ;
+          resolved = true;
+          return fail(rejectedReason);
+        };
+      }, canceller);
+
+      promise_list.push(delay());
+      promise_list.push(promise_list[0].then(function () {
+        promise_list.splice(0, 2);
+        if (promise_list.length === 0) {
+          fulfill();
+        }
+      }));
+
+      queue.cancel = function () {
+        if (resolved) {return;}
+        resolved = true;
+        promise.cancel();
+        promise.fail(function (rejectedReason) {
+          queue.isRejected = true;
+          queue.rejectedReason = rejectedReason;
+        });
+      };
+      queue.then = function () {
+        return promise.then.apply(promise, arguments);
+      };
+
+      queue.push = function(done, fail) {
+        var last_promise = promise_list[promise_list.length - 1],
+          next_promise;
+
+        if (resolved) {
+          throw new ResolvedQueueError();
+        }
+
+        next_promise = last_promise.then(done, fail);
+        promise_list.push(next_promise);
+
+        // Handle pop
+        promise_list.push(next_promise.then(function (fulfillmentValue) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            fulfill(fulfillmentValue);
+          } else {
+            return fulfillmentValue;
+          }
+        }, function (rejectedReason) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            reject(rejectedReason);
+          } else {
+            throw rejectedReason;
+          }
+        }));
+
+        return this;
+      };
+    };
+
+    Queue.prototype = Object.create(Promise.prototype);
+    Queue.prototype.constructor = Queue;
+
+
+    __exports__.Queue = Queue;
+    __exports__.ResolvedQueueError = ResolvedQueueError;
+  });
+define("rsvp/reject",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function reject(reason) {
+      return new Promise(function (resolve, reject) {
+        reject(reason);
+      });
+    }
+
+
+    __exports__.reject = reject;
+  });
+define("rsvp/resolve",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function resolve(thenable) {
+      return new Promise(function(resolve, reject) {
+        resolve(thenable);
+      });
+    }
+
+
+    __exports__.resolve = resolve;
+  });
+define("rsvp/rethrow",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var local = (typeof global === "undefined") ? this : global;
+
+    function rethrow(reason) {
+      local.setTimeout(function() {
+        throw reason;
+      });
+      throw reason;
+    }
+
+
+    __exports__.rethrow = rethrow;
+  });
+define("rsvp/timeout",
+  ["rsvp/promise","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Promise = __dependency1__.Promise;
+
+    function promiseSetTimeout(millisecond, should_reject, message) {
+      var timeout_id;
+
+      function resolver(resolve, reject) {
+        timeout_id = setTimeout(function () {
+          if (should_reject) {
+            reject(message);
+          } else {
+            resolve(message);
+          }
+        }, millisecond);
+      }
+      function canceller() {
+        clearTimeout(timeout_id);
+      }
+      return new Promise(resolver, canceller);
+    }
+
+    function delay(millisecond, message) {
+      return promiseSetTimeout(millisecond, false, message);
+    }
+
+    function timeout(millisecond) {
+      return promiseSetTimeout(millisecond, true,
+                               "Timed out after " + millisecond + " ms");
+    }
+
+    Promise.prototype.delay = function(millisecond) {
+      return this.then(function (fulfillmentValue) {
+        return delay(millisecond, fulfillmentValue);
+      });
+    };
+
+
+    __exports__.delay = delay;
+    __exports__.timeout = timeout;
+  });
+define("rsvp",
+  ["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
+    "use strict";
+    var EventTarget = __dependency1__.EventTarget;
+    var CancellationError = __dependency2__.CancellationError;
+    var Promise = __dependency3__.Promise;
+    var denodeify = __dependency4__.denodeify;
+    var all = __dependency5__.all;
+    var any = __dependency5__.any;
+    var Queue = __dependency6__.Queue;
+    var ResolvedQueueError = __dependency6__.ResolvedQueueError;
+    var delay = __dependency7__.delay;
+    var timeout = __dependency7__.timeout;
+    var hash = __dependency8__.hash;
+    var rethrow = __dependency9__.rethrow;
+    var defer = __dependency10__.defer;
+    var config = __dependency11__.config;
+    var resolve = __dependency12__.resolve;
+    var reject = __dependency13__.reject;
+
+    function configure(name, value) {
+      config[name] = value;
+    }
+
+
+    __exports__.CancellationError = CancellationError;
+    __exports__.Promise = Promise;
+    __exports__.EventTarget = EventTarget;
+    __exports__.all = all;
+    __exports__.any = any;
+    __exports__.Queue = Queue;
+    __exports__.ResolvedQueueError = ResolvedQueueError;
+    __exports__.delay = delay;
+    __exports__.timeout = timeout;
+    __exports__.hash = hash;
+    __exports__.rethrow = rethrow;
+    __exports__.defer = defer;
+    __exports__.denodeify = denodeify;
+    __exports__.configure = configure;
+    __exports__.resolve = resolve;
+    __exports__.reject = reject;
+  });
+window.RSVP = requireModule("rsvp");
+})(window);
\ No newline at end of file

dist/rsvp-2.0.4.min.js

+!function(){var a,b;!function(){var c={},d={};a=function(a,b,d){c[a]={deps:b,callback:d}},b=function(a){if(d[a])return d[a];d[a]={};var e=c[a];if(!e)throw new Error("Module '"+a+"' not found.");for(var f,g=e.deps,h=e.callback,i=[],j=0,k=g.length;k>j;j++)"exports"===g[j]?i.push(f={}):i.push(b(g[j]));var l=h.apply(this,i);return d[a]=f||l}}(),a("rsvp/all",["rsvp/promise","exports"],function(a,b){"use strict";function c(a,b){function c(){for(var a,c=0;c<b.length;c++)a=b[c],a&&"function"==typeof a.then&&"function"==typeof a.cancel&&a.cancel()}if("[object Array]"!==Object.prototype.toString.call(b))throw new TypeError("You must pass an array to all.");return new f(function(d,e,f){function g(a){return function(b){h(a,b)}}function h(a,b){l[a]=b,--m===n&&(0===n?d(l):(d(b),c()))}function i(a){return function(b){f({index:a,value:b})}}function j(a){e(a),c()}var k,l=[],m=b.length,n=b.length-a;0===m&&(1===a?d():d([]));for(var o=0;o<b.length;o++)k=b[o],k&&"function"==typeof k.then?k.then(g(o),j,i(o)):h(o,k)},c)}function d(a){return c(a.length,a)}function e(a){return c(1,a)}var f=a.Promise;b.all=d,b.any=e}),a("rsvp/async",["exports"],function(a){"use strict";function b(){return function(a,b){process.nextTick(function(){a(b)})}}function c(){return function(a,b){setImmediate(function(){a(b)})}}function d(){var a=[],b=new h(function(){var b=a.slice();a=[],b.forEach(function(a){var b=a[0],c=a[1];b(c)})}),c=document.createElement("div");return b.observe(c,{attributes:!0}),window.addEventListener("unload",function(){b.disconnect(),b=null},!1),function(b,d){a.push([b,d]),c.setAttribute("drainQueue","drainQueue")}}function e(){return function(a,b){i.setTimeout(function(){a(b)},1)}}var f,g="undefined"!=typeof window?window:{},h=g.MutationObserver||g.WebKitMutationObserver,i="undefined"!=typeof global?global:this;f="function"==typeof setImmediate?c():"undefined"!=typeof process&&"[object process]"==={}.toString.call(process)?b():h?d():e(),a.async=f}),a("rsvp/cancellation_error",["exports"],function(a){"use strict";function b(a){if(this.name="cancel",void 0!==a&&"string"!=typeof a)throw new TypeError("You must pass a string.");this.message=a||"Default Message"}b.prototype=new Error,b.prototype.constructor=b,a.CancellationError=b}),a("rsvp/config",["rsvp/async","exports"],function(a,b){"use strict";var c=a.async,d={};d.async=c,b.config=d}),a("rsvp/defer",["rsvp/promise","exports"],function(a,b){"use strict";function c(){var a={resolve:void 0,reject:void 0,promise:void 0};return a.promise=new d(function(b,c){a.resolve=b,a.reject=c}),a}var d=a.Promise;b.defer=c}),a("rsvp/events",["exports"],function(a){"use strict";var b=function(a,b){this.type=a;for(var c in b)b.hasOwnProperty(c)&&(this[c]=b[c])},c=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c][0]===b)return c;return-1},d=function(a){var b=a._promiseCallbacks;return b||(b=a._promiseCallbacks={}),b},e={mixin:function(a){return a.on=this.on,a.off=this.off,a.trigger=this.trigger,a},on:function(a,b,e){var f,g,h=d(this);for(a=a.split(/\s+/),e=e||this;g=a.shift();)f=h[g],f||(f=h[g]=[]),-1===c(f,b)&&f.push([b,e])},off:function(a,b){var e,f,g,h=d(this);for(a=a.split(/\s+/);f=a.shift();)b?(e=h[f],g=c(e,b),-1!==g&&e.splice(g,1)):h[f]=[]},trigger:function(a,c){var e,f,g,h,i,j=d(this);if(e=j[a])for(var k=0;k<e.length;k++)f=e[k],g=f[0],h=f[1],"object"!=typeof c&&(c={detail:c}),i=new b(a,c),g.call(h,i)}};a.EventTarget=e}),a("rsvp/hash",["rsvp/defer","exports"],function(a,b){"use strict";function c(a){var b=0;for(var c in a)b++;return b}function d(a){var b={},d=e(),f=c(a);0===f&&d.resolve({});var g=function(a){return function(b){h(a,b)}},h=function(a,c){b[a]=c,0===--f&&d.resolve(b)},i=function(a){d.reject(a)};for(var j in a)a[j]&&"function"==typeof a[j].then?a[j].then(g(j),i):h(j,a[j]);return d.promise}var e=a.defer;b.hash=d}),a("rsvp/node",["rsvp/promise","rsvp/all","exports"],function(a,b,c){"use strict";function d(a,b){return function(c,d){c?b(c):arguments.length>2?a(Array.prototype.slice.call(arguments,1)):a(d)}}function e(a){return function(){var b,c,e=Array.prototype.slice.call(arguments),h=this,i=new f(function(a,d){b=a,c=d});return g(e).then(function(e){e.push(d(b,c));try{a.apply(h,e)}catch(f){c(f)}}),i}}var f=a.Promise,g=b.all;c.denodeify=e}),a("rsvp/promise",["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],function(a,b,c,d){"use strict";function e(a){return f(a)||"object"==typeof a&&null!==a}function f(a){return"function"==typeof a}function g(a){m.onerror&&m.onerror(a.detail)}function h(a,b){a===b?j(a,b):i(a,b)||j(a,b)}function i(a,b){var c,d=null;try{if(a===b)throw new TypeError("A promises callback cannot return that same promise.");if(e(b)&&(d=b.then,f(d)))return a.on("promise:cancelled",function(){f(b.cancel)&&b.cancel()}),d.call(b,function(d){return c?!0:(c=!0,b!==d?h(a,d):j(a,d),void 0)},function(b){return c?!0:(c=!0,k(a,b),void 0)}),!0}catch(g){return k(a,g),!0}return!1}function j(a,b){m.async(function(){a.isFulfilled||a.isRejected||(a.trigger("promise:resolved",{detail:b}),a.isFulfilled=!0,a.fulfillmentValue=b)})}function k(a,b){m.async(function(){a.isFulfilled||a.isRejected||(a.trigger("promise:failed",{detail:b}),a.isRejected=!0,a.rejectedReason=b)})}function l(a,b){m.async(function(){a.trigger("promise:notified",{detail:b})})}var m=a.config,n=b.EventTarget,o=c.CancellationError,p=function(a,b){var c=this,d=!1;if("function"!=typeof a)throw new TypeError("You must pass a resolver function as the sole argument to the promise constructor");if(void 0!==b&&"function"!=typeof b)throw new TypeError("You can only pass a canceller function as the second argument to the promise constructor");if(!(c instanceof p))return new p(a,b);var e=function(a){d||(d=!0,h(c,a))},f=function(a){d||(d=!0,k(c,a))},i=function(a){d||l(c,a)};this.on("promise:failed",function(a){this.trigger("error",{detail:a.detail})},this),this.on("error",g),this.cancel=function(){if(!d){if(void 0!==b)try{b()}catch(a){return f(a),void 0}f(new o)}};try{a(e,f,i)}catch(j){f(j)}},q=function(a,b,c,d){var e,g,j,l,m=f(c);if(!b.isFulfilled&&!b.isRejected){if(m)try{e=c(d.detail),j=!0}catch(n){l=!0,g=n}else e=d.detail,j=!0;i(b,e)||(m&&j?h(b,e):l?k(b,g):"resolve"===a?h(b,e):"reject"===a&&k(b,e))}},r=function(a,b,c){var d;if("function"==typeof b){try{d=b(c.detail)}catch(e){return}l(a,d)}else l(a,c.detail)};p.prototype={constructor:p,isRejected:void 0,isFulfilled:void 0,rejectedReason:void 0,fulfillmentValue:void 0,then:function(a,b,c){this.off("error",g);var d=new this.constructor(function(){},function(){d.trigger("promise:cancelled",{})});return this.isFulfilled&&m.async(function(b){q("resolve",d,a,{detail:b.fulfillmentValue})},this),this.isRejected&&m.async(function(a){q("reject",d,b,{detail:a.rejectedReason})},this),this.on("promise:resolved",function(b){q("resolve",d,a,b)}),this.on("promise:failed",function(a){q("reject",d,b,a)}),this.on("promise:notified",function(a){r(d,c,a)}),d},fail:function(a){return this.then(null,a)},always:function(a){return this.then(a,a)}},n.mixin(p.prototype),d.Promise=p}),a("rsvp/queue",["rsvp/promise","rsvp/timeout","exports"],function(a,b,c){"use strict";function d(a){if(this.name="resolved",void 0!==a&&"string"!=typeof a)throw new TypeError("You must pass a string.");this.message=a||"Default Message"}var e=a.Promise,f=b.delay;d.prototype=new Error,d.prototype.constructor=d;var g=function(){function a(){for(var a=0;2>a;a++)k[a].cancel()}var b,c,h,i,j=this,k=[];return this instanceof g?(b=new e(function(a,b){c=function(b){return i?void 0:(j.isFulfilled=!0,j.fulfillmentValue=b,i=!0,a(b))},h=function(a){return i?void 0:(j.isRejected=!0,j.rejectedReason=a,i=!0,b(a))}},a),k.push(f()),k.push(k[0].then(function(){k.splice(0,2),0===k.length&&c()})),j.cancel=function(){i||(i=!0,b.cancel(),b.fail(function(a){j.isRejected=!0,j.rejectedReason=a}))},j.then=function(){return b.then.apply(b,arguments)},j.push=function(a,b){var e,f=k[k.length-1];if(i)throw new d;return e=f.then(a,b),k.push(e),k.push(e.then(function(a){return k.splice(0,2),0!==k.length?a:(c(a),void 0)},function(a){if(k.splice(0,2),0!==k.length)throw a;h(a)})),this},void 0):new g};g.prototype=Object.create(e.prototype),g.prototype.constructor=g,c.Queue=g,c.ResolvedQueueError=d}),a("rsvp/reject",["rsvp/promise","exports"],function(a,b){"use strict";function c(a){return new d(function(b,c){c(a)})}var d=a.Promise;b.reject=c}),a("rsvp/resolve",["rsvp/promise","exports"],function(a,b){"use strict";function c(a){return new d(function(b){b(a)})}var d=a.Promise;b.resolve=c}),a("rsvp/rethrow",["exports"],function(a){"use strict";function b(a){throw c.setTimeout(function(){throw a}),a}var c="undefined"==typeof global?this:global;a.rethrow=b}),a("rsvp/timeout",["rsvp/promise","exports"],function(a,b){"use strict";function c(a,b,c){function d(d,e){g=setTimeout(function(){b?e(c):d(c)},a)}function e(){clearTimeout(g)}var g;return new f(d,e)}function d(a,b){return c(a,!1,b)}function e(a){return c(a,!0,"Timed out after "+a+" ms")}var f=a.Promise;f.prototype.delay=function(a){return this.then(function(b){return d(a,b)})},b.delay=d,b.timeout=e}),a("rsvp",["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],function(a,b,c,d,e,f,g,h,i,j,k,l,m,n){"use strict";function o(a,b){C[a]=b}var p=a.EventTarget,q=b.CancellationError,r=c.Promise,s=d.denodeify,t=e.all,u=e.any,v=f.Queue,w=f.ResolvedQueueError,x=g.delay,y=g.timeout,z=h.hash,A=i.rethrow,B=j.defer,C=k.config,D=l.resolve,E=m.reject;n.CancellationError=q,n.Promise=r,n.EventTarget=p,n.all=t,n.any=u,n.Queue=v,n.ResolvedQueueError=w,n.delay=x,n.timeout=y,n.hash=z,n.rethrow=A,n.defer=B,n.denodeify=s,n.configure=o,n.resolve=D,n.reject=E}),window.RSVP=b("rsvp")}(window);
\ No newline at end of file