/*

html2canvas 0.5.0-alpha2 <http://html2canvas.hertzen.com>

Copyright (c) 2015 Niklas von Hertzen

Released under MIT License

*/

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.html2canvas = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){

(function (process,global){

/*!

* @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 2.3.0

*/

(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$$toString = {}.toString;

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 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() {

var nextTick = process.nextTick;

// node version 0.10.x displays a deprecation warning when nextTick is used recursively

// setImmediate should be used instead instead

var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);

if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {

nextTick = setImmediate;

}

return function() {

nextTick(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$$attemptVertex() {

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$$attemptVertex();

} else {

lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();

}

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$$selfFullfillment() {

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) {

if (maybeThenable.constructor === promise.constructor) {

lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);

} else {

var then = lib$es6$promise$$internal$$getThen(maybeThenable);

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$$selfFullfillment());

} else if (lib$es6$promise$utils$$objectOrFunction(value)) {

lib$es6$promise$$internal$$handleMaybeThenable(promise, 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);

}

}

function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {

var enumerator = this;

enumerator._instanceConstructor = Constructor;

enumerator.promise = new Constructor(lib$es6$promise$$internal$$noop);

if (enumerator._validateInput(input)) {

enumerator._input = input;

enumerator.length = input.length;

enumerator._remaining = input.length;

enumerator._init();

if (enumerator.length === 0) {

lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result);

} else {

enumerator.length = enumerator.length || 0;

enumerator._enumerate();

if (enumerator._remaining === 0) {

lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result);

}

}

} else {

lib$es6$promise$$internal$$reject(enumerator.promise, enumerator._validationError());

}

}

lib$es6$promise$enumerator$$Enumerator.prototype._validateInput = function(input) {

return lib$es6$promise$utils$$isArray(input);

};

lib$es6$promise$enumerator$$Enumerator.prototype._validationError = function() {

return new Error('Array Methods must be provided an Array');

};

lib$es6$promise$enumerator$$Enumerator.prototype._init = function() {

this._result = new Array(this.length);

};

var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;

lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {

var enumerator = this;

var length = enumerator.length;

var promise = enumerator.promise;

var input = enumerator._input;

for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {

enumerator._eachEntry(input[i], i);

}

};

lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {

var enumerator = this;

var c = enumerator._instanceConstructor;

if (lib$es6$promise$utils$$isMaybeThenable(entry)) {

if (entry.constructor === c && entry._state !== lib$es6$promise$$internal$$PENDING) {

entry._onerror = null;

enumerator._settledAt(entry._state, i, entry._result);

} else {

enumerator._willSettleAt(c.resolve(entry), i);

}

} else {

enumerator._remaining--;

enumerator._result[i] = entry;

}

};

lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {

var enumerator = this;

var promise = enumerator.promise;

if (promise._state === lib$es6$promise$$internal$$PENDING) {

enumerator._remaining--;

if (state === lib$es6$promise$$internal$$REJECTED) {

lib$es6$promise$$internal$$reject(promise, value);

} else {

enumerator._result[i] = value;

}

}

if (enumerator._remaining === 0) {

lib$es6$promise$$internal$$fulfill(promise, enumerator._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$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;

var promise = new Constructor(lib$es6$promise$$internal$$noop);

if (!lib$es6$promise$utils$$isArray(entries)) {

lib$es6$promise$$internal$$reject(promise, new TypeError('You must pass an array to race.'));

return promise;

}

var length = entries.length;

function onFulfillment(value) {

lib$es6$promise$$internal$$resolve(promise, value);

}

function onRejection(reason) {

lib$es6$promise$$internal$$reject(promise, reason);

}

for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {

lib$es6$promise$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);

}

return promise;

}

var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;

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;

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;

var lib$es6$promise$promise$$counter = 0;

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._id = lib$es6$promise$promise$$counter++;

this._state = undefined;

this._result = undefined;

this._subscribers = [];

if (lib$es6$promise$$internal$$noop !== resolver) {

if (!lib$es6$promise$utils$$isFunction(resolver)) {

lib$es6$promise$promise$$needsResolver();

}

if (!(this instanceof lib$es6$promise$promise$$Promise)) {

lib$es6$promise$promise$$needsNew();

}

lib$es6$promise$$internal$$initializePromise(this, resolver);

}

}

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: function(onFulfillment, onRejection) {

var parent = this;

var state = parent._state;

if (state === lib$es6$promise$$internal$$FULFILLED && !onFulfillment || state === lib$es6$promise$$internal$$REJECTED && !onRejection) {

return this;

}

var child = new this.constructor(lib$es6$promise$$internal$$noop);

var result = parent._result;

if (state) {

var callback = arguments[state - 1];

lib$es6$promise$asap$$asap(function(){

lib$es6$promise$$internal$$invokeCallback(state, child, callback, result);

});

} else {

lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);

}

return child;

},

/**

`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same

as the catch block of a try/catch statement.

```js

function findAuthor(){

throw new Error('couldn't find that author');

}

// synchronous

try {

findAuthor();

} catch(reason) {

// something went wrong

}

// async with promises

findAuthor().catch(function(reason){

// something went wrong

});

```

@method catch

@param {Function} onRejection

Useful for tooling.

@return {Promise}

*/

'catch': function(onRejection) {

return this.then(null, onRejection);

}

};

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;

var lib$es6$promise$umd$$ES6Promise = {

'Promise': 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$umd$$ES6Promise; });

} else if (typeof module !== 'undefined' && module['exports']) {

module['exports'] = lib$es6$promise$umd$$ES6Promise;

} else if (typeof this !== 'undefined') {

this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise;

}

lib$es6$promise$polyfill$$default();

}).call(this);

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"_process":2}],2:[function(require,module,exports){

// shim for using process in browser

var process = module.exports = {};

var queue = [];

var draining = false;

var currentQueue;

var queueIndex = -1;

function cleanUpNextTick() {

draining = false;

if (currentQueue.length) {

queue = currentQueue.concat(queue);

} else {

queueIndex = -1;

}

if (queue.length) {