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