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