text: (function(root) {
  
  	// Use polyfill for setImmediate for performance gains
  	var asap = Promise.immediateFn || (typeof setImmediate === 'function' && setImmediate) ||
  		function(fn) { setTimeout(fn, 1); };
  
  	// Polyfill for Function.prototype.bind
  	function bind(fn, thisArg) {
  		return function() {
  			fn.apply(thisArg, arguments);
  		}
  	}
  
  	var isArray = Array.isArray || function(value) { return Object.prototype.toString.call(value) === "[object Array]" };
  
  	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 = null;
  		this._value = null;
  		this._deferreds = []
  
  		doResolve(fn, bind(resolve, this), bind(reject, this))
  	}
  
  	function handle(deferred) {
  		var me = this;
  		if (this._state === null) {
  			this._deferreds.push(deferred);
  			return
  		}
  		asap(function() {
  			var cb = me._state ? deferred.onFulfilled : deferred.onRejected
  			if (cb === null) {
  				(me._state ? deferred.resolve : deferred.reject)(me._value);
  				return;
  			}
  			var ret;
  			try {
  				ret = cb(me._value);
  			}
  			catch (e) {
  				deferred.reject(e);
  				return;
  			}
  			deferred.resolve(ret);
  		})
  	}
  
  	function resolve(newValue) {
  		try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
  			if (newValue === this) throw new TypeError('A promise cannot be resolved with itself.');
  			if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
  				var then = newValue.then;
  				if (typeof then === 'function') {
  					doResolve(bind(then, newValue), bind(resolve, this), bind(reject, this));
  					return;
  				}
  			}
  			this._state = true;
  			this._value = newValue;
  			finale.call(this);
  		} catch (e) { reject.call(this, e); }
  	}
  
  	function reject(newValue) {
  		this._state = false;
  		this._value = newValue;
  		finale.call(this);
  	}
  
  	function finale() {
  		for (var i = 0, len = this._deferreds.length; i < len; i++) {
  			handle.call(this, this._deferreds[i]);
  		}
  		this._deferreds = null;
  	}
  
  	function Handler(onFulfilled, onRejected, resolve, reject){
  		this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
  		this.onRejected = typeof onRejected === 'function' ? onRejected : null;
  		this.resolve = resolve;
  		this.reject = reject;
  	}
  
  	/**
  	 * Take a potentially misbehaving resolver function and make sure
  	 * onFulfilled and onRejected are only called once.
  	 *
  	 * Makes no guarantees about asynchrony.
  	 */
  	function doResolve(fn, onFulfilled, onRejected) {
  		var done = false;
  		try {
  			fn(function (value) {
  				if (done) return;
  				done = true;
  				onFulfilled(value);
  			}, function (reason) {
  				if (done) return;
  				done = true;
  				onRejected(reason);
  			})
  		} catch (ex) {
  			if (done) return;
  			done = true;
  			onRejected(ex);
  		}
  	}
  
  	Promise.prototype['catch'] = function (onRejected) {
  		return this.then(null, onRejected);
  	};
  
  	Promise.prototype.then = function(onFulfilled, onRejected) {
  		var me = this;
  		return new Promise(function(resolve, reject) {
  			handle.call(me, new Handler(onFulfilled, onRejected, resolve, reject));
  		})
  	};
  
  	Promise.all = function () {
  		var args = Array.prototype.slice.call(arguments.length === 1 && isArray(arguments[0]) ? arguments[0] : arguments);
  
  		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);
  			}
  		});
  	};
  
  	if (typeof module !== 'undefined' && module.exports) {
  		module.exports = Promise;
  	} else if (!root.Promise) {
  		root.Promise = Promise;
  	}
  
  })(this);(function() {
    'use strict';
  
    if (self.fetch) {
      return
    }
  
    function Headers(headers) {
      this.map = {}
  
      var self = this
      if (headers instanceof Headers) {
        headers.forEach(function(name, values) {
          values.forEach(function(value) {
            self.append(name, value)
          })
        })
  
      } else if (headers) {
        Object.getOwnPropertyNames(headers).forEach(function(name) {
          self.append(name, headers[name])
        })
      }
    }
  
    Headers.prototype.append = function(name, value) {
      name = name.toLowerCase()
      var list = this.map[name]
      if (!list) {
        list = []
        this.map[name] = list
      }
      list.push(value)
    }
  
    Headers.prototype['delete'] = function(name) {
      delete this.map[name.toLowerCase()]
    }
  
    Headers.prototype.get = function(name) {
      var values = this.map[name.toLowerCase()]
      return values ? values[0] : null
    }
  
    Headers.prototype.getAll = function(name) {
      return this.map[name.toLowerCase()] || []
    }
  
    Headers.prototype.has = function(name) {
      return this.map.hasOwnProperty(name.toLowerCase())
    }
  
    Headers.prototype.set = function(name, value) {
      this.map[name.toLowerCase()] = [value]
    }
  
    // Instead of iterable for now.
    Headers.prototype.forEach = function(callback) {
      var self = this
      Object.getOwnPropertyNames(this.map).forEach(function(name) {
        callback(name, self.map[name])
      })
    }
  
    function consumed(body) {
      if (body.bodyUsed) {
        return Promise.reject(new TypeError('Already read'))
      }
      body.bodyUsed = true
    }
  
    function fileReaderReady(reader) {
      return new Promise(function(resolve, reject) {
        reader.onload = function() {
          resolve(reader.result)
        }
        reader.onerror = function() {
          reject(reader.error)
        }
      })
    }
  
    function readBlobAsArrayBuffer(blob) {
      var reader = new FileReader()
      reader.readAsArrayBuffer(blob)
      return fileReaderReady(reader)
    }
  
    function readBlobAsText(blob) {
      var reader = new FileReader()
      reader.readAsText(blob)
      return fileReaderReady(reader)
    }
  
    var support = {
      blob: 'FileReader' in self && 'Blob' in self && (function() {
        try {
          new Blob();
          return true
        } catch(e) {
          return false
        }
      })(),
      formData: 'FormData' in self
    }
  
    function Body() {
      this.bodyUsed = false
  
      if (support.blob) {
        this._initBody = function(body) {
          this._bodyInit = body
          if (typeof body === 'string') {
            this._bodyText = body
          } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
            this._bodyBlob = body
          } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
            this._bodyFormData = body
          } else if (!body) {
            this._bodyText = ''
          } else {
            throw new Error('unsupported BodyInit type')
          }
        }
  
        this.blob = function() {
          var rejected = consumed(this)
          if (rejected) {
            return rejected
          }
  
          if (this._bodyBlob) {
            return Promise.resolve(this._bodyBlob)
          } else if (this._bodyFormData) {
            throw new Error('could not read FormData body as blob')
          } else {
            return Promise.resolve(new Blob([this._bodyText]))
          }
        }
  
        this.arrayBuffer = function() {
          return this.blob().then(readBlobAsArrayBuffer)
        }
  
        this.text = function() {
          var rejected = consumed(this)
          if (rejected) {
            return rejected
          }
  
          if (this._bodyBlob) {
            return readBlobAsText(this._bodyBlob)
          } else if (this._bodyFormData) {
            throw new Error('could not read FormData body as text')
          } else {
            return Promise.resolve(this._bodyText)
          }
        }
      } else {
        this._initBody = function(body) {
          this._bodyInit = body
          if (typeof body === 'string') {
            this._bodyText = body
          } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
            this._bodyFormData = body
          } else if (!body) {
            this._bodyText = ''
          } else {
            throw new Error('unsupported BodyInit type')
          }
        }
  
        this.text = function() {
          var rejected = consumed(this)
          return rejected ? rejected : Promise.resolve(this._bodyText)
        }
      }
  
      if (support.formData) {
        this.formData = function() {
          return this.text().then(decode)
        }
      }
  
      this.json = function() {
        return this.text().then(JSON.parse)
      }
  
      return this
    }
  
    // HTTP methods whose capitalization should be normalized
    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
  
    function normalizeMethod(method) {
      var upcased = method.toUpperCase()
      return (methods.indexOf(upcased) > -1) ? upcased : method
    }
  
    function Request(url, options) {
      options = options || {}
      this.url = url
  
      this.credentials = options.credentials || 'omit'
      this.headers = new Headers(options.headers)
      this.method = normalizeMethod(options.method || 'GET')
      this.mode = options.mode || null
      this.referrer = null
  
      if ((this.method === 'GET' || this.method === 'HEAD') && options.body) {
        throw new TypeError('Body not allowed for GET or HEAD requests')
      }
      this._initBody(options.body)
    }
  
    function decode(body) {
      var form = new FormData()
      body.trim().split('&').forEach(function(bytes) {
        if (bytes) {
          var split = bytes.split('=')
          var name = split.shift().replace(/\+/g, ' ')
          var value = split.join('=').replace(/\+/g, ' ')
          form.append(decodeURIComponent(name), decodeURIComponent(value))
        }
      })
      return form
    }
  
    function headers(xhr) {
      var head = new Headers()
      var pairs = xhr.getAllResponseHeaders().trim().split('\n')
      pairs.forEach(function(header) {
        var split = header.trim().split(':')
        var key = split.shift().trim()
        var value = split.join(':').trim()
        head.append(key, value)
      })
      return head
    }
  
    Request.prototype.fetch = function() {
      var self = this
  
      return new Promise(function(resolve, reject) {
        var xhr = new XMLHttpRequest()
        if (self.credentials === 'cors') {
          xhr.withCredentials = true;
        }
  
        function responseURL() {
          if ('responseURL' in xhr) {
            return xhr.responseURL
          }
  
          // Avoid security warnings on getResponseHeader when not allowed by CORS
          if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
            return xhr.getResponseHeader('X-Request-URL')
          }
  
          return;
        }
  
        xhr.onload = function() {
          var status = (xhr.status === 1223) ? 204 : xhr.status
          if (status < 100 || status > 599) {
            reject(new TypeError('Network request failed'))
            return
          }
          var options = {
            status: status,
            statusText: xhr.statusText,
            headers: headers(xhr),
            url: responseURL()
          }
          var body = 'response' in xhr ? xhr.response : xhr.responseText;
          resolve(new Response(body, options))
        }
  
        xhr.onerror = function() {
          reject(new TypeError('Network request failed'))
        }
  
        xhr.open(self.method, self.url, true)
        if ('responseType' in xhr && support.blob) {
          xhr.responseType = 'blob'
        }
  
        self.headers.forEach(function(name, values) {
          values.forEach(function(value) {
            xhr.setRequestHeader(name, value)
          })
        })
  
        xhr.send(typeof self._bodyInit === 'undefined' ? null : self._bodyInit)
      })
    }
  
    Body.call(Request.prototype)
  
    function Response(bodyInit, options) {
      if (!options) {
        options = {}
      }
  
      this._initBody(bodyInit)
      this.type = 'default'
      this.url = null
      this.status = options.status
      this.statusText = options.statusText
      this.headers = options.headers
      this.url = options.url || ''
    }
  
    Body.call(Response.prototype)
  
    self.Headers = Headers;
    self.Request = Request;
    self.Response = Response;
  
    self.fetch = function (url, options) {
      return new Request(url, options).fetch()
    }
    self.fetch.polyfill = true
  })();
  /* foo.js */
  