src/cobalt/fetch/fetch.js - cobalt - Git at Google

 // ==ClosureCompiler==
 // @output_file_name fetch.js
 // @compilation_level SIMPLE_OPTIMIZATIONS
 // @language_out ES5_STRICT
 // ==/ClosureCompiler==

 // Copyright (c) 2014-2016 GitHub, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
 // "Software"), to deal in the Software without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Software, and to
 // permit persons to whom the Software is furnished to do so, subject to
 // the following conditions:
 //
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // Contact GitHub API Training Shop Blog About

 // Fetch API: https://fetch.spec.whatwg.org/

 (function(self) {
   'use strict';

   if (self.fetch) {
     return
   }

   var Array = self.Array;
   var Error = self.Error;
   var Map = self.Map;
   var RangeError = self.RangeError;
   var TypeError = self.TypeError;

   var err_InvalidHeadersInit = 'Constructing Headers with invalid parameters'

   var support = {
     searchParams: 'URLSearchParams' in self,
     blob: 'FileReader' in self && 'Blob' in self && (function() {
       try {
         new Blob()
         return true
       } catch(e) {
         return false
       }
     })(),
     formData: 'FormData' in self,
     arrayBuffer: 'ArrayBuffer' in self
   }

   if (support.arrayBuffer) {
     var viewClasses = [
       '[object Int8Array]',
       '[object Uint8Array]',
       '[object Uint8ClampedArray]',
       '[object Int16Array]',
       '[object Uint16Array]',
       '[object Int32Array]',
       '[object Uint32Array]',
       '[object Float32Array]',
       '[object Float64Array]'
     ]

     var isDataView = function(obj) {
       return obj && DataView.prototype.isPrototypeOf(obj)
     }

     var isArrayBufferView = ArrayBuffer.isView || function(obj) {
       return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
     }
   }

   function normalizeName(name) {
     if (typeof name !== 'string') {
       name = String(name)
     }
     if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
       throw new TypeError('Invalid character in header field name')
     }
     return name.toLowerCase()
   }

   function normalizeValue(value) {
     if (typeof value !== 'string') {
       value = String(value)
     }

     // https://fetch.spec.whatwg.org/#concept-header-value
     // The web platform tests don't quite abide by the current spec. Use a
     // permissive approach that passes the tests while following the spirit
     // of the spec. Essentially, leading & trailing HTTP whitespace bytes
     // are trimmed first before checking validity.
     var c, first, last, i

     //value = value.replace(/^[ \t\n\r]+|[ \t\n\r]+$/g, '')
     for (first = 0; first < value.length; first++) {
       c = value.charCodeAt(first)
       if (c !== 9 && c !== 10 && c !== 13 && c !== 32) {
         break
       }
     }
     for (last = value.length - 1; last > first; last--) {
       c = value.charCodeAt(last)
       if (c !== 9 && c !== 10 && c !== 13 && c !== 32) {
         break
       }
     }
     value = value.substring(first, last + 1)

     // Follow the chromium implementation of IsValidHTTPHeaderValue(). This
     // should be updated once the web platform test abides by the fetch spec.
     for (i = 0; i < value.length; i++) {
       c = value.charCodeAt(i)
       if (c >= 256 || c === 0 || c === 10 || c === 13) {
         throw new TypeError('Invalid character in header field value')
       }
     }
     return value
   }

   function Headers(headers) {
     this.map = new Map();

     if (headers === undefined) {
       return
     } else if (headers === null || typeof headers !== 'object') {
       throw new TypeError(err_InvalidHeadersInit)
     } else if (headers instanceof Headers) {
       // Should use for..of in case |headers| has a custom Symbol.iterator.
       // However, this results in the ClosureCompiler polyfilling Symbol.
       headers.forEach(function(value, name) {
         this.append(name, value)
       }, this)
     } else if (Array.isArray(headers)) {
       headers.forEach(function(header) {
         if (header.length !== 2) {
           throw new TypeError(err_InvalidHeadersInit)
         }
         this.append(header[0], header[1])
       }, this)
     } else {
       Object.getOwnPropertyNames(headers).forEach(function(name) {
         this.append(name, headers[name])
       }, this)
     }
   }

   Headers.prototype.append = function(name, value) {
     if (arguments.length !== 2) {
       throw TypeError('Invalid parameters to append')
     }
     name = normalizeName(name)
     value = normalizeValue(value)
     if (this.map.has(name)) {
       this.map.set(name, this.map.get(name) + ', ' + value)
     } else {
       this.map.set(name, value)
     }
   }

   Headers.prototype['delete'] = function(name) {
     if (arguments.length !== 1) {
       throw TypeError('Invalid parameters to delete')
     }
     this.map.delete(normalizeName(name))
   }

   Headers.prototype.get = function(name) {
     if (arguments.length !== 1) {
       throw TypeError('Invalid parameters to get')
     }
     name = normalizeName(name)
     var value = this.map.get(name)
     return value !== undefined ? value : null
   }

   Headers.prototype.has = function(name) {
     if (arguments.length !== 1) {
       throw TypeError('Invalid parameters to has')
     }
     return this.map.has(normalizeName(name))
   }

   Headers.prototype.set = function(name, value) {
     if (arguments.length !== 2) {
       throw TypeError('Invalid parameters to set')
     }
     this.map.set(normalizeName(name), normalizeValue(value))
   }

   Headers.prototype.forEach = function(callback, thisArg) {
     var sorted_array = Array.from(this.map.entries()).sort()
     var that = this
     sorted_array.forEach(function(value) {
       callback.call(thisArg, value[1], value[0], that)
     })
   }

   Headers.prototype.keys = function() {
     var sorted_map = new Map(Array.from(this.map.entries()).sort())
     return sorted_map.keys()
   }

   Headers.prototype.values = function() {
     var sorted_map = new Map(Array.from(this.map.entries()).sort())
     return sorted_map.values()
   }

   Headers.prototype.entries = function() {
     var sorted_map = new Map(Array.from(this.map.entries()).sort())
     return sorted_map.entries()
   }

   Headers.prototype[Symbol.iterator] = Headers.prototype.entries

   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()
     var promise = fileReaderReady(reader)
     reader.readAsArrayBuffer(blob)
     return promise
   }

   function readBlobAsText(blob) {
     var reader = new FileReader()
     var promise = fileReaderReady(reader)
     reader.readAsText(blob)
     return promise
   }

   function readArrayBufferAsText(buf) {
     var view = new Uint8Array(buf)
     var chars = new Array(view.length)

     for (var i = 0; i < view.length; i++) {
       chars[i] = String.fromCharCode(view[i])
     }
     return chars.join('')
   }

   function bufferClone(buf) {
     if (buf.slice) {
       return buf.slice(0)
     } else {
       var view = new Uint8Array(buf.byteLength)
       view.set(new Uint8Array(buf))
       return view.buffer
     }
   }

   function Body() {
     this.bodyUsed = false

     this._initBody = function(body) {
       this._bodyInit = body
       if (!body) {
         this._bodyText = ''
       } else 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 (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
         this._bodyText = body.toString()
       } else if (support.arrayBuffer && support.blob && isDataView(body)) {
         this._bodyArrayBuffer = bufferClone(body.buffer)
         // IE 10-11 can't handle a DataView body.
         this._bodyInit = new Blob([this._bodyArrayBuffer])
       } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
         this._bodyArrayBuffer = bufferClone(body)
       } else {
         throw new Error('unsupported BodyInit type')
       }

       if (!this.headers.get('content-type')) {
         if (typeof body === 'string') {
           this.headers.set('content-type', 'text/plain;charset=UTF-8')
         } else if (this._bodyBlob && this._bodyBlob.type) {
           this.headers.set('content-type', this._bodyBlob.type)
         } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
           this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
         }
       }
     }

     if (support.blob) {
       this.blob = function() {
         var rejected = consumed(this)
         if (rejected) {
           return rejected
         }

         if (this._bodyBlob) {
           return Promise.resolve(this._bodyBlob)
         } else if (this._bodyArrayBuffer) {
           return Promise.resolve(new Blob([this._bodyArrayBuffer]))
         } 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() {
         if (this._bodyArrayBuffer) {
           return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
         } else {
           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._bodyArrayBuffer) {
         return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
       } else if (this._bodyFormData) {
         throw new Error('could not read FormData body as text')
       } else {
         return 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(input, options) {
     options = options || {}
     var body = options.body

     if (input instanceof Request) {
       if (input.bodyUsed) {
         throw new TypeError('Already read')
       }
       this.url = input.url
       this.credentials = input.credentials
       if (!options.headers) {
         this.headers = new Headers(input.headers)
       }
       this.method = input.method
       this.mode = input.mode
       if (!body && input._bodyInit != null) {
         body = input._bodyInit
         input.bodyUsed = true
       }
     } else {
       this.url = String(input)
     }

     this.credentials = options.credentials || this.credentials || 'omit'
     if (options.headers || !this.headers) {
       this.headers = new Headers(options.headers)
     }
     this.method = normalizeMethod(options.method || this.method || 'GET')
     this.mode = options.mode || this.mode || null
     this.referrer = null

     if ((this.method === 'GET' || this.method === 'HEAD') && body) {
       throw new TypeError('Body not allowed for GET or HEAD requests')
     }
     this._initBody(body)
   }

   Request.prototype.clone = function() {
     return new Request(this, { body: this._bodyInit })
   }

   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 parseHeaders(rawHeaders) {
     var headers = new Headers()
     // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
     // https://tools.ietf.org/html/rfc7230#section-3.2
     var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ')
     preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
       var parts = line.split(':')
       var key = parts.shift().trim()
       if (key) {
         var value = parts.join(':').trim()
         headers.append(key, value)
       }
     })
     return headers
   }

   Body.call(Request.prototype)

   function Response(bodyInit, options) {
     if (!options) {
       options = {}
     }

     this.type = 'default'
     this.status = 'status' in options ? options.status : 200
     this.ok = this.status >= 200 && this.status < 300
     this.statusText = 'statusText' in options ? options.statusText : 'OK'
     this.headers = new Headers(options.headers)
     this.url = options.url || ''
     this._initBody(bodyInit)
   }

   Body.call(Response.prototype)

   Response.prototype.clone = function() {
     return new Response(this._bodyInit, {
       status: this.status,
       statusText: this.statusText,
       headers: new Headers(this.headers),
       url: this.url
     })
   }

   Response.error = function() {
     var response = new Response(null, {status: 0, statusText: ''})
     response.type = 'error'
     return response
   }

   var redirectStatuses = [301, 302, 303, 307, 308]

   Response.redirect = function(url, status) {
     if (redirectStatuses.indexOf(status) === -1) {
       throw new RangeError('Invalid status code')
     }

     return new Response(null, {status: status, headers: {location: url}})
   }

   self.Headers = Headers
   self.Request = Request
   self.Response = Response

   self.fetch = function(input, init) {
     return new Promise(function(resolve, reject) {
       var request = new Request(input, init)
       var xhr = new XMLHttpRequest()

       xhr.onload = function() {
         var options = {
           status: xhr.status,
           statusText: xhr.statusText,
           headers: parseHeaders(xhr.getAllResponseHeaders() || '')
         }
         options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
         var body = 'response' in xhr ? xhr.response : xhr.responseText
         resolve(new Response(body, options))
       }

       xhr.onerror = function() {
         reject(new TypeError('Network request failed'))
       }

       xhr.ontimeout = function() {
         reject(new TypeError('Network request failed'))
       }

       xhr.open(request.method, request.url, true)

       if (request.credentials === 'include') {
         xhr.withCredentials = true
       }

       if ('responseType' in xhr && support.blob) {
         xhr.responseType = 'blob'
       }

       request.headers.forEach(function(value, name) {
         xhr.setRequestHeader(name, value)
       })

       xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
     })
   }
   self.fetch.polyfill = true
 })(this);
	// ==ClosureCompiler==
	// @output_file_name fetch.js
	// @compilation_level SIMPLE_OPTIMIZATIONS
	// @language_out ES5_STRICT
	// ==/ClosureCompiler==

	// Copyright (c) 2014-2016 GitHub, Inc.
	//
	// Permission is hereby granted, free of charge, to any person obtaining
	// a copy of this software and associated documentation files (the
	// "Software"), to deal in the Software without restriction, including
	// without limitation the rights to use, copy, modify, merge, publish,
	// distribute, sublicense, and/or sell copies of the Software, and to
	// permit persons to whom the Software is furnished to do so, subject to
	// the following conditions:
	//
	// The above copyright notice and this permission notice shall be
	// included in all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	// Contact GitHub API Training Shop Blog About

	// Fetch API: https://fetch.spec.whatwg.org/

	(function(self) {
	'use strict';

	if (self.fetch) {
	return
	}

	var Array = self.Array;
	var Error = self.Error;
	var Map = self.Map;
	var RangeError = self.RangeError;
	var TypeError = self.TypeError;

	var err_InvalidHeadersInit = 'Constructing Headers with invalid parameters'

	var support = {
	searchParams: 'URLSearchParams' in self,
	blob: 'FileReader' in self && 'Blob' in self && (function() {
	try {
	new Blob()
	return true
	} catch(e) {
	return false
	}
	})(),
	formData: 'FormData' in self,
	arrayBuffer: 'ArrayBuffer' in self
	}

	if (support.arrayBuffer) {
	var viewClasses = [
	'[object Int8Array]',
	'[object Uint8Array]',
	'[object Uint8ClampedArray]',
	'[object Int16Array]',
	'[object Uint16Array]',
	'[object Int32Array]',
	'[object Uint32Array]',
	'[object Float32Array]',
	'[object Float64Array]'
	]

	var isDataView = function(obj) {
	return obj && DataView.prototype.isPrototypeOf(obj)
	}

	var isArrayBufferView = ArrayBuffer.isView \|\| function(obj) {
	return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
	}
	}

	function normalizeName(name) {
	if (typeof name !== 'string') {
	name = String(name)
	}
	if (/[^a-z0-9\-#$%&'*+.\^_`\|~]/i.test(name)) {
	throw new TypeError('Invalid character in header field name')
	}
	return name.toLowerCase()
	}

	function normalizeValue(value) {
	if (typeof value !== 'string') {
	value = String(value)
	}

	// https://fetch.spec.whatwg.org/#concept-header-value
	// The web platform tests don't quite abide by the current spec. Use a
	// permissive approach that passes the tests while following the spirit
	// of the spec. Essentially, leading & trailing HTTP whitespace bytes
	// are trimmed first before checking validity.
	var c, first, last, i

	//value = value.replace(/^[ \t\n\r]+\|[ \t\n\r]+$/g, '')
	for (first = 0; first < value.length; first++) {
	c = value.charCodeAt(first)
	if (c !== 9 && c !== 10 && c !== 13 && c !== 32) {
	break
	}
	}
	for (last = value.length - 1; last > first; last--) {
	c = value.charCodeAt(last)
	if (c !== 9 && c !== 10 && c !== 13 && c !== 32) {
	break
	}
	}
	value = value.substring(first, last + 1)

	// Follow the chromium implementation of IsValidHTTPHeaderValue(). This
	// should be updated once the web platform test abides by the fetch spec.
	for (i = 0; i < value.length; i++) {
	c = value.charCodeAt(i)
	if (c >= 256 \|\| c === 0 \|\| c === 10 \|\| c === 13) {
	throw new TypeError('Invalid character in header field value')
	}
	}
	return value
	}

	function Headers(headers) {
	this.map = new Map();

	if (headers === undefined) {
	return
	} else if (headers === null \|\| typeof headers !== 'object') {
	throw new TypeError(err_InvalidHeadersInit)
	} else if (headers instanceof Headers) {
	// Should use for..of in case \|headers\| has a custom Symbol.iterator.
	// However, this results in the ClosureCompiler polyfilling Symbol.
	headers.forEach(function(value, name) {
	this.append(name, value)
	}, this)
	} else if (Array.isArray(headers)) {
	headers.forEach(function(header) {
	if (header.length !== 2) {
	throw new TypeError(err_InvalidHeadersInit)
	}
	this.append(header[0], header[1])
	}, this)
	} else {
	Object.getOwnPropertyNames(headers).forEach(function(name) {
	this.append(name, headers[name])
	}, this)
	}
	}

	Headers.prototype.append = function(name, value) {
	if (arguments.length !== 2) {
	throw TypeError('Invalid parameters to append')
	}
	name = normalizeName(name)
	value = normalizeValue(value)
	if (this.map.has(name)) {
	this.map.set(name, this.map.get(name) + ', ' + value)
	} else {
	this.map.set(name, value)
	}
	}

	Headers.prototype['delete'] = function(name) {
	if (arguments.length !== 1) {
	throw TypeError('Invalid parameters to delete')
	}
	this.map.delete(normalizeName(name))
	}

	Headers.prototype.get = function(name) {
	if (arguments.length !== 1) {
	throw TypeError('Invalid parameters to get')
	}
	name = normalizeName(name)
	var value = this.map.get(name)
	return value !== undefined ? value : null
	}

	Headers.prototype.has = function(name) {
	if (arguments.length !== 1) {
	throw TypeError('Invalid parameters to has')
	}
	return this.map.has(normalizeName(name))
	}

	Headers.prototype.set = function(name, value) {
	if (arguments.length !== 2) {
	throw TypeError('Invalid parameters to set')
	}
	this.map.set(normalizeName(name), normalizeValue(value))
	}

	Headers.prototype.forEach = function(callback, thisArg) {
	var sorted_array = Array.from(this.map.entries()).sort()
	var that = this
	sorted_array.forEach(function(value) {
	callback.call(thisArg, value[1], value[0], that)
	})
	}

	Headers.prototype.keys = function() {
	var sorted_map = new Map(Array.from(this.map.entries()).sort())
	return sorted_map.keys()
	}

	Headers.prototype.values = function() {
	var sorted_map = new Map(Array.from(this.map.entries()).sort())
	return sorted_map.values()
	}

	Headers.prototype.entries = function() {
	var sorted_map = new Map(Array.from(this.map.entries()).sort())
	return sorted_map.entries()
	}

	Headers.prototype[Symbol.iterator] = Headers.prototype.entries

	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()
	var promise = fileReaderReady(reader)
	reader.readAsArrayBuffer(blob)
	return promise
	}

	function readBlobAsText(blob) {
	var reader = new FileReader()
	var promise = fileReaderReady(reader)
	reader.readAsText(blob)
	return promise
	}

	function readArrayBufferAsText(buf) {
	var view = new Uint8Array(buf)
	var chars = new Array(view.length)

	for (var i = 0; i < view.length; i++) {
	chars[i] = String.fromCharCode(view[i])
	}
	return chars.join('')
	}

	function bufferClone(buf) {
	if (buf.slice) {
	return buf.slice(0)
	} else {
	var view = new Uint8Array(buf.byteLength)
	view.set(new Uint8Array(buf))
	return view.buffer
	}
	}

	function Body() {
	this.bodyUsed = false

	this._initBody = function(body) {
	this._bodyInit = body
	if (!body) {
	this._bodyText = ''
	} else 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 (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
	this._bodyText = body.toString()
	} else if (support.arrayBuffer && support.blob && isDataView(body)) {
	this._bodyArrayBuffer = bufferClone(body.buffer)
	// IE 10-11 can't handle a DataView body.
	this._bodyInit = new Blob([this._bodyArrayBuffer])
	} else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) \|\| isArrayBufferView(body))) {
	this._bodyArrayBuffer = bufferClone(body)
	} else {
	throw new Error('unsupported BodyInit type')
	}

	if (!this.headers.get('content-type')) {
	if (typeof body === 'string') {
	this.headers.set('content-type', 'text/plain;charset=UTF-8')
	} else if (this._bodyBlob && this._bodyBlob.type) {
	this.headers.set('content-type', this._bodyBlob.type)
	} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
	this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
	}
	}
	}

	if (support.blob) {
	this.blob = function() {
	var rejected = consumed(this)
	if (rejected) {
	return rejected
	}

	if (this._bodyBlob) {
	return Promise.resolve(this._bodyBlob)
	} else if (this._bodyArrayBuffer) {
	return Promise.resolve(new Blob([this._bodyArrayBuffer]))
	} 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() {
	if (this._bodyArrayBuffer) {
	return consumed(this) \|\| Promise.resolve(this._bodyArrayBuffer)
	} else {
	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._bodyArrayBuffer) {
	return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
	} else if (this._bodyFormData) {
	throw new Error('could not read FormData body as text')
	} else {
	return 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(input, options) {
	options = options \|\| {}
	var body = options.body

	if (input instanceof Request) {
	if (input.bodyUsed) {
	throw new TypeError('Already read')
	}
	this.url = input.url
	this.credentials = input.credentials
	if (!options.headers) {
	this.headers = new Headers(input.headers)
	}
	this.method = input.method
	this.mode = input.mode
	if (!body && input._bodyInit != null) {
	body = input._bodyInit
	input.bodyUsed = true
	}
	} else {
	this.url = String(input)
	}

	this.credentials = options.credentials \|\| this.credentials \|\| 'omit'
	if (options.headers \|\| !this.headers) {
	this.headers = new Headers(options.headers)
	}
	this.method = normalizeMethod(options.method \|\| this.method \|\| 'GET')
	this.mode = options.mode \|\| this.mode \|\| null
	this.referrer = null

	if ((this.method === 'GET' \|\| this.method === 'HEAD') && body) {
	throw new TypeError('Body not allowed for GET or HEAD requests')
	}
	this._initBody(body)
	}

	Request.prototype.clone = function() {
	return new Request(this, { body: this._bodyInit })
	}

	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 parseHeaders(rawHeaders) {
	var headers = new Headers()
	// Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
	// https://tools.ietf.org/html/rfc7230#section-3.2
	var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ')
	preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
	var parts = line.split(':')
	var key = parts.shift().trim()
	if (key) {
	var value = parts.join(':').trim()
	headers.append(key, value)
	}
	})
	return headers
	}

	Body.call(Request.prototype)

	function Response(bodyInit, options) {
	if (!options) {
	options = {}
	}

	this.type = 'default'
	this.status = 'status' in options ? options.status : 200
	this.ok = this.status >= 200 && this.status < 300
	this.statusText = 'statusText' in options ? options.statusText : 'OK'
	this.headers = new Headers(options.headers)
	this.url = options.url \|\| ''
	this._initBody(bodyInit)
	}

	Body.call(Response.prototype)

	Response.prototype.clone = function() {
	return new Response(this._bodyInit, {
	status: this.status,
	statusText: this.statusText,
	headers: new Headers(this.headers),
	url: this.url
	})
	}

	Response.error = function() {
	var response = new Response(null, {status: 0, statusText: ''})
	response.type = 'error'
	return response
	}

	var redirectStatuses = [301, 302, 303, 307, 308]

	Response.redirect = function(url, status) {
	if (redirectStatuses.indexOf(status) === -1) {
	throw new RangeError('Invalid status code')
	}

	return new Response(null, {status: status, headers: {location: url}})
	}

	self.Headers = Headers
	self.Request = Request
	self.Response = Response

	self.fetch = function(input, init) {
	return new Promise(function(resolve, reject) {
	var request = new Request(input, init)
	var xhr = new XMLHttpRequest()

	xhr.onload = function() {
	var options = {
	status: xhr.status,
	statusText: xhr.statusText,
	headers: parseHeaders(xhr.getAllResponseHeaders() \|\| '')
	}
	options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
	var body = 'response' in xhr ? xhr.response : xhr.responseText
	resolve(new Response(body, options))
	}

	xhr.onerror = function() {
	reject(new TypeError('Network request failed'))
	}

	xhr.ontimeout = function() {
	reject(new TypeError('Network request failed'))
	}

	xhr.open(request.method, request.url, true)

	if (request.credentials === 'include') {
	xhr.withCredentials = true
	}

	if ('responseType' in xhr && support.blob) {
	xhr.responseType = 'blob'
	}

	request.headers.forEach(function(value, name) {
	xhr.setRequestHeader(name, value)
	})

	xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
	})
	}
	self.fetch.polyfill = true
	})(this);