happy-dom 12.10.2 → 13.0.0

package/lib/fetch/Fetch.js

@@ -1,9 +1,20 @@
-import Request from './Request.js';
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Fetch_browserFrame, _Fetch_window;
+import * as PropertySymbol from '../PropertySymbol.js';
 import Headers from './Headers.js';
 import FetchRequestReferrerUtility from './utilities/FetchRequestReferrerUtility.js';
 import DOMException from '../exception/DOMException.js';
 import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
-import Response from './Response.js';
 import HTTP from 'http';
 import HTTPS from 'https';
 import Zlib from 'zlib';
@@ -11,10 +22,14 @@ import URL from '../url/URL.js';
 import Stream from 'stream';
 import DataURIParser from './data-uri/DataURIParser.js';
 import FetchCORSUtility from './utilities/FetchCORSUtility.js';
-const SUPPORTED_SCHEMAS = ['data:', 'http:', 'https:'];
-const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
+import Response from './Response.js';
+import CachedResponseStateEnum from './cache/response/CachedResponseStateEnum.js';
+import FetchRequestHeaderUtility from './utilities/FetchRequestHeaderUtility.js';
+import FetchRequestValidationUtility from './utilities/FetchRequestValidationUtility.js';
+import FetchResponseRedirectUtility from './utilities/FetchResponseRedirectUtility.js';
+import FetchResponseHeaderUtility from './utilities/FetchResponseHeaderUtility.js';
+import FetchHTTPSCertificate from './certificate/FetchHTTPSCertificate.js';
 const LAST_CHUNK = Buffer.from('0\r\n\r\n');
-const MAX_REDIRECT_COUNT = 20;
 /**
  * Handles fetch requests.
  *
@@ -23,17 +38,19 @@ const MAX_REDIRECT_COUNT = 20;
  *
  * @see https://fetch.spec.whatwg.org/#http-network-fetch
  */
-export default class Fetch {
+class Fetch {
     /**
      * Constructor.
      *
      * @param options Options.
-     * @param options.document
+     * @param options.browserFrame Browser frame.
+     * @param options.window Window.
      * @param options.url URL.
      * @param [options.init] Init.
-     * @param [options.ownerDocument] Owner document.
      * @param [options.redirectCount] Redirect count.
      * @param [options.contentType] Content Type.
+     * @param [options.disableCache] Disables the use of cached responses. It will still store the response in the cache.
+     * @param [options.disableCrossOriginPolicy] Disables the Cross-Origin policy.
      */
     constructor(options) {
         this.reject = null;
@@ -46,57 +63,252 @@ export default class Fetch {
         this.previousChunk = null;
         this.nodeRequest = null;
         this.response = null;
+        this.responseHeaders = null;
         this.redirectCount = 0;
-        const url = options.url;
-        this.ownerDocument = options.ownerDocument;
+        _Fetch_browserFrame.set(this, void 0);
+        _Fetch_window.set(this, void 0);
+        __classPrivateFieldSet(this, _Fetch_browserFrame, options.browserFrame, "f");
+        __classPrivateFieldSet(this, _Fetch_window, options.window, "f");
         this.request =
             typeof options.url === 'string' || options.url instanceof URL
-                ? new Request(options.url, options.init)
-                : url;
+                ? new options.browserFrame.window.Request(options.url, options.init)
+                : options.url;
         if (options.contentType) {
-            this.request._contentType = options.contentType;
+            this.request[PropertySymbol.contentType] = options.contentType;
         }
-        this.redirectCount = options.redirectCount || 0;
+        this.redirectCount = options.redirectCount ?? 0;
+        this.disableCache = options.disableCache ?? false;
+        this.disableCrossOriginPolicy = options.disableCrossOriginPolicy ?? false;
     }
     /**
      * Sends request.
      *
      * @returns Response.
      */
-    send() {
+    async send() {
+        FetchRequestReferrerUtility.prepareRequest(__classPrivateFieldGet(this, _Fetch_window, "f").location, this.request);
+        FetchRequestValidationUtility.validateSchema(this.request);
+        if (this.request.signal.aborted) {
+            throw new DOMException('The operation was aborted.', DOMExceptionNameEnum.abortError);
+        }
+        if (this.request[PropertySymbol.url].protocol === 'data:') {
+            const result = DataURIParser.parse(this.request.url);
+            this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(result.buffer, {
+                headers: { 'Content-Type': result.type }
+            });
+            return this.response;
+        }
+        // Security check for "https" to "http" requests.
+        if (this.request[PropertySymbol.url].protocol === 'http:' &&
+            __classPrivateFieldGet(this, _Fetch_window, "f").location.protocol === 'https:') {
+            throw new DOMException(`Mixed Content: The page at '${__classPrivateFieldGet(this, _Fetch_window, "f").location.href}' was loaded over HTTPS, but requested an insecure XMLHttpRequest endpoint '${this.request.url}'. This request has been blocked; the content must be served over HTTPS.`, DOMExceptionNameEnum.securityError);
+        }
+        if (!this.disableCache) {
+            const cachedResponse = await this.getCachedResponse();
+            if (cachedResponse) {
+                return cachedResponse;
+            }
+        }
+        if (!this.disableCrossOriginPolicy) {
+            const compliesWithCrossOriginPolicy = await this.compliesWithCrossOriginPolicy();
+            if (!compliesWithCrossOriginPolicy) {
+                __classPrivateFieldGet(this, _Fetch_window, "f").console.warn(`Cross-Origin Request Blocked: The Same Origin Policy dissallows reading the remote resource at "${this.request.url}".`);
+                throw new DOMException(`Cross-Origin Request Blocked: The Same Origin Policy dissallows reading the remote resource at "${this.request.url}".`, DOMExceptionNameEnum.networkError);
+            }
+        }
+        return await this.sendRequest();
+    }
+    /**
+     * Returns cached response.
+     *
+     * @returns Response.
+     */
+    async getCachedResponse() {
+        if (this.disableCache) {
+            return null;
+        }
+        let cachedResponse = __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context.responseCache.get(this.request);
+        if (!cachedResponse || cachedResponse.response.waitingForBody) {
+            return null;
+        }
+        if (cachedResponse.state === CachedResponseStateEnum.stale) {
+            const headers = new Headers(cachedResponse.request.headers);
+            if (cachedResponse.etag) {
+                headers.set('If-None-Match', cachedResponse.etag);
+            }
+            else {
+                if (!cachedResponse.lastModified) {
+                    return null;
+                }
+                headers.set('If-Modified-Since', new Date(cachedResponse.lastModified).toUTCString());
+            }
+            const fetch = new Fetch({
+                browserFrame: __classPrivateFieldGet(this, _Fetch_browserFrame, "f"),
+                window: __classPrivateFieldGet(this, _Fetch_window, "f"),
+                url: this.request.url,
+                init: { headers, method: cachedResponse.request.method },
+                disableCache: true,
+                disableCrossOriginPolicy: true
+            });
+            if (cachedResponse.etag || !cachedResponse.staleWhileRevalidate) {
+                const validateResponse = await fetch.send();
+                const body = validateResponse.status !== 304 ? await validateResponse.buffer() : null;
+                cachedResponse = __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context.responseCache.add(this.request, {
+                    ...validateResponse,
+                    body,
+                    waitingForBody: false
+                });
+                if (validateResponse.status !== 304) {
+                    const response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, {
+                        status: validateResponse.status,
+                        statusText: validateResponse.statusText,
+                        headers: validateResponse.headers
+                    });
+                    response.url = validateResponse.url;
+                    response[PropertySymbol.cachedResponse] = cachedResponse;
+                    return response;
+                }
+            }
+            else {
+                fetch.send().then((response) => {
+                    response.buffer().then((body) => {
+                        __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context.responseCache.add(this.request, {
+                            ...response,
+                            body,
+                            waitingForBody: false
+                        });
+                    });
+                });
+            }
+        }
+        if (!cachedResponse || cachedResponse.response.waitingForBody) {
+            return null;
+        }
+        const response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(cachedResponse.response.body, {
+            status: cachedResponse.response.status,
+            statusText: cachedResponse.response.statusText,
+            headers: cachedResponse.response.headers
+        });
+        response.url = cachedResponse.response.url;
+        response[PropertySymbol.cachedResponse] = cachedResponse;
+        return response;
+    }
+    /**
+     * Checks if the request complies with the Cross-Origin policy.
+     *
+     * @returns True if it complies with the policy.
+     */
+    async compliesWithCrossOriginPolicy() {
+        if (this.disableCrossOriginPolicy ||
+            !FetchCORSUtility.isCORS(__classPrivateFieldGet(this, _Fetch_window, "f").location, this.request[PropertySymbol.url])) {
+            return true;
+        }
+        const cachedPreflightResponse = __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context.preflightResponseCache.get(this.request);
+        if (cachedPreflightResponse) {
+            if (cachedPreflightResponse.allowOrigin !== '*' &&
+                cachedPreflightResponse.allowOrigin !== __classPrivateFieldGet(this, _Fetch_window, "f").location.origin) {
+                return false;
+            }
+            if (cachedPreflightResponse.allowMethods.length !== 0 &&
+                !cachedPreflightResponse.allowMethods.includes(this.request.method)) {
+                return false;
+            }
+            return true;
+        }
+        const requestHeaders = [];
+        for (const [header] of this.request.headers) {
+            requestHeaders.push(header);
+        }
+        const fetch = new Fetch({
+            browserFrame: __classPrivateFieldGet(this, _Fetch_browserFrame, "f"),
+            window: __classPrivateFieldGet(this, _Fetch_window, "f"),
+            url: this.request.url,
+            init: {
+                method: 'OPTIONS',
+                headers: new Headers({
+                    'Access-Control-Request-Method': this.request.method,
+                    'Access-Control-Request-Headers': requestHeaders.join(', ')
+                })
+            },
+            disableCache: true,
+            disableCrossOriginPolicy: true
+        });
+        const response = await fetch.send();
+        if (!response.ok) {
+            return false;
+        }
+        const allowOrigin = response.headers.get('Access-Control-Allow-Origin');
+        if (!allowOrigin) {
+            return false;
+        }
+        if (allowOrigin !== '*' && allowOrigin !== __classPrivateFieldGet(this, _Fetch_window, "f").location.origin) {
+            return false;
+        }
+        const allowMethods = [];
+        if (response.headers.has('Access-Control-Allow-Methods')) {
+            const allowMethodsHeader = response.headers.get('Access-Control-Allow-Methods');
+            if (allowMethodsHeader !== '*') {
+                for (const method of allowMethodsHeader.split(',')) {
+                    allowMethods.push(method.trim().toUpperCase());
+                }
+            }
+        }
+        if (allowMethods.length !== 0 && !allowMethods.includes(this.request.method)) {
+            return false;
+        }
+        // TODO: Add support for more Access-Control-Allow-* headers.
+        return true;
+    }
+    /**
+     * Sends request.
+     *
+     * @returns Response.
+     */
+    sendRequest() {
         return new Promise((resolve, reject) => {
-            const taskManager = this.ownerDocument.defaultView.happyDOM.asyncTaskManager;
-            const taskID = taskManager.startTask(() => this.abort());
+            const taskID = __classPrivateFieldGet(this, _Fetch_browserFrame, "f")[PropertySymbol.asyncTaskManager].startTask(() => this.onAsyncTaskManagerAbort());
             if (this.resolve) {
                 throw new Error('Fetch already sent.');
             }
             this.resolve = (response) => {
-                taskManager.endTask(taskID);
+                // We can end up here when closing down the browser frame and there is an ongoing request.
+                // Therefore we need to check if browserFrame.page.context is still available.
+                if (!this.disableCache &&
+                    response instanceof Response &&
+                    __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page &&
+                    __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context) {
+                    response[PropertySymbol.cachedResponse] =
+                        __classPrivateFieldGet(this, _Fetch_browserFrame, "f").page.context.responseCache.add(this.request, {
+                            ...response,
+                            headers: this.responseHeaders,
+                            body: response[PropertySymbol.buffer],
+                            waitingForBody: !response[PropertySymbol.buffer] && !!response.body
+                        });
+                }
+                __classPrivateFieldGet(this, _Fetch_browserFrame, "f")[PropertySymbol.asyncTaskManager].endTask(taskID);
                 resolve(response);
             };
             this.reject = (error) => {
-                taskManager.endTask(taskID);
+                __classPrivateFieldGet(this, _Fetch_browserFrame, "f")[PropertySymbol.asyncTaskManager].endTask(taskID);
                 reject(error);
             };
-            this.prepareRequest();
-            this.validateRequest();
-            if (this.request._url.protocol === 'data:') {
-                const result = DataURIParser.parse(this.request.url);
-                this.response = new Response(result.buffer, {
-                    headers: { 'Content-Type': result.type }
-                });
-                resolve(this.response);
-                return;
-            }
-            if (this.request.signal.aborted) {
-                this.abort();
-                return;
-            }
             this.request.signal.addEventListener('abort', this.listeners.onSignalAbort);
-            const send = (this.request._url.protocol === 'https:' ? HTTPS : HTTP).request;
-            this.nodeRequest = send(this.request._url.href, {
+            const send = (this.request[PropertySymbol.url].protocol === 'https:' ? HTTPS : HTTP).request;
+            this.nodeRequest = send(this.request[PropertySymbol.url].href, {
                 method: this.request.method,
-                headers: this.getRequestHeaders()
+                headers: FetchRequestHeaderUtility.getRequestHeaders({
+                    browserFrame: __classPrivateFieldGet(this, _Fetch_browserFrame, "f"),
+                    window: __classPrivateFieldGet(this, _Fetch_window, "f"),
+                    request: this.request
+                }),
+                agent: false,
+                rejectUnauthorized: true,
+                key: this.request[PropertySymbol.url].protocol === 'https:'
+                    ? FetchHTTPSCertificate.key
+                    : undefined,
+                cert: this.request[PropertySymbol.url].protocol === 'https:'
+                    ? FetchHTTPSCertificate.cert
+                    : undefined
             });
             this.nodeRequest.on('error', this.onError.bind(this));
             this.nodeRequest.on('socket', this.onSocket.bind(this));
@@ -146,10 +358,12 @@ export default class Fetch {
     }
     /**
      * Event listener for signal "abort" event.
+     *
+     * @param event Event.
      */
-    onSignalAbort() {
+    onSignalAbort(event) {
         this.finalizeRequest();
-        this.abort();
+        this.abort(event.target?.reason);
     }
     /**
      * Event listener for request "error" event.
@@ -158,9 +372,22 @@ export default class Fetch {
      */
     onError(error) {
         this.finalizeRequest();
-        this.ownerDocument.defaultView.console.error(error);
+        __classPrivateFieldGet(this, _Fetch_window, "f").console.error(error);
         this.reject(new DOMException(`Fetch to "${this.request.url}" failed. Error: ${error.message}`, DOMExceptionNameEnum.networkError));
     }
+    /**
+     * Triggered when the async task manager aborts.
+     */
+    onAsyncTaskManagerAbort() {
+        const error = new DOMException('The operation was aborted.', DOMExceptionNameEnum.abortError);
+        if (this.request.body) {
+            this.request.body.destroy(error);
+        }
+        if (!this.response || !this.response.body) {
+            return;
+        }
+        this.response.body.destroy(error);
+    }
     /**
      * Event listener for request "response" event.
      *
@@ -172,8 +399,12 @@ export default class Fetch {
             nodeResponse.headers['transfer-encoding'] === 'chunked' &&
                 !nodeResponse.headers['content-length'];
         this.nodeRequest.setTimeout(0);
-        const headers = this.getResponseHeaders(nodeResponse);
-        if (this.handleRedirectResponse(nodeResponse, headers)) {
+        this.responseHeaders = FetchResponseHeaderUtility.parseResponseHeaders({
+            browserFrame: __classPrivateFieldGet(this, _Fetch_browserFrame, "f"),
+            requestURL: this.request[PropertySymbol.url],
+            rawHeaders: nodeResponse.rawHeaders
+        });
+        if (this.handleRedirectResponse(nodeResponse, this.responseHeaders)) {
             return;
         }
         nodeResponse.once('end', () => this.request.signal.removeEventListener('abort', this.listeners.onSignalAbort));
@@ -185,34 +416,34 @@ export default class Fetch {
         const responseOptions = {
             status: nodeResponse.statusCode,
             statusText: nodeResponse.statusMessage,
-            headers
+            headers: this.responseHeaders
         };
-        const contentEncodingHeader = headers.get('Content-Encoding');
+        const contentEncodingHeader = this.responseHeaders.get('Content-Encoding');
         if (this.request.method === 'HEAD' ||
             contentEncodingHeader === null ||
             nodeResponse.statusCode === 204 ||
             nodeResponse.statusCode === 304) {
-            this.response = new Response(body, responseOptions);
+            this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
             this.response.redirected = this.redirectCount > 0;
             this.response.url = this.request.url;
             this.resolve(this.response);
             return;
         }
-        // Be less strict when decoding compressed responses.
-        // Sometimes servers send slightly invalid responses that are still accepted by common browsers.
-        // "cURL" always uses Z_SYNC_FLUSH.
-        const zlibOptions = {
-            flush: Zlib.constants.Z_SYNC_FLUSH,
-            finishFlush: Zlib.constants.Z_SYNC_FLUSH
-        };
         // For GZip
         if (contentEncodingHeader === 'gzip' || contentEncodingHeader === 'x-gzip') {
+            // Be less strict when decoding compressed responses.
+            // Sometimes servers send slightly invalid responses that are still accepted by common browsers.
+            // "cURL" always uses Z_SYNC_FLUSH.
+            const zlibOptions = {
+                flush: Zlib.constants.Z_SYNC_FLUSH,
+                finishFlush: Zlib.constants.Z_SYNC_FLUSH
+            };
             body = Stream.pipeline(body, Zlib.createGunzip(zlibOptions), (error) => {
                 if (error) {
                     // Ignore error as it is forwarded to the response body.
                 }
             });
-            this.response = new Response(body, responseOptions);
+            this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
             this.response.redirected = this.redirectCount > 0;
             this.response.url = this.request.url;
             this.resolve(this.response);
@@ -243,7 +474,7 @@ export default class Fetch {
                         }
                     });
                 }
-                this.response = new Response(body, responseOptions);
+                this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
                 this.response.redirected = this.redirectCount > 0;
                 this.response.url = this.request.url;
                 this.resolve(this.response);
@@ -251,7 +482,7 @@ export default class Fetch {
             raw.on('end', () => {
                 // Some old IIS servers return zero-length OK deflate responses, so 'data' is never emitted.
                 if (!this.response) {
-                    this.response = new Response(body, responseOptions);
+                    this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
                     this.response.redirected = this.redirectCount > 0;
                     this.response.url = this.request.url;
                     this.resolve(this.response);
@@ -266,14 +497,14 @@ export default class Fetch {
                     // Ignore error as it is forwarded to the response body.
                 }
             });
-            this.response = new Response(body, responseOptions);
+            this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
             this.response.redirected = this.redirectCount > 0;
             this.response.url = this.request.url;
             this.resolve(this.response);
             return;
         }
         // Otherwise, use response as is
-        this.response = new Response(body, responseOptions);
+        this.response = new (__classPrivateFieldGet(this, _Fetch_window, "f").Response)(body, responseOptions);
         this.response.redirected = this.redirectCount > 0;
         this.response.url = this.request.url;
         this.resolve(this.response);
@@ -286,7 +517,7 @@ export default class Fetch {
      * @returns True if redirect response was handled, false otherwise.
      */
     handleRedirectResponse(nodeResponse, responseHeaders) {
-        if (!this.isRedirect(nodeResponse.statusCode)) {
+        if (!FetchResponseRedirectUtility.isRedirect(nodeResponse.statusCode)) {
             return false;
         }
         switch (this.request.redirect) {
@@ -316,21 +547,12 @@ export default class Fetch {
                 if (locationURL === null) {
                     return false;
                 }
-                if (this.redirectCount >= MAX_REDIRECT_COUNT) {
+                if (FetchResponseRedirectUtility.isMaxRedirectsReached(this.redirectCount)) {
                     this.finalizeRequest();
                     this.reject(new DOMException(`Maximum redirects reached at: ${this.request.url}`, DOMExceptionNameEnum.networkError));
                     return true;
                 }
                 const headers = new Headers(this.request.headers);
-                let body = this.request._bodyBuffer;
-                if (!body && this.request.body) {
-                    // Piping a used request body is not possible.
-                    if (this.request.bodyUsed) {
-                        throw new DOMException('It is not possible to pipe a body after it is used.', DOMExceptionNameEnum.networkError);
-                    }
-                    body = new Stream.PassThrough();
-                    this.request.body.pipe(body);
-                }
                 const requestInit = {
                     method: this.request.method,
                     signal: this.request.signal,
@@ -338,22 +560,16 @@ export default class Fetch {
                     referrerPolicy: this.request.referrerPolicy,
                     credentials: this.request.credentials,
                     headers,
-                    body
+                    body: this.request[PropertySymbol.bodyBuffer]
                 };
-                // TODO: Maybe we need to add support for OPTIONS request with 'Access-Control-Allow-*' headers?
                 if (this.request.credentials === 'omit' ||
                     (this.request.credentials === 'same-origin' &&
-                        FetchCORSUtility.isCORS(this.ownerDocument.location, locationURL))) {
+                        FetchCORSUtility.isCORS(__classPrivateFieldGet(this, _Fetch_window, "f").location, locationURL))) {
                     headers.delete('authorization');
                     headers.delete('www-authenticate');
                     headers.delete('cookie');
                     headers.delete('cookie2');
                 }
-                if (nodeResponse.statusCode !== 303 && this.request.body && !this.request._bodyBuffer) {
-                    this.finalizeRequest();
-                    this.reject(new DOMException('Cannot follow redirect with body being a readable stream.', DOMExceptionNameEnum.networkError));
-                    return true;
-                }
                 if (this.request.signal.aborted) {
                     this.abort();
                     return true;
@@ -368,15 +584,21 @@ export default class Fetch {
                 if (responseReferrerPolicy) {
                     requestInit.referrerPolicy = responseReferrerPolicy;
                 }
-                const fetch = new this.constructor({
-                    ownerDocument: this.ownerDocument,
+                const fetch = new Fetch({
+                    browserFrame: __classPrivateFieldGet(this, _Fetch_browserFrame, "f"),
+                    window: __classPrivateFieldGet(this, _Fetch_window, "f"),
                     url: locationURL,
                     init: requestInit,
                     redirectCount: this.redirectCount + 1,
-                    contentType: !shouldBecomeGetRequest ? this.request._contentType : undefined
+                    contentType: !shouldBecomeGetRequest
+                        ? this.request[PropertySymbol.contentType]
+                        : undefined
                 });
                 this.finalizeRequest();
-                this.resolve(fetch.send());
+                fetch
+                    .send()
+                    .then((response) => this.resolve(response))
+                    .catch((error) => this.reject(error));
                 return true;
             default:
                 this.finalizeRequest();
@@ -384,113 +606,6 @@ export default class Fetch {
                 return true;
         }
     }
-    /**
-     * Prepares the request before being sent.
-     */
-    prepareRequest() {
-        if (!this.request.referrerPolicy) {
-            this.request.referrerPolicy = 'strict-origin-when-cross-origin';
-        }
-        if (this.request.referrer && this.request.referrer !== 'no-referrer') {
-            this.request._referrer = FetchRequestReferrerUtility.getSentReferrer(this.ownerDocument, this.request);
-        }
-        else {
-            this.request._referrer = 'no-referrer';
-        }
-    }
-    /**
-     * Validates the request.
-     *
-     * @throws {Error} Throws an error if the request is invalid.
-     */
-    validateRequest() {
-        if (!SUPPORTED_SCHEMAS.includes(this.request._url.protocol)) {
-            throw new DOMException(`Failed to fetch from "${this.request.url}": URL scheme "${this.request._url.protocol.replace(/:$/, '')}" is not supported.`, DOMExceptionNameEnum.notSupportedError);
-        }
-    }
-    /**
-     * Returns request headers.
-     *
-     * @returns Headers.
-     */
-    getRequestHeaders() {
-        const headers = new Headers(this.request.headers);
-        const document = this.ownerDocument;
-        const isCORS = FetchCORSUtility.isCORS(document.location, this.request._url);
-        // TODO: Maybe we need to add support for OPTIONS request with 'Access-Control-Allow-*' headers?
-        if (this.request.credentials === 'omit' ||
-            (this.request.credentials === 'same-origin' && isCORS)) {
-            headers.delete('authorization');
-            headers.delete('www-authenticate');
-        }
-        headers.set('Accept-Encoding', 'gzip, deflate, br');
-        headers.set('Connection', 'close');
-        if (!headers.has('User-Agent')) {
-            headers.set('User-Agent', document.defaultView.navigator.userAgent);
-        }
-        if (this.request._referrer instanceof URL) {
-            headers.set('Referer', this.request._referrer.href);
-        }
-        if (this.request.credentials === 'include' ||
-            (this.request.credentials === 'same-origin' && !isCORS)) {
-            const cookie = document.defaultView.document._cookie.getCookieString(this.ownerDocument.defaultView.location, false);
-            if (cookie) {
-                headers.set('Cookie', cookie);
-            }
-        }
-        if (!headers.has('Accept')) {
-            headers.set('Accept', '*/*');
-        }
-        if (!headers.has('Content-Length') && this.request._contentLength !== null) {
-            headers.set('Content-Length', String(this.request._contentLength));
-        }
-        if (!headers.has('Content-Type') && this.request._contentType) {
-            headers.set('Content-Type', this.request._contentType);
-        }
-        // We need to convert the headers to Node request headers.
-        const httpRequestHeaders = {};
-        for (const header of Object.values(headers._entries)) {
-            httpRequestHeaders[header.name] = header.value;
-        }
-        return httpRequestHeaders;
-    }
-    /**
-     * Returns "true" if redirect.
-     *
-     * @param statusCode Status code.
-     * @returns "true" if redirect.
-     */
-    isRedirect(statusCode) {
-        return REDIRECT_STATUS_CODES.includes(statusCode);
-    }
-    /**
-     * Appends headers to response.
-     *
-     * @param nodeResponse HTTP request.
-     * @returns Headers.
-     */
-    getResponseHeaders(nodeResponse) {
-        const headers = new Headers();
-        let key = null;
-        for (const header of nodeResponse.rawHeaders) {
-            if (!key) {
-                key = header;
-            }
-            else {
-                const lowerKey = key.toLowerCase();
-                // Handles setting cookie headers to the document.
-                // "set-cookie" and "set-cookie2" are not allowed in response headers according to spec.
-                if (lowerKey === 'set-cookie' || lowerKey === 'set-cookie2') {
-                    this.ownerDocument['_cookie'].addCookieString(this.request._url, header);
-                }
-                else {
-                    headers.append(key, header);
-                }
-                key = null;
-            }
-        }
-        return headers;
-    }
     /**
      * Finalizes the request.
      */
@@ -500,9 +615,11 @@ export default class Fetch {
     }
     /**
      * Aborts the request.
+     *
+     * @param reason Reason.
      */
-    abort() {
-        const error = new DOMException('The operation was aborted.', DOMExceptionNameEnum.abortError);
+    abort(reason) {
+        const error = new DOMException('The operation was aborted.' + (reason ? ' ' + reason : ''), DOMExceptionNameEnum.abortError);
         if (this.request.body) {
             this.request.body.destroy(error);
         }
@@ -512,10 +629,12 @@ export default class Fetch {
             }
             return;
         }
-        this.response.body.emit('error', error);
+        this.response.body.destroy(error);
         if (this.reject) {
             this.reject(error);
         }
     }
 }
+_Fetch_browserFrame = new WeakMap(), _Fetch_window = new WeakMap();
+export default Fetch;
 //# sourceMappingURL=Fetch.js.map