[Summary view] [Print] [Text view]

   1  (function (global, factory) {
   2    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   3    typeof define === 'function' && define.amd ? define(['exports'], factory) :
   4    (factory((global.WHATWGFetch = {})));
   5  }(this, (function (exports) { 'use strict';
   6  
   7    var support = {
   8      searchParams: 'URLSearchParams' in self,
   9      iterable: 'Symbol' in self && 'iterator' in Symbol,
  10      blob:
  11        'FileReader' in self &&
  12        'Blob' in self &&
  13        (function() {
  14          try {
  15            new Blob();
  16            return true
  17          } catch (e) {
  18            return false
  19          }
  20        })(),
  21      formData: 'FormData' in self,
  22      arrayBuffer: 'ArrayBuffer' in self
  23    };
  24  
  25    function isDataView(obj) {
  26      return obj && DataView.prototype.isPrototypeOf(obj)
  27    }
  28  
  29    if (support.arrayBuffer) {
  30      var viewClasses = [
  31        '[object Int8Array]',
  32        '[object Uint8Array]',
  33        '[object Uint8ClampedArray]',
  34        '[object Int16Array]',
  35        '[object Uint16Array]',
  36        '[object Int32Array]',
  37        '[object Uint32Array]',
  38        '[object Float32Array]',
  39        '[object Float64Array]'
  40      ];
  41  
  42      var isArrayBufferView =
  43        ArrayBuffer.isView ||
  44        function(obj) {
  45          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
  46        };
  47    }
  48  
  49    function normalizeName(name) {
  50      if (typeof name !== 'string') {
  51        name = String(name);
  52      }
  53      if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
  54        throw new TypeError('Invalid character in header field name')
  55      }
  56      return name.toLowerCase()
  57    }
  58  
  59    function normalizeValue(value) {
  60      if (typeof value !== 'string') {
  61        value = String(value);
  62      }
  63      return value
  64    }
  65  
  66    // Build a destructive iterator for the value list
  67    function iteratorFor(items) {
  68      var iterator = {
  69        next: function() {
  70          var value = items.shift();
  71          return {done: value === undefined, value: value}
  72        }
  73      };
  74  
  75      if (support.iterable) {
  76        iterator[Symbol.iterator] = function() {
  77          return iterator
  78        };
  79      }
  80  
  81      return iterator
  82    }
  83  
  84    function Headers(headers) {
  85      this.map = {};
  86  
  87      if (headers instanceof Headers) {
  88        headers.forEach(function(value, name) {
  89          this.append(name, value);
  90        }, this);
  91      } else if (Array.isArray(headers)) {
  92        headers.forEach(function(header) {
  93          this.append(header[0], header[1]);
  94        }, this);
  95      } else if (headers) {
  96        Object.getOwnPropertyNames(headers).forEach(function(name) {
  97          this.append(name, headers[name]);
  98        }, this);
  99      }
 100    }
 101  
 102    Headers.prototype.append = function(name, value) {
 103      name = normalizeName(name);
 104      value = normalizeValue(value);
 105      var oldValue = this.map[name];
 106      this.map[name] = oldValue ? oldValue + ', ' + value : value;
 107    };
 108  
 109    Headers.prototype['delete'] = function(name) {
 110      delete this.map[normalizeName(name)];
 111    };
 112  
 113    Headers.prototype.get = function(name) {
 114      name = normalizeName(name);
 115      return this.has(name) ? this.map[name] : null
 116    };
 117  
 118    Headers.prototype.has = function(name) {
 119      return this.map.hasOwnProperty(normalizeName(name))
 120    };
 121  
 122    Headers.prototype.set = function(name, value) {
 123      this.map[normalizeName(name)] = normalizeValue(value);
 124    };
 125  
 126    Headers.prototype.forEach = function(callback, thisArg) {
 127      for (var name in this.map) {
 128        if (this.map.hasOwnProperty(name)) {
 129          callback.call(thisArg, this.map[name], name, this);
 130        }
 131      }
 132    };
 133  
 134    Headers.prototype.keys = function() {
 135      var items = [];
 136      this.forEach(function(value, name) {
 137        items.push(name);
 138      });
 139      return iteratorFor(items)
 140    };
 141  
 142    Headers.prototype.values = function() {
 143      var items = [];
 144      this.forEach(function(value) {
 145        items.push(value);
 146      });
 147      return iteratorFor(items)
 148    };
 149  
 150    Headers.prototype.entries = function() {
 151      var items = [];
 152      this.forEach(function(value, name) {
 153        items.push([name, value]);
 154      });
 155      return iteratorFor(items)
 156    };
 157  
 158    if (support.iterable) {
 159      Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
 160    }
 161  
 162    function consumed(body) {
 163      if (body.bodyUsed) {
 164        return Promise.reject(new TypeError('Already read'))
 165      }
 166      body.bodyUsed = true;
 167    }
 168  
 169    function fileReaderReady(reader) {
 170      return new Promise(function(resolve, reject) {
 171        reader.onload = function() {
 172          resolve(reader.result);
 173        };
 174        reader.onerror = function() {
 175          reject(reader.error);
 176        };
 177      })
 178    }
 179  
 180    function readBlobAsArrayBuffer(blob) {
 181      var reader = new FileReader();
 182      var promise = fileReaderReady(reader);
 183      reader.readAsArrayBuffer(blob);
 184      return promise
 185    }
 186  
 187    function readBlobAsText(blob) {
 188      var reader = new FileReader();
 189      var promise = fileReaderReady(reader);
 190      reader.readAsText(blob);
 191      return promise
 192    }
 193  
 194    function readArrayBufferAsText(buf) {
 195      var view = new Uint8Array(buf);
 196      var chars = new Array(view.length);
 197  
 198      for (var i = 0; i < view.length; i++) {
 199        chars[i] = String.fromCharCode(view[i]);
 200      }
 201      return chars.join('')
 202    }
 203  
 204    function bufferClone(buf) {
 205      if (buf.slice) {
 206        return buf.slice(0)
 207      } else {
 208        var view = new Uint8Array(buf.byteLength);
 209        view.set(new Uint8Array(buf));
 210        return view.buffer
 211      }
 212    }
 213  
 214    function Body() {
 215      this.bodyUsed = false;
 216  
 217      this._initBody = function(body) {
 218        this._bodyInit = body;
 219        if (!body) {
 220          this._bodyText = '';
 221        } else if (typeof body === 'string') {
 222          this._bodyText = body;
 223        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
 224          this._bodyBlob = body;
 225        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
 226          this._bodyFormData = body;
 227        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
 228          this._bodyText = body.toString();
 229        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
 230          this._bodyArrayBuffer = bufferClone(body.buffer);
 231          // IE 10-11 can't handle a DataView body.
 232          this._bodyInit = new Blob([this._bodyArrayBuffer]);
 233        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
 234          this._bodyArrayBuffer = bufferClone(body);
 235        } else {
 236          this._bodyText = body = Object.prototype.toString.call(body);
 237        }
 238  
 239        if (!this.headers.get('content-type')) {
 240          if (typeof body === 'string') {
 241            this.headers.set('content-type', 'text/plain;charset=UTF-8');
 242          } else if (this._bodyBlob && this._bodyBlob.type) {
 243            this.headers.set('content-type', this._bodyBlob.type);
 244          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
 245            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
 246          }
 247        }
 248      };
 249  
 250      if (support.blob) {
 251        this.blob = function() {
 252          var rejected = consumed(this);
 253          if (rejected) {
 254            return rejected
 255          }
 256  
 257          if (this._bodyBlob) {
 258            return Promise.resolve(this._bodyBlob)
 259          } else if (this._bodyArrayBuffer) {
 260            return Promise.resolve(new Blob([this._bodyArrayBuffer]))
 261          } else if (this._bodyFormData) {
 262            throw new Error('could not read FormData body as blob')
 263          } else {
 264            return Promise.resolve(new Blob([this._bodyText]))
 265          }
 266        };
 267  
 268        this.arrayBuffer = function() {
 269          if (this._bodyArrayBuffer) {
 270            return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
 271          } else {
 272            return this.blob().then(readBlobAsArrayBuffer)
 273          }
 274        };
 275      }
 276  
 277      this.text = function() {
 278        var rejected = consumed(this);
 279        if (rejected) {
 280          return rejected
 281        }
 282  
 283        if (this._bodyBlob) {
 284          return readBlobAsText(this._bodyBlob)
 285        } else if (this._bodyArrayBuffer) {
 286          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
 287        } else if (this._bodyFormData) {
 288          throw new Error('could not read FormData body as text')
 289        } else {
 290          return Promise.resolve(this._bodyText)
 291        }
 292      };
 293  
 294      if (support.formData) {
 295        this.formData = function() {
 296          return this.text().then(decode)
 297        };
 298      }
 299  
 300      this.json = function() {
 301        return this.text().then(JSON.parse)
 302      };
 303  
 304      return this
 305    }
 306  
 307    // HTTP methods whose capitalization should be normalized
 308    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
 309  
 310    function normalizeMethod(method) {
 311      var upcased = method.toUpperCase();
 312      return methods.indexOf(upcased) > -1 ? upcased : method
 313    }
 314  
 315    function Request(input, options) {
 316      options = options || {};
 317      var body = options.body;
 318  
 319      if (input instanceof Request) {
 320        if (input.bodyUsed) {
 321          throw new TypeError('Already read')
 322        }
 323        this.url = input.url;
 324        this.credentials = input.credentials;
 325        if (!options.headers) {
 326          this.headers = new Headers(input.headers);
 327        }
 328        this.method = input.method;
 329        this.mode = input.mode;
 330        this.signal = input.signal;
 331        if (!body && input._bodyInit != null) {
 332          body = input._bodyInit;
 333          input.bodyUsed = true;
 334        }
 335      } else {
 336        this.url = String(input);
 337      }
 338  
 339      this.credentials = options.credentials || this.credentials || 'same-origin';
 340      if (options.headers || !this.headers) {
 341        this.headers = new Headers(options.headers);
 342      }
 343      this.method = normalizeMethod(options.method || this.method || 'GET');
 344      this.mode = options.mode || this.mode || null;
 345      this.signal = options.signal || this.signal;
 346      this.referrer = null;
 347  
 348      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
 349        throw new TypeError('Body not allowed for GET or HEAD requests')
 350      }
 351      this._initBody(body);
 352    }
 353  
 354    Request.prototype.clone = function() {
 355      return new Request(this, {body: this._bodyInit})
 356    };
 357  
 358    function decode(body) {
 359      var form = new FormData();
 360      body
 361        .trim()
 362        .split('&')
 363        .forEach(function(bytes) {
 364          if (bytes) {
 365            var split = bytes.split('=');
 366            var name = split.shift().replace(/\+/g, ' ');
 367            var value = split.join('=').replace(/\+/g, ' ');
 368            form.append(decodeURIComponent(name), decodeURIComponent(value));
 369          }
 370        });
 371      return form
 372    }
 373  
 374    function parseHeaders(rawHeaders) {
 375      var headers = new Headers();
 376      // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
 377      // https://tools.ietf.org/html/rfc7230#section-3.2
 378      var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
 379      preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
 380        var parts = line.split(':');
 381        var key = parts.shift().trim();
 382        if (key) {
 383          var value = parts.join(':').trim();
 384          headers.append(key, value);
 385        }
 386      });
 387      return headers
 388    }
 389  
 390    Body.call(Request.prototype);
 391  
 392    function Response(bodyInit, options) {
 393      if (!options) {
 394        options = {};
 395      }
 396  
 397      this.type = 'default';
 398      this.status = options.status === undefined ? 200 : options.status;
 399      this.ok = this.status >= 200 && this.status < 300;
 400      this.statusText = 'statusText' in options ? options.statusText : 'OK';
 401      this.headers = new Headers(options.headers);
 402      this.url = options.url || '';
 403      this._initBody(bodyInit);
 404    }
 405  
 406    Body.call(Response.prototype);
 407  
 408    Response.prototype.clone = function() {
 409      return new Response(this._bodyInit, {
 410        status: this.status,
 411        statusText: this.statusText,
 412        headers: new Headers(this.headers),
 413        url: this.url
 414      })
 415    };
 416  
 417    Response.error = function() {
 418      var response = new Response(null, {status: 0, statusText: ''});
 419      response.type = 'error';
 420      return response
 421    };
 422  
 423    var redirectStatuses = [301, 302, 303, 307, 308];
 424  
 425    Response.redirect = function(url, status) {
 426      if (redirectStatuses.indexOf(status) === -1) {
 427        throw new RangeError('Invalid status code')
 428      }
 429  
 430      return new Response(null, {status: status, headers: {location: url}})
 431    };
 432  
 433    exports.DOMException = self.DOMException;
 434    try {
 435      new exports.DOMException();
 436    } catch (err) {
 437      exports.DOMException = function(message, name) {
 438        this.message = message;
 439        this.name = name;
 440        var error = Error(message);
 441        this.stack = error.stack;
 442      };
 443      exports.DOMException.prototype = Object.create(Error.prototype);
 444      exports.DOMException.prototype.constructor = exports.DOMException;
 445    }
 446  
 447    function fetch(input, init) {
 448      return new Promise(function(resolve, reject) {
 449        var request = new Request(input, init);
 450  
 451        if (request.signal && request.signal.aborted) {
 452          return reject(new exports.DOMException('Aborted', 'AbortError'))
 453        }
 454  
 455        var xhr = new XMLHttpRequest();
 456  
 457        function abortXhr() {
 458          xhr.abort();
 459        }
 460  
 461        xhr.onload = function() {
 462          var options = {
 463            status: xhr.status,
 464            statusText: xhr.statusText,
 465            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
 466          };
 467          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
 468          var body = 'response' in xhr ? xhr.response : xhr.responseText;
 469          resolve(new Response(body, options));
 470        };
 471  
 472        xhr.onerror = function() {
 473          reject(new TypeError('Network request failed'));
 474        };
 475  
 476        xhr.ontimeout = function() {
 477          reject(new TypeError('Network request failed'));
 478        };
 479  
 480        xhr.onabort = function() {
 481          reject(new exports.DOMException('Aborted', 'AbortError'));
 482        };
 483  
 484        xhr.open(request.method, request.url, true);
 485  
 486        if (request.credentials === 'include') {
 487          xhr.withCredentials = true;
 488        } else if (request.credentials === 'omit') {
 489          xhr.withCredentials = false;
 490        }
 491  
 492        if ('responseType' in xhr && support.blob) {
 493          xhr.responseType = 'blob';
 494        }
 495  
 496        request.headers.forEach(function(value, name) {
 497          xhr.setRequestHeader(name, value);
 498        });
 499  
 500        if (request.signal) {
 501          request.signal.addEventListener('abort', abortXhr);
 502  
 503          xhr.onreadystatechange = function() {
 504            // DONE (success or failure)
 505            if (xhr.readyState === 4) {
 506              request.signal.removeEventListener('abort', abortXhr);
 507            }
 508          };
 509        }
 510  
 511        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
 512      })
 513    }
 514  
 515    fetch.polyfill = true;
 516  
 517    if (!self.fetch) {
 518      self.fetch = fetch;
 519      self.Headers = Headers;
 520      self.Request = Request;
 521      self.Response = Response;
 522    }
 523  
 524    exports.Headers = Headers;
 525    exports.Request = Request;
 526    exports.Response = Response;
 527    exports.fetch = fetch;
 528  
 529    Object.defineProperty(exports, '__esModule', { value: true });
 530  
 531  })));