diff --git a/decktape.js b/decktape.js
index cb360e7..7883916 100644
--- a/decktape.js
+++ b/decktape.js
@@ -21,7 +21,7 @@ var fs      = require('fs'),
     page    = require('webpage').create(),
     parser  = require('nomnom'),
     printer = require('printer').create(),
-    Promise = require('promise');
+    Promise = require('es6-promise').Promise;
 
 var plugins = loadAvailablePlugins(phantom.libraryPath + '/plugins/');
 
diff --git a/libs/es6-promise.js b/libs/es6-promise.js
new file mode 100644
index 0000000..8e2951e
--- /dev/null
+++ b/libs/es6-promise.js
@@ -0,0 +1,956 @@
+/*!
+ * @overview es6-promise - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+ * @license   Licensed under MIT license
+ *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
+ * @version   3.2.2+39aa2571
+ */
+
+(function() {
+    "use strict";
+    function lib$es6$promise$utils$$objectOrFunction(x) {
+        return typeof x === 'function' || (typeof x === 'object' && x !== null);
+    }
+
+    function lib$es6$promise$utils$$isFunction(x) {
+        return typeof x === 'function';
+    }
+
+    function lib$es6$promise$utils$$isMaybeThenable(x) {
+        return typeof x === 'object' && x !== null;
+    }
+
+    var lib$es6$promise$utils$$_isArray;
+    if (!Array.isArray) {
+        lib$es6$promise$utils$$_isArray = function (x) {
+            return Object.prototype.toString.call(x) === '[object Array]';
+        };
+    } else {
+        lib$es6$promise$utils$$_isArray = Array.isArray;
+    }
+
+    var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray;
+    var lib$es6$promise$asap$$len = 0;
+    var lib$es6$promise$asap$$vertxNext;
+    var lib$es6$promise$asap$$customSchedulerFn;
+
+    var lib$es6$promise$asap$$asap = function asap(callback, arg) {
+        lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback;
+        lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg;
+        lib$es6$promise$asap$$len += 2;
+        if (lib$es6$promise$asap$$len === 2) {
+            // If len is 2, that means that we need to schedule an async flush.
+            // If additional callbacks are queued before the queue is flushed, they
+            // will be processed by this flush that we are scheduling.
+            if (lib$es6$promise$asap$$customSchedulerFn) {
+                lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush);
+            } else {
+                lib$es6$promise$asap$$scheduleFlush();
+            }
+        }
+    }
+
+    function lib$es6$promise$asap$$setScheduler(scheduleFn) {
+        lib$es6$promise$asap$$customSchedulerFn = scheduleFn;
+    }
+
+    function lib$es6$promise$asap$$setAsap(asapFn) {
+        lib$es6$promise$asap$$asap = asapFn;
+    }
+
+    var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;
+    var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {};
+    var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;
+    var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+
+    // test for web worker but not in IE10
+    var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
+        typeof importScripts !== 'undefined' &&
+        typeof MessageChannel !== 'undefined';
+
+    // node
+    function lib$es6$promise$asap$$useNextTick() {
+        // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+        // see https://github.com/cujojs/when/issues/410 for details
+        return function() {
+            process.nextTick(lib$es6$promise$asap$$flush);
+        };
+    }
+
+    // vertx
+    function lib$es6$promise$asap$$useVertxTimer() {
+        return function() {
+            lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush);
+        };
+    }
+
+    function lib$es6$promise$asap$$useMutationObserver() {
+        var iterations = 0;
+        var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush);
+        var node = document.createTextNode('');
+        observer.observe(node, { characterData: true });
+
+        return function() {
+            node.data = (iterations = ++iterations % 2);
+        };
+    }
+
+    // web worker
+    function lib$es6$promise$asap$$useMessageChannel() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = lib$es6$promise$asap$$flush;
+        return function () {
+            channel.port2.postMessage(0);
+        };
+    }
+
+    function lib$es6$promise$asap$$useSetTimeout() {
+        return function() {
+            setTimeout(lib$es6$promise$asap$$flush, 1);
+        };
+    }
+
+    var lib$es6$promise$asap$$queue = new Array(1000);
+    function lib$es6$promise$asap$$flush() {
+        for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {
+            var callback = lib$es6$promise$asap$$queue[i];
+            var arg = lib$es6$promise$asap$$queue[i+1];
+
+            callback(arg);
+
+            lib$es6$promise$asap$$queue[i] = undefined;
+            lib$es6$promise$asap$$queue[i+1] = undefined;
+        }
+
+        lib$es6$promise$asap$$len = 0;
+    }
+
+    function lib$es6$promise$asap$$attemptVertx() {
+        try {
+            var r = require;
+            var vertx = r('vertx');
+            lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;
+            return lib$es6$promise$asap$$useVertxTimer();
+        } catch(e) {
+            return lib$es6$promise$asap$$useSetTimeout();
+        }
+    }
+
+    var lib$es6$promise$asap$$scheduleFlush;
+    // Decide what async method to use to triggering processing of queued callbacks:
+    if (lib$es6$promise$asap$$isNode) {
+        lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick();
+    } else if (lib$es6$promise$asap$$BrowserMutationObserver) {
+        lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver();
+    } else if (lib$es6$promise$asap$$isWorker) {
+        lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel();
+    } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') {
+        lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx();
+    } else {
+        lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();
+    }
+    function lib$es6$promise$then$$then(onFulfillment, onRejection) {
+        var parent = this;
+
+        var child = new this.constructor(lib$es6$promise$$internal$$noop);
+
+        if (child[lib$es6$promise$$internal$$PROMISE_ID] === undefined) {
+            lib$es6$promise$$internal$$makePromise(child);
+        }
+
+        var state = parent._state;
+
+        if (state) {
+            var callback = arguments[state - 1];
+            lib$es6$promise$asap$$asap(function(){
+                lib$es6$promise$$internal$$invokeCallback(state, child, callback, parent._result);
+            });
+        } else {
+            lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);
+        }
+
+        return child;
+    }
+    var lib$es6$promise$then$$default = lib$es6$promise$then$$then;
+    function lib$es6$promise$promise$resolve$$resolve(object) {
+        /*jshint validthis:true */
+        var Constructor = this;
+
+        if (object && typeof object === 'object' && object.constructor === Constructor) {
+            return object;
+        }
+
+        var promise = new Constructor(lib$es6$promise$$internal$$noop);
+        lib$es6$promise$$internal$$resolve(promise, object);
+        return promise;
+    }
+    var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;
+    var lib$es6$promise$$internal$$PROMISE_ID = Math.random().toString(36).substring(16);
+
+    function lib$es6$promise$$internal$$noop() {}
+
+    var lib$es6$promise$$internal$$PENDING   = void 0;
+    var lib$es6$promise$$internal$$FULFILLED = 1;
+    var lib$es6$promise$$internal$$REJECTED  = 2;
+
+    var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject();
+
+    function lib$es6$promise$$internal$$selfFulfillment() {
+        return new TypeError("You cannot resolve a promise with itself");
+    }
+
+    function lib$es6$promise$$internal$$cannotReturnOwn() {
+        return new TypeError('A promises callback cannot return that same promise.');
+    }
+
+    function lib$es6$promise$$internal$$getThen(promise) {
+        try {
+            return promise.then;
+        } catch(error) {
+            lib$es6$promise$$internal$$GET_THEN_ERROR.error = error;
+            return lib$es6$promise$$internal$$GET_THEN_ERROR;
+        }
+    }
+
+    function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
+        try {
+            then.call(value, fulfillmentHandler, rejectionHandler);
+        } catch(e) {
+            return e;
+        }
+    }
+
+    function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) {
+        lib$es6$promise$asap$$asap(function(promise) {
+            var sealed = false;
+            var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) {
+                if (sealed) { return; }
+                sealed = true;
+                if (thenable !== value) {
+                    lib$es6$promise$$internal$$resolve(promise, value);
+                } else {
+                    lib$es6$promise$$internal$$fulfill(promise, value);
+                }
+            }, function(reason) {
+                if (sealed) { return; }
+                sealed = true;
+
+                lib$es6$promise$$internal$$reject(promise, reason);
+            }, 'Settle: ' + (promise._label || ' unknown promise'));
+
+            if (!sealed && error) {
+                sealed = true;
+                lib$es6$promise$$internal$$reject(promise, error);
+            }
+        }, promise);
+    }
+
+    function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) {
+        if (thenable._state === lib$es6$promise$$internal$$FULFILLED) {
+            lib$es6$promise$$internal$$fulfill(promise, thenable._result);
+        } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) {
+            lib$es6$promise$$internal$$reject(promise, thenable._result);
+        } else {
+            lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) {
+                lib$es6$promise$$internal$$resolve(promise, value);
+            }, function(reason) {
+                lib$es6$promise$$internal$$reject(promise, reason);
+            });
+        }
+    }
+
+    function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) {
+        if (maybeThenable.constructor === promise.constructor &&
+            then === lib$es6$promise$then$$default &&
+            constructor.resolve === lib$es6$promise$promise$resolve$$default) {
+            lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);
+        } else {
+            if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) {
+                lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error);
+            } else if (then === undefined) {
+                lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
+            } else if (lib$es6$promise$utils$$isFunction(then)) {
+                lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);
+            } else {
+                lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
+            }
+        }
+    }
+
+    function lib$es6$promise$$internal$$resolve(promise, value) {
+        if (promise === value) {
+            lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment());
+        } else if (lib$es6$promise$utils$$objectOrFunction(value)) {
+            lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value));
+        } else {
+            lib$es6$promise$$internal$$fulfill(promise, value);
+        }
+    }
+
+    function lib$es6$promise$$internal$$publishRejection(promise) {
+        if (promise._onerror) {
+            promise._onerror(promise._result);
+        }
+
+        lib$es6$promise$$internal$$publish(promise);
+    }
+
+    function lib$es6$promise$$internal$$fulfill(promise, value) {
+        if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
+
+        promise._result = value;
+        promise._state = lib$es6$promise$$internal$$FULFILLED;
+
+        if (promise._subscribers.length !== 0) {
+            lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise);
+        }
+    }
+
+    function lib$es6$promise$$internal$$reject(promise, reason) {
+        if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
+        promise._state = lib$es6$promise$$internal$$REJECTED;
+        promise._result = reason;
+
+        lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise);
+    }
+
+    function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
+        var subscribers = parent._subscribers;
+        var length = subscribers.length;
+
+        parent._onerror = null;
+
+        subscribers[length] = child;
+        subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment;
+        subscribers[length + lib$es6$promise$$internal$$REJECTED]  = onRejection;
+
+        if (length === 0 && parent._state) {
+            lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent);
+        }
+    }
+
+    function lib$es6$promise$$internal$$publish(promise) {
+        var subscribers = promise._subscribers;
+        var settled = promise._state;
+
+        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) {
+                lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail);
+            } else {
+                callback(detail);
+            }
+        }
+
+        promise._subscribers.length = 0;
+    }
+
+    function lib$es6$promise$$internal$$ErrorObject() {
+        this.error = null;
+    }
+
+    var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject();
+
+    function lib$es6$promise$$internal$$tryCatch(callback, detail) {
+        try {
+            return callback(detail);
+        } catch(e) {
+            lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e;
+            return lib$es6$promise$$internal$$TRY_CATCH_ERROR;
+        }
+    }
+
+    function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) {
+        var hasCallback = lib$es6$promise$utils$$isFunction(callback),
+            value, error, succeeded, failed;
+
+        if (hasCallback) {
+            value = lib$es6$promise$$internal$$tryCatch(callback, detail);
+
+            if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) {
+                failed = true;
+                error = value.error;
+                value = null;
+            } else {
+                succeeded = true;
+            }
+
+            if (promise === value) {
+                lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn());
+                return;
+            }
+
+        } else {
+            value = detail;
+            succeeded = true;
+        }
+
+        if (promise._state !== lib$es6$promise$$internal$$PENDING) {
+            // noop
+        } else if (hasCallback && succeeded) {
+            lib$es6$promise$$internal$$resolve(promise, value);
+        } else if (failed) {
+            lib$es6$promise$$internal$$reject(promise, error);
+        } else if (settled === lib$es6$promise$$internal$$FULFILLED) {
+            lib$es6$promise$$internal$$fulfill(promise, value);
+        } else if (settled === lib$es6$promise$$internal$$REJECTED) {
+            lib$es6$promise$$internal$$reject(promise, value);
+        }
+    }
+
+    function lib$es6$promise$$internal$$initializePromise(promise, resolver) {
+        try {
+            resolver(function resolvePromise(value){
+                lib$es6$promise$$internal$$resolve(promise, value);
+            }, function rejectPromise(reason) {
+                lib$es6$promise$$internal$$reject(promise, reason);
+            });
+        } catch(e) {
+            lib$es6$promise$$internal$$reject(promise, e);
+        }
+    }
+
+    var lib$es6$promise$$internal$$id = 0;
+    function lib$es6$promise$$internal$$nextId() {
+        return lib$es6$promise$$internal$$id++;
+    }
+
+    function lib$es6$promise$$internal$$makePromise(promise) {
+        promise[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$id++;
+        promise._state = undefined;
+        promise._result = undefined;
+        promise._subscribers = [];
+    }
+
+    function lib$es6$promise$promise$all$$all(entries) {
+        return new lib$es6$promise$enumerator$$default(this, entries).promise;
+    }
+    var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;
+    function lib$es6$promise$promise$race$$race(entries) {
+        /*jshint validthis:true */
+        var Constructor = this;
+
+        if (!lib$es6$promise$utils$$isArray(entries)) {
+            return new Constructor(function(resolve, reject) {
+                reject(new TypeError('You must pass an array to race.'));
+            });
+        } else {
+            return new Constructor(function(resolve, reject) {
+                var length = entries.length;
+                for (var i = 0; i < length; i++) {
+                    Constructor.resolve(entries[i]).then(resolve, reject);
+                }
+            });
+        }
+    }
+    var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;
+    function lib$es6$promise$promise$reject$$reject(reason) {
+        /*jshint validthis:true */
+        var Constructor = this;
+        var promise = new Constructor(lib$es6$promise$$internal$$noop);
+        lib$es6$promise$$internal$$reject(promise, reason);
+        return promise;
+    }
+    var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;
+
+
+    function lib$es6$promise$promise$$needsResolver() {
+        throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+    }
+
+    function lib$es6$promise$promise$$needsNew() {
+        throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+    }
+
+    var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;
+    /**
+     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 Promise
+     @param {function} resolver
+     Useful for tooling.
+     @constructor
+     */
+    function lib$es6$promise$promise$$Promise(resolver) {
+        this[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$nextId();
+        this._result = this._state = undefined;
+        this._subscribers = [];
+
+        if (lib$es6$promise$$internal$$noop !== resolver) {
+            typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();
+            this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();
+        }
+    }
+
+    lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default;
+    lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default;
+    lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default;
+    lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default;
+    lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler;
+    lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap;
+    lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap;
+
+    lib$es6$promise$promise$$Promise.prototype = {
+        constructor: lib$es6$promise$promise$$Promise,
+
+        /**
+         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
+         Useful for tooling.
+         @return {Promise}
+         */
+        then: lib$es6$promise$then$$default,
+
+        /**
+         `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+         as the catch block of a try/catch statement.
+
+         ```js
+         function findAuthor(){
+        throw new Error('couldn't find that author');
+      }
+
+         // synchronous
+         try {
+        findAuthor();
+      } catch(reason) {
+        // something went wrong
+      }
+
+         // async with promises
+         findAuthor().catch(function(reason){
+        // something went wrong
+      });
+         ```
+
+         @method catch
+         @param {Function} onRejection
+         Useful for tooling.
+         @return {Promise}
+         */
+        'catch': function(onRejection) {
+            return this.then(null, onRejection);
+        }
+    };
+    var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;
+    function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {
+        this._instanceConstructor = Constructor;
+        this.promise = new Constructor(lib$es6$promise$$internal$$noop);
+
+        if (!this.promise[lib$es6$promise$$internal$$PROMISE_ID]) {
+            lib$es6$promise$$internal$$makePromise(this.promise);
+        }
+
+        if (lib$es6$promise$utils$$isArray(input)) {
+            this._input     = input;
+            this.length     = input.length;
+            this._remaining = input.length;
+
+            this._result = new Array(this.length);
+
+            if (this.length === 0) {
+                lib$es6$promise$$internal$$fulfill(this.promise, this._result);
+            } else {
+                this.length = this.length || 0;
+                this._enumerate();
+                if (this._remaining === 0) {
+                    lib$es6$promise$$internal$$fulfill(this.promise, this._result);
+                }
+            }
+        } else {
+            lib$es6$promise$$internal$$reject(this.promise, lib$es6$promise$enumerator$$validationError());
+        }
+    }
+
+    function lib$es6$promise$enumerator$$validationError() {
+        return new Error('Array Methods must be provided an Array');
+    }
+
+    lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {
+        var length  = this.length;
+        var input   = this._input;
+
+        for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {
+            this._eachEntry(input[i], i);
+        }
+    };
+
+    lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
+        var c = this._instanceConstructor;
+        var resolve = c.resolve;
+
+        if (resolve === lib$es6$promise$promise$resolve$$default) {
+            var then = lib$es6$promise$$internal$$getThen(entry);
+
+            if (then === lib$es6$promise$then$$default &&
+                entry._state !== lib$es6$promise$$internal$$PENDING) {
+                this._settledAt(entry._state, i, entry._result);
+            } else if (typeof then !== 'function') {
+                this._remaining--;
+                this._result[i] = entry;
+            } else if (c === lib$es6$promise$promise$$default) {
+                var promise = new c(lib$es6$promise$$internal$$noop);
+                lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then);
+                this._willSettleAt(promise, i);
+            } else {
+                this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);
+            }
+        } else {
+            this._willSettleAt(resolve(entry), i);
+        }
+    };
+
+    lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
+        var promise = this.promise;
+
+        if (promise._state === lib$es6$promise$$internal$$PENDING) {
+            this._remaining--;
+
+            if (state === lib$es6$promise$$internal$$REJECTED) {
+                lib$es6$promise$$internal$$reject(promise, value);
+            } else {
+                this._result[i] = value;
+            }
+        }
+
+        if (this._remaining === 0) {
+            lib$es6$promise$$internal$$fulfill(promise, this._result);
+        }
+    };
+
+    lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
+        var enumerator = this;
+
+        lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) {
+            enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value);
+        }, function(reason) {
+            enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason);
+        });
+    };
+    function lib$es6$promise$polyfill$$polyfill() {
+        var local;
+
+        if (typeof global !== 'undefined') {
+            local = global;
+        } else if (typeof self !== 'undefined') {
+            local = self;
+        } else {
+            try {
+                local = Function('return this')();
+            } catch (e) {
+                throw new Error('polyfill failed because global object is unavailable in this environment');
+            }
+        }
+
+        var P = local.Promise;
+
+        if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {
+            return;
+        }
+
+        local.Promise = lib$es6$promise$promise$$default;
+    }
+    var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;
+
+    lib$es6$promise$promise$$default.Promise = lib$es6$promise$promise$$default;
+    lib$es6$promise$promise$$default.polyfill = lib$es6$promise$polyfill$$default;
+
+    /* global define:true module:true window: true */
+    if (typeof define === 'function' && define['amd']) {
+        define(function() { return lib$es6$promise$promise$$default; });
+    } else if (typeof module !== 'undefined' && module['exports']) {
+        module['exports'] = lib$es6$promise$promise$$default;
+    } else if (typeof this !== 'undefined') {
+        this['Promise'] = lib$es6$promise$promise$$default;
+    }
+
+    lib$es6$promise$polyfill$$default();
+}).call(this);
diff --git a/libs/promise.js b/libs/promise.js
deleted file mode 100644
index 6bccc93..0000000
--- a/libs/promise.js
+++ /dev/null
@@ -1,230 +0,0 @@
-// https://github.com/taylorhakes/promise-polyfill
-(function (root) {
-
-    // Store setTimeout reference so promise-polyfill will be unaffected by
-    // other code modifying setTimeout (like sinon.useFakeTimers())
-    var setTimeoutFunc = setTimeout;
-
-    function noop() {
-    }
-
-    // Use polyfill for setImmediate for performance gains
-    var asap = (typeof setImmediate === 'function' && setImmediate) ||
-        function (fn) {
-            setTimeoutFunc(fn, 1);
-        };
-
-    var onUnhandledRejection = function onUnhandledRejection(err) {
-        if (typeof console !== 'undefined' && console) {
-            console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
-        }
-    };
-
-    // Polyfill for Function.prototype.bind
-    function bind(fn, thisArg) {
-        return function () {
-            fn.apply(thisArg, arguments);
-        };
-    }
-
-    function Promise(fn) {
-        if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
-        if (typeof fn !== 'function') throw new TypeError('not a function');
-        this._state = 0;
-        this._handled = false;
-        this._value = undefined;
-        this._deferreds = [];
-
-        doResolve(fn, this);
-    }
-
-    function handle(self, deferred) {
-        while (self._state === 3) {
-            self = self._value;
-        }
-        if (self._state === 0) {
-            self._deferreds.push(deferred);
-            return;
-        }
-        self._handled = true;
-        asap(function () {
-            var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
-            if (cb === null) {
-                (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
-                return;
-            }
-            var ret;
-            try {
-                ret = cb(self._value);
-            } catch (e) {
-                reject(deferred.promise, e);
-                return;
-            }
-            resolve(deferred.promise, ret);
-        });
-    }
-
-    function resolve(self, newValue) {
-        try {
-            // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
-            if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
-            if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
-                var then = newValue.then;
-                if (newValue instanceof Promise) {
-                    self._state = 3;
-                    self._value = newValue;
-                    finale(self);
-                    return;
-                } else if (typeof then === 'function') {
-                    doResolve(bind(then, newValue), self);
-                    return;
-                }
-            }
-            self._state = 1;
-            self._value = newValue;
-            finale(self);
-        } catch (e) {
-            reject(self, e);
-        }
-    }
-
-    function reject(self, newValue) {
-        self._state = 2;
-        self._value = newValue;
-        finale(self);
-    }
-
-    function finale(self) {
-        if (self._state === 2 && self._deferreds.length === 0) {
-            asap(function() {
-                if (!self._handled) {
-                    onUnhandledRejection(self._value);
-                }
-            });
-        }
-
-        for (var i = 0, len = self._deferreds.length; i < len; i++) {
-            handle(self, self._deferreds[i]);
-        }
-        self._deferreds = null;
-    }
-
-    function Handler(onFulfilled, onRejected, promise) {
-        this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
-        this.onRejected = typeof onRejected === 'function' ? onRejected : null;
-        this.promise = promise;
-    }
-
-    /**
-     * Take a potentially misbehaving resolver function and make sure
-     * onFulfilled and onRejected are only called once.
-     *
-     * Makes no guarantees about asynchrony.
-     */
-    function doResolve(fn, self) {
-        var done = false;
-        try {
-            fn(function (value) {
-                if (done) return;
-                done = true;
-                resolve(self, value);
-            }, function (reason) {
-                if (done) return;
-                done = true;
-                reject(self, reason);
-            });
-        } catch (ex) {
-            if (done) return;
-            done = true;
-            reject(self, ex);
-        }
-    }
-
-    Promise.prototype['catch'] = function (onRejected) {
-        return this.then(null, onRejected);
-    };
-
-    Promise.prototype.then = function (onFulfilled, onRejected) {
-        var prom = new (this.constructor)(noop);
-
-        handle(this, new Handler(onFulfilled, onRejected, prom));
-        return prom;
-    };
-
-    Promise.all = function (arr) {
-        var args = Array.prototype.slice.call(arr);
-
-        return new Promise(function (resolve, reject) {
-            if (args.length === 0) return resolve([]);
-            var remaining = args.length;
-
-            function res(i, val) {
-                try {
-                    if (val && (typeof val === 'object' || typeof val === 'function')) {
-                        var then = val.then;
-                        if (typeof then === 'function') {
-                            then.call(val, function (val) {
-                                res(i, val);
-                            }, reject);
-                            return;
-                        }
-                    }
-                    args[i] = val;
-                    if (--remaining === 0) {
-                        resolve(args);
-                    }
-                } catch (ex) {
-                    reject(ex);
-                }
-            }
-
-            for (var i = 0; i < args.length; i++) {
-                res(i, args[i]);
-            }
-        });
-    };
-
-    Promise.resolve = function (value) {
-        if (value && typeof value === 'object' && value.constructor === Promise) {
-            return value;
-        }
-
-        return new Promise(function (resolve) {
-            resolve(value);
-        });
-    };
-
-    Promise.reject = function (value) {
-        return new Promise(function (resolve, reject) {
-            reject(value);
-        });
-    };
-
-    Promise.race = function (values) {
-        return new Promise(function (resolve, reject) {
-            for (var i = 0, len = values.length; i < len; i++) {
-                values[i].then(resolve, reject);
-            }
-        });
-    };
-
-    /**
-     * Set the immediate function to execute callbacks
-     * @param fn {function} Function to execute
-     * @private
-     */
-    Promise._setImmediateFn = function _setImmediateFn(fn) {
-        asap = fn;
-    };
-
-    Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
-        onUnhandledRejection = fn;
-    };
-
-    if (typeof module !== 'undefined' && module.exports) {
-        module.exports = Promise;
-    } else if (!root.Promise) {
-        root.Promise = Promise;
-    }
-
-})(this);
\ No newline at end of file