(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :

  typeof define === 'function' && define.amd ? define(['exports'], factory) :

  (factory((global.WHATWGFetch = {})));

}(this, (function (exports) { 'use strict';

  var support = {

    searchParams: 'URLSearchParams' in self,

    iterable: 'Symbol' in self && 'iterator' in Symbol,

    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

  };

  function isDataView(obj) {

    return obj && DataView.prototype.isPrototypeOf(obj)

  }

  if (support.arrayBuffer) {

    var 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);

    }

    return value

  }

  // Build a destructive iterator for the value list

  function iteratorFor(items) {

    var iterator = {

      next: function() {

        var value = items.shift();

        return {done: value === undefined, value: value}

      }

    };

    if (support.iterable) {

      iterator[Symbol.iterator] = function() {

        return iterator

      };

    }

    return iterator

  }

  function Headers(headers) {

    this.map = {};

    if (headers instanceof Headers) {

      headers.forEach(function(value, name) {

        this.append(name, value);

      }, this);

    } else if (Array.isArray(headers)) {

      headers.forEach(function(header) {

        this.append(header[0], header[1]);

      }, this);

    } else if (headers) {

      Object.getOwnPropertyNames(headers).forEach(function(name) {

        this.append(name, headers[name]);

      }, this);

    }

  }

  Headers.prototype.append = function(name, value) {

    name = normalizeName(name);

    value = normalizeValue(value);

    var oldValue = this.map[name];

    this.map[name] = oldValue ? oldValue + ', ' + value : value;

  };

  Headers.prototype['delete'] = function(name) {

    delete this.map[normalizeName(name)];

  };

  Headers.prototype.get = function(name) {

    name = normalizeName(name);

    return this.has(name) ? this.map[name] : null

  };

  Headers.prototype.has = function(name) {

    return this.map.hasOwnProperty(normalizeName(name))

  };

  Headers.prototype.set = function(name, value) {

    this.map[normalizeName(name)] = normalizeValue(value);

  };

  Headers.prototype.forEach = function(callback, thisArg) {

    for (var name in this.map) {

      if (this.map.hasOwnProperty(name)) {

        callback.call(thisArg, this.map[name], name, this);

      }

    }

  };

  Headers.prototype.keys = function() {

    var items = [];

    this.forEach(function(value, name) {

      items.push(name);

    });

    return iteratorFor(items)

  };

  Headers.prototype.values = function() {

    var items = [];

    this.forEach(function(value) {

      items.push(value);

    });

    return iteratorFor(items)

  };

  Headers.prototype.entries = function() {

    var items = [];

    this.forEach(function(value, name) {

      items.push([name, value]);

    });

    return iteratorFor(items)

  };

  if (support.iterable) {

    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 {

        this._bodyText = body = Object.prototype.toString.call(body);

      }

      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;

      this.signal = input.signal;

      if (!body && input._bodyInit != null) {

        body = input._bodyInit;

        input.bodyUsed = true;

      }

    } else {

      this.url = String(input);

    }

    this.credentials = options.credentials || this.credentials || 'same-origin';

    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.signal = options.signal || this.signal;