enmi-conf.org: comparison wp/wp-includes/js/dist/vendor/wp-polyfill-fetch.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/dist/vendor/wp-polyfill-fetch.js

changeset 21	48c4eec2b7e6
parent 19	3d72ae0968f4
child 22	8c2e4d02f4ef

equal deleted inserted replaced

-:7b1b88e27a20
+:48c4eec2b7e6
 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 global =
+/* eslint-disable no-prototype-builtins */
+var g =
 (typeof globalThis !== 'undefined' && globalThis) ||
 (typeof self !== 'undefined' && self) ||
-(typeof global !== 'undefined' && global);
+// eslint-disable-next-line no-undef
+(typeof global !== 'undefined' && global) ||
+{};
 var support = {
-searchParams: 'URLSearchParams' in global,
+searchParams: 'URLSearchParams' in g,
-iterable: 'Symbol' in global && 'iterator' in Symbol,
+iterable: 'Symbol' in g && 'iterator' in Symbol,
 blob:
-'FileReader' in global &&
+'FileReader' in g &&
-'Blob' in global &&
+'Blob' in g &&
 (function() {
 try {
 new Blob();
 return true
 } catch (e) {
 return false
 }
 })(),
-formData: 'FormData' in global,
+formData: 'FormData' in g,
-arrayBuffer: 'ArrayBuffer' in global
+arrayBuffer: 'ArrayBuffer' in g
 };
 function isDataView(obj) {
 return obj && DataView.prototype.isPrototypeOf(obj)
 }
 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('Headers constructor: expected name/value pair to be length 2, found' + header.length)
+}
 this.append(header[0], header[1]);
 }, this);
 } else if (headers) {
 Object.getOwnPropertyNames(headers).forEach(function(name) {
 this.append(name, headers[name]);
 if (support.iterable) {
 Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
 }
 function consumed(body) {
+if (body._noBody) return
 if (body.bodyUsed) {
 return Promise.reject(new TypeError('Already read'))
 }
 body.bodyUsed = true;
 }
 }
 function readBlobAsText(blob) {
 var reader = new FileReader();
 var promise = fileReaderReady(reader);
-reader.readAsText(blob);
+var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+var encoding = match ? match[1] : 'utf-8';
+reader.readAsText(blob, encoding);
 return promise
 }
 function readArrayBufferAsText(buf) {
 var view = new Uint8Array(buf);
 on the object before the Proxy is created. This change ensures
 Response.bodyUsed exists on the instance, while maintaining the
 semantic of setting Request.bodyUsed in the constructor before
 _initBody is called.
 */
+// eslint-disable-next-line no-self-assign
 this.bodyUsed = this.bodyUsed;
 this._bodyInit = body;
 if (!body) {
+this._noBody = true;
 this._bodyText = '';
 } else if (typeof body === 'string') {
 this._bodyText = body;
 } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
 this._bodyBlob = body;
 throw new Error('could not read FormData body as blob')
 } else {
 return Promise.resolve(new Blob([this._bodyText]))
 }
 };
+}
-this.arrayBuffer = function() {
-if (this._bodyArrayBuffer) {
+this.arrayBuffer = function() {
-var isConsumed = consumed(this);
+if (this._bodyArrayBuffer) {
-if (isConsumed) {
+var isConsumed = consumed(this);
-return isConsumed
+if (isConsumed) {
-}
+return isConsumed
-if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+} else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
 return Promise.resolve(
 this._bodyArrayBuffer.buffer.slice(
 this._bodyArrayBuffer.byteOffset,
 this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
-)
 )
-} else {
+)
-return Promise.resolve(this._bodyArrayBuffer)
-}
 } else {
-return this.blob().then(readBlobAsArrayBuffer)
+return Promise.resolve(this._bodyArrayBuffer)
 }
-};
+} else if (support.blob) {
-}
+return this.blob().then(readBlobAsArrayBuffer)
+} else {
+throw new Error('could not read as ArrayBuffer')
+}
+};
 this.text = function() {
 var rejected = consumed(this);
 if (rejected) {
 return rejected
 return this
 }
 // HTTP methods whose capitalization should be normalized
-var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+var methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'];
 function normalizeMethod(method) {
 var upcased = method.toUpperCase();
 return methods.indexOf(upcased) > -1 ? upcased : method
 }
 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;
+this.signal = options.signal || this.signal || (function () {
+if ('AbortController' in g) {
+var ctrl = new AbortController();
+return ctrl.signal;
+}
+}());
 this.referrer = null;
 if ((this.method === 'GET' || this.method === 'HEAD') && body) {
 throw new TypeError('Body not allowed for GET or HEAD requests')
 }
 .forEach(function(line) {
 var parts = line.split(':');
 var key = parts.shift().trim();
 if (key) {
 var value = parts.join(':').trim();
-headers.append(key, value);
+try {
+headers.append(key, value);
+} catch (error) {
+console.warn('Response ' + error.message);
+}
 }
 });
 return headers
 }
 options = {};
 }
 this.type = 'default';
 this.status = options.status === undefined ? 200 : options.status;
+if (this.status < 200 || this.status > 599) {
+throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].")
+}
 this.ok = this.status >= 200 && this.status < 300;
 this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
 this.headers = new Headers(options.headers);
 this.url = options.url || '';
 this._initBody(bodyInit);
 url: this.url
 })
 };
 Response.error = function() {
-var response = new Response(null, {status: 0, statusText: ''});
+var response = new Response(null, {status: 200, statusText: ''});
+response.status = 0;
 response.type = 'error';
 return response
 };
 var redirectStatuses = [301, 302, 303, 307, 308];
 }
 return new Response(null, {status: status, headers: {location: url}})
 };
-exports.DOMException = global.DOMException;
+exports.DOMException = g.DOMException;
 try {
 new exports.DOMException();
 } catch (err) {
 exports.DOMException = function(message, name) {
 this.message = message;
 }, 0);
 };
 function fixUrl(url) {
 try {
-return url === '' && global.location.href ? global.location.href : url
+return url === '' && g.location.href ? g.location.href : url
 } catch (e) {
 return url
 }
 }
 if ('responseType' in xhr) {
 if (support.blob) {
 xhr.responseType = 'blob';
 } else if (
-support.arrayBuffer &&
+support.arrayBuffer
-request.headers.get('Content-Type') &&
-request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
 ) {
 xhr.responseType = 'arraybuffer';
 }
 }
-if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || (g.Headers && init.headers instanceof g.Headers))) {
+var names = [];
 Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+names.push(normalizeName(name));
 xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+});
+request.headers.forEach(function(value, name) {
+if (names.indexOf(name) === -1) {
+xhr.setRequestHeader(name, value);
+}
 });
 } else {
 request.headers.forEach(function(value, name) {
 xhr.setRequestHeader(name, value);
 });
 })
 }
 fetch.polyfill = true;
-if (!global.fetch) {
+if (!g.fetch) {
-global.fetch = fetch;
+g.fetch = fetch;
-global.Headers = Headers;
+g.Headers = Headers;
-global.Request = Request;
+g.Request = Request;
-global.Response = Response;
+g.Response = Response;
 }
 exports.Headers = Headers;
 exports.Request = Request;
 exports.Response = Response;

enmi-conf.org