happy-dom 18.0.1 → 19.0.0

package/src/css/style-property-map/StylePropertyMapReadOnly.ts

@@ -0,0 +1,128 @@
+import CSSStyleDeclaration from '../declaration/CSSStyleDeclaration.js';
+import CSSKeywordValue from './CSSKeywordValue.js';
+import CSSStyleValue from './CSSStyleValue.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * StylePropertyMapReadOnly interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly
+ */
+export default class StylePropertyMapReadOnly {
+	public [PropertySymbol.style]: CSSStyleDeclaration;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol Illegal constructor symbol.
+	 * @param style Style.
+	 */
+	constructor(illegalConstructorSymbol: Symbol, style: CSSStyleDeclaration) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		this[PropertySymbol.style] = style;
+	}
+
+	/**
+	 * Returns size.
+	 *
+	 * @returns Size.
+	 */
+	public get size(): number {
+		return this[PropertySymbol.style].length;
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public [Symbol.iterator](): IterableIterator<[string, CSSKeywordValue[]]> {
+		return this.entries();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all key/value pairs contained in this object.
+	 *
+	 * @returns Entries.
+	 */
+	public entries(): IterableIterator<[string, CSSKeywordValue[]]> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			const property = (<any>this[PropertySymbol.style])[i];
+			array[i] = [
+				property,
+				[new CSSKeywordValue(this[PropertySymbol.style].getPropertyValue(property))]
+			];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Values.
+	 */
+	public values(): IterableIterator<CSSKeywordValue[]> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			const property = (<any>this[PropertySymbol.style])[i];
+			array[i] = [new CSSKeywordValue(this[PropertySymbol.style].getPropertyValue(property))];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all keys of the key/value pairs contained in this object.
+	 *
+	 * @returns Keys.
+	 */
+	public keys(): IterableIterator<string> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			array[i] = (<any>this[PropertySymbol.style])[i];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns a property value.
+	 *
+	 * @param property Property.
+	 * @returns Value.
+	 */
+	public get(property: string): CSSStyleValue {
+		return new CSSStyleValue(
+			PropertySymbol.illegalConstructor,
+			this[PropertySymbol.style],
+			property
+		);
+	}
+
+	/**
+	 * Returns array of property values.
+	 *
+	 * @param property Property.
+	 * @returns Values.
+	 */
+	public getAll(property: string): CSSStyleValue[] {
+		return [
+			new CSSStyleValue(PropertySymbol.illegalConstructor, this[PropertySymbol.style], property)
+		];
+	}
+
+	/**
+	 * Checks if a property is present.
+	 *
+	 * @param property Property.
+	 * @returns True if the property is present.
+	 */
+	public has(property: string): boolean {
+		return !!this[PropertySymbol.style].getPropertyValue(property);
+	}
+}

package/src/css/utilities/CSSParser.ts

@@ -10,6 +10,7 @@ import CSSSupportsRule from '../rules/CSSSupportsRule.js';
 import CSSFontFaceRule from '../rules/CSSFontFaceRule.js';
 import SelectorParser from '../../query-selector/SelectorParser.js';
 import CSSRuleTypeEnum from '../CSSRuleTypeEnum.js';
+import CSSScopeRule from '../rules/CSSScopeRule.js';
 
 const COMMENT_REGEXP = /\/\*[\s\S]*?\*\//gm;
 
@@ -17,14 +18,24 @@ const COMMENT_REGEXP = /\/\*[\s\S]*?\*\//gm;
  * CSS parser.
  */
 export default class CSSParser {
+	#parentStyleSheet: CSSStyleSheet;
+
 	/**
-	 * Parses HTML and returns a root element.
+	 * Constructor.
 	 *
 	 * @param parentStyleSheet Parent style sheet.
+	 */
+	constructor(parentStyleSheet: CSSStyleSheet) {
+		this.#parentStyleSheet = parentStyleSheet;
+	}
+	/**
+	 * Parses HTML and returns a root element.
+	 *
 	 * @param cssText CSS code.
-	 * @returns Root element.
+	 * @returns CSS rules.
 	 */
-	public static parseFromString(parentStyleSheet: CSSStyleSheet, cssText: string): CSSRule[] {
+	public parseFromString(cssText: string): CSSRule[] {
+		const parentStyleSheet = this.#parentStyleSheet;
 		const window = parentStyleSheet[PropertySymbol.window];
 		const css = cssText.replace(COMMENT_REGEXP, '');
 		const cssRules = [];
@@ -46,10 +57,16 @@ export default class CSSParser {
 					switch (ruleType) {
 						case '@keyframes':
 						case '@-webkit-keyframes':
-							const keyframesRule = new CSSKeyframesRule(PropertySymbol.illegalConstructor, window);
+							const keyframesRule = new CSSKeyframesRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
 
-							(<string>keyframesRule.name) = ruleParameters;
-							keyframesRule.parentStyleSheet = parentStyleSheet;
+							keyframesRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-keyframes' ? '-webkit-' : '';
+							keyframesRule[PropertySymbol.name] = ruleParameters;
+							keyframesRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 							if (parentRule) {
 								if (
 									parentRule.type === CSSRuleTypeEnum.mediaRule ||
@@ -65,13 +82,13 @@ export default class CSSParser {
 							break;
 						case '@media':
 							const mediums = ruleParameters.split(',');
-							const mediaRule = new CSSMediaRule(PropertySymbol.illegalConstructor, window);
+							const mediaRule = new CSSMediaRule(PropertySymbol.illegalConstructor, window, this);
 
 							for (const medium of mediums) {
 								mediaRule.media.appendMedium(medium.trim());
 							}
 
-							mediaRule.parentStyleSheet = parentStyleSheet;
+							mediaRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 							if (parentRule) {
 								if (
 									parentRule.type === CSSRuleTypeEnum.mediaRule ||
@@ -87,10 +104,15 @@ export default class CSSParser {
 							break;
 						case '@container':
 						case '@-webkit-container':
-							const containerRule = new CSSContainerRule(PropertySymbol.illegalConstructor, window);
-
-							(<string>containerRule.conditionText) = ruleParameters;
-							containerRule.parentStyleSheet = parentStyleSheet;
+							const containerRule = new CSSContainerRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
+							containerRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-container' ? '-webkit-' : '';
+							containerRule[PropertySymbol.conditionText] = ruleParameters;
+							containerRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 
 							if (parentRule) {
 								if (
@@ -108,10 +130,16 @@ export default class CSSParser {
 							break;
 						case '@supports':
 						case '@-webkit-supports':
-							const supportsRule = new CSSSupportsRule(PropertySymbol.illegalConstructor, window);
+							const supportsRule = new CSSSupportsRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
 
-							(<string>supportsRule.conditionText) = ruleParameters;
-							supportsRule.parentStyleSheet = parentStyleSheet;
+							supportsRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-supports' ? '-webkit-' : '';
+							supportsRule[PropertySymbol.conditionText] = ruleParameters;
+							supportsRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 							if (parentRule) {
 								if (
 									parentRule.type === CSSRuleTypeEnum.mediaRule ||
@@ -126,10 +154,14 @@ export default class CSSParser {
 							parentRule = supportsRule;
 							break;
 						case '@font-face':
-							const fontFaceRule = new CSSFontFaceRule(PropertySymbol.illegalConstructor, window);
+							const fontFaceRule = new CSSFontFaceRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
 
 							fontFaceRule[PropertySymbol.cssText] = ruleParameters;
-							fontFaceRule.parentStyleSheet = parentStyleSheet;
+							fontFaceRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 							if (parentRule) {
 								if (
 									parentRule.type === CSSRuleTypeEnum.mediaRule ||
@@ -143,19 +175,64 @@ export default class CSSParser {
 							}
 							parentRule = fontFaceRule;
 							break;
+						case '@scope':
+						case '@-webkit-scope':
+							const scopeRule = new CSSScopeRule(PropertySymbol.illegalConstructor, window, this);
+
+							scopeRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-scope' ? '-webkit-' : '';
+							scopeRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+
+							if (ruleParameters) {
+								const scopeRuleParts = ruleParameters.split(/\s+to\s+/);
+								if (
+									scopeRuleParts[0] &&
+									scopeRuleParts[0][0] === '(' &&
+									scopeRuleParts[0][scopeRuleParts[0].length - 1] === ')'
+								) {
+									scopeRule[PropertySymbol.start] = scopeRuleParts[0].slice(1, -1);
+								}
+								if (
+									scopeRuleParts[1] &&
+									scopeRuleParts[1][0] === '(' &&
+									scopeRuleParts[1][scopeRuleParts[1].length - 1] === ')'
+								) {
+									scopeRule[PropertySymbol.end] = scopeRuleParts[1].slice(1, -1);
+								}
+							}
+
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(scopeRule);
+								}
+							} else {
+								cssRules.push(scopeRule);
+							}
+							parentRule = scopeRule;
+							break;
 						default:
 							// Unknown rule.
 							// We will create a new rule to let it grab its content, but we will not add it to the cssRules array.
-							const newRule = new CSSRule(PropertySymbol.illegalConstructor, window);
-							newRule.parentStyleSheet = parentStyleSheet;
+							const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+							newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
 							parentRule = newRule;
 							break;
 					}
 				} else if (parentRule && parentRule.type === CSSRuleTypeEnum.keyframesRule) {
-					const newRule = new CSSKeyframeRule(PropertySymbol.illegalConstructor, window);
-					(<string>newRule.keyText) = selectorText.trim();
-					newRule.parentStyleSheet = parentStyleSheet;
-					newRule.parentRule = parentRule;
+					const newRule = new CSSKeyframeRule(PropertySymbol.illegalConstructor, window, this);
+					let keyText = selectorText.trim();
+					if (keyText === 'from') {
+						keyText = '0%';
+					} else if (keyText === 'to') {
+						keyText = '100%';
+					}
+					newRule[PropertySymbol.keyText] = keyText;
+					newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+					newRule[PropertySymbol.parentRule] = parentRule;
 
 					(<CSSKeyframesRule>parentRule).cssRules.push(<CSSKeyframeRule>newRule);
 					parentRule = newRule;
@@ -166,19 +243,19 @@ export default class CSSParser {
 						parentRule.type === CSSRuleTypeEnum.supportsRule)
 				) {
 					if (this.validateSelectorText(selectorText)) {
-						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window);
-						(<string>newRule.selectorText) = selectorText;
-						newRule.parentStyleSheet = parentStyleSheet;
-						newRule.parentRule = parentRule;
+						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+						newRule[PropertySymbol.selectorText] = selectorText;
+						newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+						newRule[PropertySymbol.parentRule] = parentRule;
 						(<CSSMediaRule>parentRule).cssRules.push(newRule);
 						parentRule = newRule;
 					}
 				} else {
 					if (this.validateSelectorText(selectorText)) {
-						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window);
-						(<string>newRule.selectorText) = selectorText;
-						newRule.parentStyleSheet = parentStyleSheet;
-						newRule.parentRule = parentRule;
+						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+						newRule[PropertySymbol.selectorText] = selectorText;
+						newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+						newRule[PropertySymbol.parentRule] = parentRule;
 
 						if (!parentRule) {
 							cssRules.push(newRule);
@@ -223,7 +300,7 @@ export default class CSSParser {
 	 * @param selectorText Selector text.
 	 * @returns True if valid, false otherwise.
 	 */
-	private static validateSelectorText(selectorText: string): boolean {
+	private validateSelectorText(selectorText: string): boolean {
 		try {
 			SelectorParser.getSelectorGroups(selectorText);
 		} catch (e) {

package/src/event/events/IPopStateEventInit.ts

@@ -0,0 +1,6 @@
+import IEventInit from '../IEventInit.js';
+
+export default interface IPopStateEventInit extends IEventInit {
+	state?: object | null;
+	hasUAVisualTransition?: boolean;
+}

package/src/event/events/PopStateEvent.ts

@@ -0,0 +1,23 @@
+import Event from '../Event.js';
+import IPopStateEventInit from './IPopStateEventInit.js';
+
+/**
+ *
+ */
+export default class PopStateEvent extends Event {
+	public readonly state: object | null;
+	public readonly hasUAVisualTransition: boolean;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param type Event type.
+	 * @param [eventInit] Event init.
+	 */
+	constructor(type: string, eventInit: IPopStateEventInit | null = null) {
+		super(type);
+
+		this.state = eventInit?.state ?? null;
+		this.hasUAVisualTransition = eventInit?.hasUAVisualTransition ?? false;
+	}
+}

package/src/fetch/Fetch.ts

@@ -31,6 +31,7 @@ import FetchBodyUtility from './utilities/FetchBodyUtility.js';
 import IFetchInterceptor from './types/IFetchInterceptor.js';
 import VirtualServerUtility from './utilities/VirtualServerUtility.js';
 import PreloadUtility from './preload/PreloadUtility.js';
+import IFetchRequestHeaders from './types/IFetchRequestHeaders.js';
 
 const LAST_CHUNK = Buffer.from('0\r\n\r\n');
 
@@ -56,6 +57,7 @@ export default class Fetch {
 	private response: Response | null = null;
 	private responseHeaders: Headers | null = null;
 	private interceptor: IFetchInterceptor | null;
+	private requestHeaders: IFetchRequestHeaders[] | null;
 	private request: Request;
 	private redirectCount = 0;
 	private disableCache: boolean;
@@ -109,6 +111,7 @@ export default class Fetch {
 			this.#browserFrame.page.context.browser.settings.fetch.disableSameOriginPolicy ??
 			false;
 		this.interceptor = this.#browserFrame.page.context.browser.settings.fetch.interceptor;
+		this.requestHeaders = this.#browserFrame.page.context.browser.settings.fetch.requestHeaders;
 		this.disablePreload = options.disablePreload ?? false;
 	}
 
@@ -118,8 +121,30 @@ export default class Fetch {
 	 * @returns Response.
 	 */
 	public async send(): Promise<Response> {
+		if (!(this.request instanceof Request) || !(this.request[PropertySymbol.url] instanceof URL)) {
+			throw new this.#window.DOMException(
+				'Unknown request object. Request object must be an instance of Request.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
 		FetchRequestReferrerUtility.prepareRequest(new URL(this.#window.location.href), this.request);
 
+		if (this.requestHeaders) {
+			for (const header of this.requestHeaders) {
+				if (
+					!header.url ||
+					(typeof header.url === 'string'
+						? header.url.startsWith(this.request.url)
+						: this.request.url.match(header.url))
+				) {
+					for (const [key, value] of Object.entries(header.headers)) {
+						this.request.headers.set(key, value);
+					}
+				}
+			}
+		}
+
 		if (this.interceptor?.beforeAsyncRequest) {
 			const taskID = this.#browserFrame[PropertySymbol.asyncTaskManager].startTask();
 			const response = await this.interceptor.beforeAsyncRequest({
@@ -323,7 +348,7 @@ export default class Fetch {
 	 * @returns Response.
 	 */
 	private async getVirtualServerResponse(): Promise<Response | null> {
-		const filePath = VirtualServerUtility.getFilepath(this.#window, this.request.url);
+		let filePath = VirtualServerUtility.getFilepath(this.#window, this.request.url);
 
 		if (!filePath) {
 			return null;
@@ -350,9 +375,8 @@ export default class Fetch {
 
 		try {
 			const stat = await FS.promises.stat(filePath);
-			buffer = await FS.promises.readFile(
-				stat.isDirectory() ? Path.join(filePath, 'index.html') : filePath
-			);
+			filePath = stat.isDirectory() ? Path.join(filePath, 'index.html') : filePath;
+			buffer = await FS.promises.readFile(filePath);
 		} catch (error) {
 			this.#browserFrame.page.console.error(
 				`${this.request.method} ${this.request.url} 404 (Not Found)`
@@ -381,6 +405,7 @@ export default class Fetch {
 
 		const response = new this.#window.Response(body);
 		response[PropertySymbol.buffer] = buffer;
+		response[PropertySymbol.virtualServerFile] = filePath;
 		(<string>response.url) = this.request.url;
 
 		const interceptedResponse = this.interceptor?.afterAsyncResponse
@@ -394,15 +419,16 @@ export default class Fetch {
 		this.#browserFrame[PropertySymbol.asyncTaskManager].endTask(taskID);
 
 		const returnResponse = interceptedResponse instanceof Response ? interceptedResponse : response;
-		const cachedResponse = {
+		const cacheableResponse = {
 			...returnResponse,
 			body: buffer,
-			waitingForBody: false
+			waitingForBody: false,
+			virtual: true
 		};
 
 		response[PropertySymbol.cachedResponse] = this.#browserFrame.page.context.responseCache.add(
 			this.request,
-			cachedResponse
+			cacheableResponse
 		);
 
 		return returnResponse;
@@ -978,6 +1004,7 @@ export default class Fetch {
 					url: locationURL,
 					init: requestInit,
 					redirectCount: this.redirectCount + 1,
+					disableSameOriginPolicy: this.disableSameOriginPolicy,
 					contentType: !shouldBecomeGetRequest ? this.request[PropertySymbol.contentType] : null
 				});
 

package/src/fetch/Request.ts

@@ -320,7 +320,9 @@ export default class Request implements Request {
 
 		asyncTaskManager.endTask(taskID);
 
-		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+		return <ArrayBuffer>(
+			buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+		);
 	}
 
 	/**

package/src/fetch/ResourceFetch.ts

@@ -7,6 +7,7 @@ import WindowBrowserContext from '../window/WindowBrowserContext.js';
 import PreloadUtility from './preload/PreloadUtility.js';
 import * as PropertySymbol from '../PropertySymbol.js';
 import IRequestReferrerPolicy from './types/IRequestReferrerPolicy.js';
+import IResourceFetchResponse from './types/IResourceFetchResponse.js';
 
 /**
  * Helper class for performing fetch of resources.
@@ -37,11 +38,14 @@ export default class ResourceFetch {
 		url: string | URL,
 		destination: 'script' | 'style' | 'module',
 		options?: { credentials?: IRequestCredentials; referrerPolicy?: IRequestReferrerPolicy }
-	): Promise<string> {
+	): Promise<IResourceFetchResponse> {
 		const browserFrame = new WindowBrowserContext(this.window).getBrowserFrame();
 
 		if (!browserFrame) {
-			return '';
+			return {
+				content: '',
+				virtualServerFile: null
+			};
 		}
 
 		// Preloaded resource
@@ -67,7 +71,10 @@ export default class ResourceFetch {
 					);
 				}
 
-				return preloadEntry.response?.[PropertySymbol.buffer]?.toString() || '';
+				return {
+					content: preloadEntry.response?.[PropertySymbol.buffer]?.toString() || '',
+					virtualServerFile: preloadEntry.response?.[PropertySymbol.virtualServerFile] || null
+				};
 			}
 		}
 
@@ -93,7 +100,10 @@ export default class ResourceFetch {
 			);
 		}
 
-		return await response.text();
+		return {
+			content: await response.text(),
+			virtualServerFile: response[PropertySymbol.virtualServerFile] || null
+		};
 	}
 
 	/**
@@ -110,11 +120,14 @@ export default class ResourceFetch {
 		url: string,
 		destination: 'script' | 'style' | 'module',
 		options?: { credentials?: IRequestCredentials; referrerPolicy?: IRequestReferrerPolicy }
-	): string {
+	): IResourceFetchResponse {
 		const browserFrame = new WindowBrowserContext(this.window).getBrowserFrame();
 
 		if (!browserFrame) {
-			return '';
+			return {
+				content: '',
+				virtualServerFile: null
+			};
 		}
 
 		// Preloaded resource
@@ -141,13 +154,10 @@ export default class ResourceFetch {
 					);
 				}
 
-				if (!preloadEntry.response[PropertySymbol.buffer]) {
-					throw new this.window.DOMException(
-						`Failed to perform request to "${new URL(url, this.window.location.href).href}". Response buffer is not available.`
-					);
-				}
-
-				return preloadEntry.response[PropertySymbol.buffer].toString();
+				return {
+					content: preloadEntry.response?.[PropertySymbol.buffer]?.toString() || '',
+					virtualServerFile: preloadEntry.response?.[PropertySymbol.virtualServerFile] || null
+				};
 			}
 		}
 
@@ -172,6 +182,9 @@ export default class ResourceFetch {
 			);
 		}
 
-		return response.body?.toString() || '';
+		return {
+			content: response.body?.toString() || '',
+			virtualServerFile: response[PropertySymbol.virtualServerFile] || null
+		};
 	}
 }

package/src/fetch/Response.ts

@@ -43,6 +43,7 @@ export default class Response implements Response {
 	public readonly headers: Headers;
 	public [PropertySymbol.cachedResponse]: ICachedResponse | null = null;
 	public [PropertySymbol.buffer]: Buffer | null = null;
+	public [PropertySymbol.virtualServerFile]: string | null = null;
 	public [PropertySymbol.aborted]: boolean = false;
 	public [PropertySymbol.error]: Error | null = null;
 
@@ -136,7 +137,9 @@ export default class Response implements Response {
 
 		this.#storeBodyInCache(buffer);
 
-		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+		return <ArrayBuffer>(
+			buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+		);
 	}
 
 	/**
@@ -349,6 +352,8 @@ export default class Response implements Response {
 	 * @param buffer Buffer.
 	 */
 	#storeBodyInCache(buffer: Buffer): void {
+		this[PropertySymbol.buffer] = buffer;
+
 		if (this[PropertySymbol.cachedResponse]?.response?.waitingForBody) {
 			this[PropertySymbol.cachedResponse].response.body = buffer;
 			this[PropertySymbol.cachedResponse].response.waitingForBody = false;