// ==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
  }

  const Array = self.Array
  const ArrayBuffer = self.ArrayBuffer
  const Error = self.Error
  const Symbol_iterator = self.Symbol.iterator
  const Map = self.Map
  const RangeError = self.RangeError
  const TypeError = self.TypeError
  const Uint8Array = self.Uint8Array

  const Promise = self.Promise
  const Promise_reject = Promise.reject
  const Promise_resolve = Promise.resolve

  const ReadableStream = self.ReadableStream
  const ReadableStreamTee = self.ReadableStreamTee
  const IsReadableStreamDisturbed = self.IsReadableStreamDisturbed
  const IsReadableStreamLocked = self.IsReadableStreamLocked

  const err_InvalidHeadersInit = 'Constructing Headers with invalid parameters'
  const err_NetworkRequestFailed = 'Network request failed'

  const viewClasses = [
    '[object Int8Array]',
    '[object Uint8Array]',
    '[object Uint8ClampedArray]',
    '[object Int16Array]',
    '[object Uint16Array]',
    '[object Int32Array]',
    '[object Uint32Array]',
    '[object Float32Array]',
    '[object Float64Array]'
  ]

  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, len

    //value = value.replace(/^[ \t\n\r]+|[ \t\n\r]+$/g, '')
    for (first = 0, len = value.length; first < len; 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, len = value.length; i < len; 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
  }

  // https://fetch.spec.whatwg.org/#headers-class
  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 consumeBodyAsUint8Array(body) {
    if (body.bodyUsed) {
      return Promise_reject(new TypeError('Body already read'))
    }

    if (body.body === null) {
      return Promise_resolve(new Uint8Array(0))
    }

    if (IsReadableStreamLocked(body.body)) {
      return Promise_reject(new TypeError('ReadableStream already locked'))
    }

    var reader = body.body.getReader()
    var results = []
    var resultsLength = 0
    return reader.read().then(function addResult(result) {
      if (result.done) {
        var data
        if (results.length === 0) {
          data = new Uint8Array(0)
        } else if (results.length === 1) {
          data = new Uint8Array(results[0])
        } else {
          data = new Uint8Array(resultsLength)
          for (var i = 0, len = results.length, offset = 0; i < len; i++) {
            data.set(results[i], offset)
            offset += results[i].length
          }
        }
        return data
      } else if (result.value instanceof Uint8Array) {
        resultsLength += result.value.length
        results.push(result.value)
        return reader.read().then(addResult)
      } else {
        return Promise_reject(new TypeError('Invalid stream read value type'))
      }
    })
  }

  function encodeStringToUint8Array(str) {
    // Encode string to UTF-8 then store it in an Uint8Array.
    var utf8 = unescape(encodeURIComponent(str))
    var uint8 = new Uint8Array(utf8.length)
    for (var i = 0, len = utf8.length; i < len; i++) {
      uint8[i] = utf8.charCodeAt(i)
    }
    return uint8
  }

  function decodeStringFromUint8Array(uint8) {
    // Decode string from UTF-8 that is stored in the Uint8Array.
    return decodeURIComponent(escape(String.fromCharCode.apply(null, uint8)))
  }

  // https://fetch.spec.whatwg.org/#concept-bodyinit-extract
  function extractBody(controller, data, errorString) {
    if (!data) {
    } else if (typeof data === 'string') {
      controller.enqueue(encodeStringToUint8Array(data))
    } else if (ArrayBuffer.prototype.isPrototypeOf(data)) {
      controller.enqueue(new Uint8Array(data))
    } else if (isArrayBufferView(data)) {
      controller.enqueue(new Uint8Array(data.buffer))
    } else {
      throw new TypeError(errorString)
    }
  }

  // https://fetch.spec.whatwg.org/#body-mixin
  // However, our engine does not fully support URLSearchParams, FormData, nor
  //   Blob types. So only support text(), arrayBuffer(), and json().
  function Body() {
    this._initBody = function(body) {
      this._bodyUsed = false
      if (body === null || body === undefined) {
        this.body = null
      } else if (body instanceof ReadableStream) {
        this.body = body
      } else {
        this.body = new ReadableStream({
          start(controller) {
            extractBody(controller, body, 'Unsupported BodyInit type')
            controller.close()
          }
        })
      }

      if (!this.headers.get('content-type')) {
        if (typeof body === 'string') {
          this.headers.set('content-type', 'text/plain;charset=UTF-8')
        }
      }
    }

    Object.defineProperty(this, 'bodyUsed', {
      get: function() {
        if (this._bodyUsed) {
          return true
        } else if (this.body) {
          return !!IsReadableStreamDisturbed(this.body)
        } else {
          return false
        }
      }
    })

    this.arrayBuffer = function() {
      return consumeBodyAsUint8Array(this).then(function(data) {
        return data.buffer
      })
    }

    this.text = function() {
      return consumeBodyAsUint8Array(this).then(function(data) {
        if (data.length === 0) {
          return ''
        } else {
          return decodeStringFromUint8Array(data)
        }
      })
    }

    this.json = function() {
      return this.text().then(JSON.parse)
    }

    return this
  }

  // HTTP methods whose capitalization should be normalized
  const methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']

  function normalizeMethod(method) {
    var upcased = method.toUpperCase()
    return (methods.indexOf(upcased) > -1) ? upcased : method
  }

  // https://fetch.spec.whatwg.org/#request-class
  function Request(input, init) {
    init = init || {}
    var body = init.body

    if (input instanceof Request) {
      if (input.bodyUsed) {
        throw new TypeError('Request body already read')
      }
      this.url = input.url
      this.credentials = input.credentials
      if (!init.headers) {
        this.headers = new Headers(input.headers)
      }
      this.method = input.method
      this.mode = input.mode
      if (!body && input.body !== null) {
        // Take ownership of the stream and mark |input| as disturbed.
        body = input.body
        input._bodyUsed = true
      }
    } else {
      this.url = String(input)
    }

    this.credentials = init.credentials || this.credentials || 'omit'
    if (init.headers || !this.headers) {
      this.headers = new Headers(init.headers)
    }
    this.method = normalizeMethod(init.method || this.method || 'GET')
    this.mode = init.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() {
    var cloneBody = null
    if (this.body !== null) {
      var streams = ReadableStreamTee(this.body, true /* cloneForBranch2 */)
      this.body = streams[0]
      cloneBody = streams[1]
    }
    return new Request(this, { body: cloneBody })
  }

  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)

  // Status text must be a reason-phrase token.
  // https://tools.ietf.org/html/rfc7230#section-3.1.2
  function parseStatusText(text) {
    for (var i = 0, len = text.length, c; i < len; i++) {
      c = text.charCodeAt(i)
      if (c !== 9 && (c < 32 || c > 255 || c === 127)) {
        throw TypeError('Invalid status text')
      }
    }
    return text
  }

  // Body is not allowed in responses with a null body status.
  const nullBodyStatuses = [ 101, 204, 205, 304 ]

  // https://fetch.spec.whatwg.org/#response-class
  function Response(body, init) {
    if (!init) {
      init = {}
    }

    this.type = 'default'
    this.status = 'status' in init ? init.status : 200
    if (this.status < 200 || this.status > 599) {
      throw new RangeError('Invalid response status')
    }
    this.ok = this.status >= 200 && this.status < 300
    this.statusText = 'statusText' in init ? parseStatusText(init.statusText) : 'OK'
    this.headers = new Headers(init.headers)
    this.url = init.url || ''
    if (body && nullBodyStatuses.indexOf(this.status) > -1) {
      throw new TypeError('Body not allowed with a null body status')
    }
    this._initBody(body)
  }

  Body.call(Response.prototype)

  Response.prototype.clone = function() {
    var cloneBody = null
    if (this.body !== null) {
      var streams = ReadableStreamTee(this.body, true /* cloneForBranch2 */)
      this.body = streams[0]
      cloneBody = streams[1]
    }
    return new Response(cloneBody, {
      status: this.status,
      statusText: this.statusText,
      headers: new Headers(this.headers),
      url: this.url
    })
  }

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

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

  Response.redirect = function(url, status) {
    if (!FetchInternal.IsUrlValid(url)) {
      throw new TypeError('Invalid URL')
    }
    if (status === undefined) {
      status = 302
    }
    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 cancelled = false
      var request = new Request(input, init)
      var xhr = new XMLHttpRequest()

      var responseStreamController = null
      var responseStream = new ReadableStream({
        start(controller) {
          responseStreamController = controller
        },
        cancel(controller) {
          cancelled = true
          xhr.abort()
        }
      })

      xhr.onload = function() {
        responseStreamController.close()
      }

      xhr.onreadystatechange = function() {
        if (xhr.readyState === xhr.HEADERS_RECEIVED) {
          var init = {
            status: xhr.status,
            statusText: xhr.statusText,
            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
          }
          init.url = 'responseURL' in xhr ? xhr.responseURL : init.headers.get('X-Request-URL')
          resolve(new Response(responseStream, init))
        }
      }

      xhr.onerror = function() {
        responseStreamController.error(new TypeError(err_NetworkRequestFailed))
        reject(new TypeError(err_NetworkRequestFailed))
      }

      xhr.ontimeout = function() {
        responseStreamController.error(new TypeError(err_NetworkRequestFailed))
        reject(new TypeError(err_NetworkRequestFailed))
      }

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

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

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

      var fetchUpdate = function(data) {
        if (!cancelled) {
          // Data is already an Uint8Array.
          responseStreamController.enqueue(data)
        }
      }

      if (request.body === null) {
        xhr.fetch(fetchUpdate, null)
      } else {
        consumeBodyAsUint8Array(request).then(function(data) {
          xhr.fetch(fetchUpdate, data)
        })
      }
    })
  }
  self.fetch.polyfill = true
})(this);