happy-dom 12.10.2 → 13.0.0

package/cjs/fetch/Fetch.cjs

@@ -1,14 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _Fetch_browserFrame, _Fetch_window;
 Object.defineProperty(exports, "__esModule", { value: true });
-const Request_js_1 = __importDefault(require("./Request.cjs"));
+const PropertySymbol = __importStar(require("../PropertySymbol.cjs"));
 const Headers_js_1 = __importDefault(require("./Headers.cjs"));
 const FetchRequestReferrerUtility_js_1 = __importDefault(require("./utilities/FetchRequestReferrerUtility.cjs"));
 const DOMException_js_1 = __importDefault(require("../exception/DOMException.cjs"));
 const DOMExceptionNameEnum_js_1 = __importDefault(require("../exception/DOMExceptionNameEnum.cjs"));
-const Response_js_1 = __importDefault(require("./Response.cjs"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
 const zlib_1 = __importDefault(require("zlib"));
@@ -16,10 +50,14 @@ const URL_js_1 = __importDefault(require("../url/URL.cjs"));
 const stream_1 = __importDefault(require("stream"));
 const DataURIParser_js_1 = __importDefault(require("./data-uri/DataURIParser.cjs"));
 const FetchCORSUtility_js_1 = __importDefault(require("./utilities/FetchCORSUtility.cjs"));
-const SUPPORTED_SCHEMAS = ['data:', 'http:', 'https:'];
-const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
+const Response_js_1 = __importDefault(require("./Response.cjs"));
+const CachedResponseStateEnum_js_1 = __importDefault(require("./cache/response/CachedResponseStateEnum.cjs"));
+const FetchRequestHeaderUtility_js_1 = __importDefault(require("./utilities/FetchRequestHeaderUtility.cjs"));
+const FetchRequestValidationUtility_js_1 = __importDefault(require("./utilities/FetchRequestValidationUtility.cjs"));
+const FetchResponseRedirectUtility_js_1 = __importDefault(require("./utilities/FetchResponseRedirectUtility.cjs"));
+const FetchResponseHeaderUtility_js_1 = __importDefault(require("./utilities/FetchResponseHeaderUtility.cjs"));
+const FetchHTTPSCertificate_js_1 = __importDefault(require("./certificate/FetchHTTPSCertificate.cjs"));
 const LAST_CHUNK = Buffer.from('0\r\n\r\n');
-const MAX_REDIRECT_COUNT = 20;
 /**
  * Handles fetch requests.
  *
@@ -33,12 +71,14 @@ 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;
@@ -51,57 +91,252 @@ 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_js_1.default
-                ? new Request_js_1.default(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.disableCache = options.disableCache ?? false;
+        this.disableCrossOriginPolicy = options.disableCrossOriginPolicy ?? false;
+    }
+    /**
+     * Sends request.
+     *
+     * @returns Response.
+     */
+    async send() {
+        FetchRequestReferrerUtility_js_1.default.prepareRequest(__classPrivateFieldGet(this, _Fetch_window, "f").location, this.request);
+        FetchRequestValidationUtility_js_1.default.validateSchema(this.request);
+        if (this.request.signal.aborted) {
+            throw new DOMException_js_1.default('The operation was aborted.', DOMExceptionNameEnum_js_1.default.abortError);
+        }
+        if (this.request[PropertySymbol.url].protocol === 'data:') {
+            const result = DataURIParser_js_1.default.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_js_1.default(`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_js_1.default.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_js_1.default(`Cross-Origin Request Blocked: The Same Origin Policy dissallows reading the remote resource at "${this.request.url}".`, DOMExceptionNameEnum_js_1.default.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_js_1.default.stale) {
+            const headers = new Headers_js_1.default(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_js_1.default.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_js_1.default({
+                    '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;
         }
-        this.redirectCount = options.redirectCount || 0;
+        // TODO: Add support for more Access-Control-Allow-* headers.
+        return true;
     }
     /**
      * Sends request.
      *
      * @returns Response.
      */
-    send() {
+    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_js_1.default &&
+                    __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_js_1.default.parse(this.request.url);
-                this.response = new Response_js_1.default(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_1.default : http_1.default).request;
-            this.nodeRequest = send(this.request._url.href, {
+            const send = (this.request[PropertySymbol.url].protocol === 'https:' ? https_1.default : http_1.default).request;
+            this.nodeRequest = send(this.request[PropertySymbol.url].href, {
                 method: this.request.method,
-                headers: this.getRequestHeaders()
+                headers: FetchRequestHeaderUtility_js_1.default.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_js_1.default.key
+                    : undefined,
+                cert: this.request[PropertySymbol.url].protocol === 'https:'
+                    ? FetchHTTPSCertificate_js_1.default.cert
+                    : undefined
             });
             this.nodeRequest.on('error', this.onError.bind(this));
             this.nodeRequest.on('socket', this.onSocket.bind(this));
@@ -151,10 +386,12 @@ 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.
@@ -163,9 +400,22 @@ class Fetch {
      */
     onError(error) {
         this.finalizeRequest();
-        this.ownerDocument.defaultView.console.error(error);
+        __classPrivateFieldGet(this, _Fetch_window, "f").console.error(error);
         this.reject(new DOMException_js_1.default(`Fetch to "${this.request.url}" failed. Error: ${error.message}`, DOMExceptionNameEnum_js_1.default.networkError));
     }
+    /**
+     * Triggered when the async task manager aborts.
+     */
+    onAsyncTaskManagerAbort() {
+        const error = new DOMException_js_1.default('The operation was aborted.', DOMExceptionNameEnum_js_1.default.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.
      *
@@ -177,8 +427,12 @@ 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_js_1.default.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));
@@ -190,34 +444,34 @@ 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_js_1.default(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_1.default.constants.Z_SYNC_FLUSH,
-            finishFlush: zlib_1.default.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_1.default.constants.Z_SYNC_FLUSH,
+                finishFlush: zlib_1.default.constants.Z_SYNC_FLUSH
+            };
             body = stream_1.default.pipeline(body, zlib_1.default.createGunzip(zlibOptions), (error) => {
                 if (error) {
                     // Ignore error as it is forwarded to the response body.
                 }
             });
-            this.response = new Response_js_1.default(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);
@@ -248,7 +502,7 @@ class Fetch {
                         }
                     });
                 }
-                this.response = new Response_js_1.default(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);
@@ -256,7 +510,7 @@ 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_js_1.default(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);
@@ -271,14 +525,14 @@ class Fetch {
                     // Ignore error as it is forwarded to the response body.
                 }
             });
-            this.response = new Response_js_1.default(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_js_1.default(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);
@@ -291,7 +545,7 @@ class Fetch {
      * @returns True if redirect response was handled, false otherwise.
      */
     handleRedirectResponse(nodeResponse, responseHeaders) {
-        if (!this.isRedirect(nodeResponse.statusCode)) {
+        if (!FetchResponseRedirectUtility_js_1.default.isRedirect(nodeResponse.statusCode)) {
             return false;
         }
         switch (this.request.redirect) {
@@ -321,21 +575,12 @@ class Fetch {
                 if (locationURL === null) {
                     return false;
                 }
-                if (this.redirectCount >= MAX_REDIRECT_COUNT) {
+                if (FetchResponseRedirectUtility_js_1.default.isMaxRedirectsReached(this.redirectCount)) {
                     this.finalizeRequest();
                     this.reject(new DOMException_js_1.default(`Maximum redirects reached at: ${this.request.url}`, DOMExceptionNameEnum_js_1.default.networkError));
                     return true;
                 }
                 const headers = new Headers_js_1.default(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_js_1.default('It is not possible to pipe a body after it is used.', DOMExceptionNameEnum_js_1.default.networkError);
-                    }
-                    body = new stream_1.default.PassThrough();
-                    this.request.body.pipe(body);
-                }
                 const requestInit = {
                     method: this.request.method,
                     signal: this.request.signal,
@@ -343,22 +588,16 @@ 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_js_1.default.isCORS(this.ownerDocument.location, locationURL))) {
+                        FetchCORSUtility_js_1.default.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_js_1.default('Cannot follow redirect with body being a readable stream.', DOMExceptionNameEnum_js_1.default.networkError));
-                    return true;
-                }
                 if (this.request.signal.aborted) {
                     this.abort();
                     return true;
@@ -373,15 +612,21 @@ 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();
@@ -389,113 +634,6 @@ 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_js_1.default.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_js_1.default(`Failed to fetch from "${this.request.url}": URL scheme "${this.request._url.protocol.replace(/:$/, '')}" is not supported.`, DOMExceptionNameEnum_js_1.default.notSupportedError);
-        }
-    }
-    /**
-     * Returns request headers.
-     *
-     * @returns Headers.
-     */
-    getRequestHeaders() {
-        const headers = new Headers_js_1.default(this.request.headers);
-        const document = this.ownerDocument;
-        const isCORS = FetchCORSUtility_js_1.default.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_js_1.default) {
-            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_js_1.default();
-        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.
      */
@@ -505,9 +643,11 @@ class Fetch {
     }
     /**
      * Aborts the request.
+     *
+     * @param reason Reason.
      */
-    abort() {
-        const error = new DOMException_js_1.default('The operation was aborted.', DOMExceptionNameEnum_js_1.default.abortError);
+    abort(reason) {
+        const error = new DOMException_js_1.default('The operation was aborted.' + (reason ? ' ' + reason : ''), DOMExceptionNameEnum_js_1.default.abortError);
         if (this.request.body) {
             this.request.body.destroy(error);
         }
@@ -517,11 +657,12 @@ 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();
 exports.default = Fetch;
 //# sourceMappingURL=Fetch.cjs.map