happy-dom 15.0.0 → 15.1.0

package/src/browser/utilities/BrowserExceptionObserver.ts

@@ -0,0 +1,125 @@
+import BrowserWindow from '../../window/BrowserWindow.js';
+
+/**
+ * Listens for uncaught exceptions coming from Happy DOM on the running Node process and dispatches error events on the Window instance.
+ */
+export default class BrowserExceptionObserver {
+	private static listenerCount = 0;
+	private observedWindows: BrowserWindow[] = [];
+	private uncaughtExceptionListener: (
+		error: Error,
+		origin: 'uncaughtException' | 'unhandledRejection'
+	) => void | null;
+	private uncaughtRejectionListener: (error: Error) => void | null;
+
+	/**
+	 * Observes the Node process for uncaught exceptions.
+	 *
+	 * @param window Browser window.
+	 */
+	public observe(window: BrowserWindow): void {
+		if (this.observedWindows.includes(window)) {
+			throw new Error('Browser window is already being observed.');
+		}
+
+		this.observedWindows.push(window);
+
+		if (this.uncaughtExceptionListener) {
+			return;
+		}
+
+		this.uncaughtExceptionListener = (
+			error: unknown,
+			origin: 'uncaughtException' | 'unhandledRejection'
+		): void => {
+			if (origin === 'unhandledRejection') {
+				return;
+			}
+
+			let targetWindow: BrowserWindow | null = null;
+
+			for (const window of this.observedWindows) {
+				if (error instanceof window.Error || error instanceof window.DOMException) {
+					targetWindow = window;
+					break;
+				}
+			}
+
+			if (targetWindow) {
+				targetWindow.console.error(error);
+				targetWindow.dispatchEvent(
+					new targetWindow.ErrorEvent('error', {
+						error: <Error>error,
+						message: (<Error>error).message
+					})
+				);
+			} else if (
+				process.listenerCount('uncaughtException') ===
+				(<typeof BrowserExceptionObserver>this.constructor).listenerCount
+			) {
+				// eslint-disable-next-line no-console
+				console.error(error);
+				// Exit if there are no other listeners handling the error.
+				process.exit(1);
+			}
+		};
+
+		// The "uncaughtException" event is not always triggered for unhandled rejections.
+		// Therefore we want to use the "unhandledRejection" event as well.
+		this.uncaughtRejectionListener = (error: unknown): void => {
+			let targetWindow: BrowserWindow | null = null;
+
+			for (const window of this.observedWindows) {
+				if (error instanceof window.Error || error instanceof window.DOMException) {
+					targetWindow = window;
+					break;
+				}
+			}
+
+			if (targetWindow) {
+				targetWindow.console.error(error);
+				targetWindow.dispatchEvent(
+					new targetWindow.ErrorEvent('error', {
+						error: <Error>error,
+						message: (<Error>error).message
+					})
+				);
+			} else if (
+				process.listenerCount('unhandledRejection') ===
+				(<typeof BrowserExceptionObserver>this.constructor).listenerCount
+			) {
+				// eslint-disable-next-line no-console
+				console.error(error);
+				// Exit if there are no other listeners handling the error.
+				process.exit(1);
+			}
+		};
+
+		(<typeof BrowserExceptionObserver>this.constructor).listenerCount++;
+		process.on('uncaughtException', this.uncaughtExceptionListener);
+		process.on('unhandledRejection', this.uncaughtRejectionListener);
+	}
+
+	/**
+	 * Disconnects observer.
+	 *
+	 * @param window Browser window.
+	 */
+	public disconnect(window: BrowserWindow): void {
+		const index = this.observedWindows.indexOf(window);
+
+		if (index === -1) {
+			return;
+		}
+
+		this.observedWindows.splice(index, 1);
+
+		if (this.observedWindows.length === 0 && this.uncaughtExceptionListener) {
+			(<typeof BrowserExceptionObserver>this.constructor).listenerCount--;
+			process.off('uncaughtException', this.uncaughtExceptionListener);
+			process.off('unhandledRejection', this.uncaughtRejectionListener);
+			this.uncaughtExceptionListener = null;
+			this.uncaughtRejectionListener = null;
+		}
+	}
+}

package/src/browser/utilities/BrowserFrameFactory.ts

@@ -2,6 +2,7 @@ import IBrowserFrame from '../types/IBrowserFrame.js';
 import * as PropertySymbol from '../../PropertySymbol.js';
 import BrowserWindow from '../../window/BrowserWindow.js';
 import IBrowserPage from '../types/IBrowserPage.js';
+
 /**
  * Browser frame factory.
  */
@@ -27,7 +28,9 @@ export default class BrowserFrameFactory {
 	 * @param frame Frame.
 	 */
 	public static destroyFrame(frame: IBrowserFrame): Promise<void> {
-		// Using Promise instead of async/await to prevent microtask
+		const exceptionObserver = frame.page?.context?.browser?.[PropertySymbol.exceptionObserver];
+
+		// Using Promise instead of async/await to prevent usage of a microtask
 		return new Promise((resolve, reject) => {
 			if (!frame.window) {
 				resolve();
@@ -42,54 +45,47 @@ export default class BrowserFrameFactory {
 			}
 
 			if (!frame.childFrames.length) {
-				if (frame.window && frame.window[PropertySymbol.mutationObservers]) {
-					for (const mutationObserver of frame.window[PropertySymbol.mutationObservers]) {
-						mutationObserver.disconnect();
-					}
-					frame.window[PropertySymbol.mutationObservers] = [];
-				}
-				return frame[PropertySymbol.asyncTaskManager]
+				frame[PropertySymbol.asyncTaskManager]
 					.destroy()
 					.then(() => {
-						frame[PropertySymbol.exceptionObserver]?.disconnect();
-						if (frame.window) {
-							frame.window[PropertySymbol.destroy]();
-							(<IBrowserPage | null>frame.page) = null;
-							(<BrowserWindow | null>frame.window) = null;
-							frame[PropertySymbol.openerFrame] = null;
-							frame[PropertySymbol.openerWindow] = null;
+						if (exceptionObserver && frame.window) {
+							exceptionObserver.disconnect(frame.window);
 						}
+
+						(<IBrowserPage | null>frame.page) = null;
+						(<BrowserWindow | null>frame.window) = null;
+						frame[PropertySymbol.openerFrame] = null;
+						frame[PropertySymbol.openerWindow] = null;
+
 						resolve();
 					})
 					.catch((error) => reject(error));
+				if (frame.window) {
+					frame.window[PropertySymbol.destroy]();
+				}
+				return;
 			}
 
 			Promise.all(frame.childFrames.slice().map((childFrame) => this.destroyFrame(childFrame)))
 				.then(() => {
-					if (frame.window && frame.window[PropertySymbol.mutationObservers]) {
-						for (const mutationObserver of frame.window[PropertySymbol.mutationObservers]) {
-							mutationObserver.disconnect();
-						}
-						frame.window[PropertySymbol.mutationObservers] = [];
-					}
-					return frame[PropertySymbol.asyncTaskManager].destroy().then(() => {
-						frame[PropertySymbol.exceptionObserver]?.disconnect();
-						if (frame.window) {
-							const listeners = frame[PropertySymbol.listeners];
+					frame[PropertySymbol.asyncTaskManager]
+						.destroy()
+						.then(() => {
+							if (exceptionObserver && frame.window) {
+								exceptionObserver.disconnect(frame.window);
+							}
 
-							frame.window[PropertySymbol.destroy]();
 							(<IBrowserPage | null>frame.page) = null;
 							(<BrowserWindow | null>frame.window) = null;
-							frame[PropertySymbol.listeners] = null;
 							frame[PropertySymbol.openerFrame] = null;
 							frame[PropertySymbol.openerWindow] = null;
 
-							for (const listener of listeners.navigation) {
-								listener();
-							}
-						}
-						resolve();
-					});
+							resolve();
+						})
+						.catch((error) => reject(error));
+					if (frame.window) {
+						frame.window[PropertySymbol.destroy]();
+					}
 				})
 				.catch((error) => reject(error));
 		});

package/src/browser/utilities/BrowserFrameNavigator.ts

@@ -4,13 +4,10 @@ import IGoToOptions from '../types/IGoToOptions.js';
 import Response from '../../fetch/Response.js';
 import DocumentReadyStateManager from '../../nodes/document/DocumentReadyStateManager.js';
 import BrowserWindow from '../../window/BrowserWindow.js';
-import WindowErrorUtility from '../../window/WindowErrorUtility.js';
-import AbortController from '../../fetch/AbortController.js';
 import BrowserFrameFactory from './BrowserFrameFactory.js';
 import BrowserFrameURL from './BrowserFrameURL.js';
 import BrowserFrameValidator from './BrowserFrameValidator.js';
 import AsyncTaskManager from '../../async-task-manager/AsyncTaskManager.js';
-import BrowserErrorCaptureEnum from '../enums/BrowserErrorCaptureEnum.js';
 import FormData from '../../form-data/FormData.js';
 import HistoryScrollRestorationEnum from '../../history/HistoryScrollRestorationEnum.js';
 import IHistoryItem from '../../history/IHistoryItem.js';
@@ -46,6 +43,7 @@ export default class BrowserFrameNavigator {
 		disableHistory?: boolean;
 	}): Promise<Response | null> {
 		const { windowClass, frame, url, formData, method, goToOptions, disableHistory } = options;
+		const exceptionObserver = frame.page.context.browser[PropertySymbol.exceptionObserver];
 		const referrer = goToOptions?.referrer || frame.window.location.origin;
 		const targetURL = BrowserFrameURL.getRelativeURL(frame, url);
 		const resolveNavigationListeners = (): void => {
@@ -60,6 +58,7 @@ export default class BrowserFrameNavigator {
 			throw new Error('The frame has been destroyed, the "window" property is not set.');
 		}
 
+		// Javascript protocol
 		if (targetURL.protocol === 'javascript:') {
 			if (frame && !frame.page.context.browser.settings.disableJavaScriptEvaluation) {
 				const readyStateManager = (<
@@ -67,30 +66,26 @@ export default class BrowserFrameNavigator {
 				>(<unknown>frame.window))[PropertySymbol.readyStateManager];
 
 				readyStateManager.startTask();
-
-				// The browser will wait for the next tick before executing the script.
-				await new Promise((resolve) => frame.page.mainFrame.window.setTimeout(resolve));
-
 				const code =
 					'//# sourceURL=' + frame.url + '\n' + targetURL.href.replace('javascript:', '');
 
-				if (
-					frame.page.context.browser.settings.disableErrorCapturing ||
-					frame.page.context.browser.settings.errorCapture !== BrowserErrorCaptureEnum.tryAndCatch
-				) {
-					frame.window.eval(code);
-				} else {
-					WindowErrorUtility.captureError(frame.window, () => frame.window.eval(code));
-				}
+				// The browser will wait for the next tick before executing the script.
+				// Fixes issue where evaluating the response can throw an error.
+				// By using requestAnimationFrame() the error will not reject the promise.
+				// The error will be caught by process error level listener or a try and catch in the requestAnimationFrame().
+				frame.window.requestAnimationFrame(() => frame.window.eval(code));
 
-				readyStateManager.endTask();
+				// We need to wait for the next tick before resolving navigation listeners and ending the ready state task.
+				await new Promise((resolve) => frame.window.setTimeout(() => resolve(null)));
 
+				readyStateManager.endTask();
 				resolveNavigationListeners();
 			}
 
 			return null;
 		}
 
+		// Validate navigation
 		if (!BrowserFrameValidator.validateCrossOriginPolicy(frame, targetURL)) {
 			return null;
 		}
@@ -103,16 +98,6 @@ export default class BrowserFrameNavigator {
 			return null;
 		}
 
-		const width = frame.window.innerWidth;
-		const height = frame.window.innerHeight;
-		const devicePixelRatio = frame.window.devicePixelRatio;
-		const parentWindow = frame.parentFrame ? frame.parentFrame.window : frame.page.mainFrame.window;
-		const topWindow = frame.page.mainFrame.window;
-
-		for (const childFrame of frame.childFrames) {
-			BrowserFrameFactory.destroyFrame(childFrame);
-		}
-
 		// History management.
 		if (!disableHistory) {
 			const history = frame[PropertySymbol.history];
@@ -138,36 +123,63 @@ export default class BrowserFrameNavigator {
 			});
 		}
 
-		(<IBrowserFrame[]>frame.childFrames) = [];
-		frame.window[PropertySymbol.destroy]();
-		frame[PropertySymbol.asyncTaskManager].destroy();
-		frame[PropertySymbol.asyncTaskManager] = new AsyncTaskManager();
+		// Store current Window state
+		const previousWindow = frame.window;
+		const previousAsyncTaskManager = frame[PropertySymbol.asyncTaskManager];
+		const width = previousWindow.innerWidth;
+		const height = previousWindow.innerHeight;
+		const devicePixelRatio = previousWindow.devicePixelRatio;
+		const parentWindow = frame.parentFrame ? frame.parentFrame.window : frame.page.mainFrame.window;
+		const topWindow = frame.page.mainFrame.window;
 
+		// Create new Window
+		frame[PropertySymbol.asyncTaskManager] = new AsyncTaskManager(frame);
 		(<BrowserWindow>frame.window) = new windowClass(frame, { url: targetURL.href, width, height });
 		frame.window[PropertySymbol.parent] = parentWindow;
 		frame.window[PropertySymbol.top] = topWindow;
 		(<number>frame.window.devicePixelRatio) = devicePixelRatio;
 
+		if (exceptionObserver) {
+			exceptionObserver.observe(frame.window);
+		}
+
 		if (referrer) {
 			frame.window.document[PropertySymbol.referrer] = referrer;
 		}
 
+		// Destroy child frames and Window
+		const destroyTaskID = frame[PropertySymbol.asyncTaskManager].startTask();
+		const destroyWindowAndAsyncTaskManager = (): void => {
+			previousAsyncTaskManager.destroy().then(() => {
+				if (exceptionObserver) {
+					exceptionObserver.disconnect(previousWindow);
+				}
+				frame[PropertySymbol.asyncTaskManager].endTask(destroyTaskID);
+			});
+
+			previousWindow[PropertySymbol.destroy]();
+		};
+
+		if (frame.childFrames.length) {
+			Promise.all(
+				frame.childFrames.map((childFrame) => BrowserFrameFactory.destroyFrame(childFrame))
+			).then(destroyWindowAndAsyncTaskManager);
+		} else {
+			destroyWindowAndAsyncTaskManager();
+		}
+
+		// About protocol
 		if (targetURL.protocol === 'about:') {
 			await new Promise((resolve) => frame.page.mainFrame.window.requestAnimationFrame(resolve));
 			resolveNavigationListeners();
 			return null;
 		}
 
+		// Start navigation
 		const readyStateManager = (<{ [PropertySymbol.readyStateManager]: DocumentReadyStateManager }>(
 			(<unknown>frame.window)
 		))[PropertySymbol.readyStateManager];
-
-		readyStateManager.startTask();
-
-		const abortController = new AbortController();
-		let response: Response;
-		let responseText: string;
-
+		const abortController = new frame.window.AbortController();
 		const timeout = frame.window.setTimeout(
 			() => abortController.abort(new Error('Request timed out.')),
 			goToOptions?.timeout ?? 30000
@@ -177,6 +189,10 @@ export default class BrowserFrameNavigator {
 			readyStateManager.endTask();
 			resolveNavigationListeners();
 		};
+		let response: Response;
+		let responseText: string;
+
+		readyStateManager.startTask();
 
 		try {
 			response = await frame.window.fetch(targetURL.href, {
@@ -211,13 +227,19 @@ export default class BrowserFrameNavigator {
 			frame.page.console.error(`GET ${targetURL.href} ${response.status} (${response.statusText})`);
 		}
 
+		// The frame may be destroyed during teardown.
+		if (!frame.window) {
+			return;
+		}
+
 		// Fixes issue where evaluating the response can throw an error.
 		// By using requestAnimationFrame() the error will not reject the promise.
 		// The error will be caught by process error level listener or a try and catch in the requestAnimationFrame().
 		frame.window.requestAnimationFrame(() => (frame.content = responseText));
 
+		// Finalize the navigation
 		await new Promise((resolve) =>
-			frame.window.requestAnimationFrame(() => {
+			frame.window.setTimeout(() => {
 				finalize();
 				resolve(null);
 			})

package/src/clipboard/Clipboard.ts

@@ -1,4 +1,3 @@
-import DOMException from '../exception/DOMException.js';
 import BrowserWindow from '../window/BrowserWindow.js';
 import ClipboardItem from './ClipboardItem.js';
 import Blob from '../file/Blob.js';
@@ -10,16 +9,19 @@ import Blob from '../file/Blob.js';
  * https://developer.mozilla.org/en-US/docs/Web/API/Clipboard.
  */
 export default class Clipboard {
-	#ownerWindow: BrowserWindow;
+	#window: BrowserWindow;
 	#data: ClipboardItem[] = [];
 
 	/**
 	 * Constructor.
 	 *
-	 * @param ownerWindow Owner window.
+	 * @param window Owner window.
 	 */
-	constructor(ownerWindow: BrowserWindow) {
-		this.#ownerWindow = ownerWindow;
+	constructor(window: BrowserWindow) {
+		if (!window) {
+			throw new TypeError('Illegal constructor');
+		}
+		this.#window = window;
 	}
 
 	/**
@@ -28,11 +30,13 @@ export default class Clipboard {
 	 * @returns Data.
 	 */
 	public async read(): Promise<ClipboardItem[]> {
-		const permissionStatus = await this.#ownerWindow.navigator.permissions.query({
+		const permissionStatus = await this.#window.navigator.permissions.query({
 			name: 'clipboard-read'
 		});
 		if (permissionStatus.state === 'denied') {
-			throw new DOMException(`Failed to execute 'read' on 'Clipboard': The request is not allowed`);
+			throw new this.#window.DOMException(
+				`Failed to execute 'read' on 'Clipboard': The request is not allowed`
+			);
 		}
 		return this.#data;
 	}
@@ -43,11 +47,11 @@ export default class Clipboard {
 	 * @returns Text.
 	 */
 	public async readText(): Promise<string> {
-		const permissionStatus = await this.#ownerWindow.navigator.permissions.query({
+		const permissionStatus = await this.#window.navigator.permissions.query({
 			name: 'clipboard-read'
 		});
 		if (permissionStatus.state === 'denied') {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				`Failed to execute 'readText' on 'Clipboard': The request is not allowed`
 			);
 		}
@@ -72,11 +76,11 @@ export default class Clipboard {
 	 * @param data Data.
 	 */
 	public async write(data: ClipboardItem[]): Promise<void> {
-		const permissionStatus = await this.#ownerWindow.navigator.permissions.query({
+		const permissionStatus = await this.#window.navigator.permissions.query({
 			name: 'clipboard-write'
 		});
 		if (permissionStatus.state === 'denied') {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				`Failed to execute 'write' on 'Clipboard': The request is not allowed`
 			);
 		}
@@ -89,14 +93,16 @@ export default class Clipboard {
 	 * @param text Text.
 	 */
 	public async writeText(text: string): Promise<void> {
-		const permissionStatus = await this.#ownerWindow.navigator.permissions.query({
+		const permissionStatus = await this.#window.navigator.permissions.query({
 			name: 'clipboard-write'
 		});
 		if (permissionStatus.state === 'denied') {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				`Failed to execute 'writeText' on 'Clipboard': The request is not allowed`
 			);
 		}
-		this.#data = [new ClipboardItem({ 'text/plain': new Blob([text], { type: 'text/plain' }) })];
+		this.#data = [
+			new this.#window.ClipboardItem({ 'text/plain': new Blob([text], { type: 'text/plain' }) })
+		];
 	}
 }

package/src/css/declaration/AbstractCSSStyleDeclaration.ts

@@ -1,9 +1,9 @@
 import Element from '../../nodes/element/Element.js';
 import CSSRule from '../CSSRule.js';
 import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
-import DOMException from '../../exception/DOMException.js';
 import CSSStyleDeclarationElementStyle from './element-style/CSSStyleDeclarationElementStyle.js';
 import CSSStyleDeclarationPropertyManager from './property-manager/CSSStyleDeclarationPropertyManager.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
 
 /**
  * CSS Style Declaration.
@@ -68,7 +68,7 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 */
 	public set cssText(cssText: string) {
 		if (this.#computed) {
-			throw new DOMException(
+			throw new this[PropertySymbol.window].DOMException(
 				`Failed to execute 'cssText' on 'CSSStyleDeclaration': These styles are computed, and the properties are therefore read-only.`,
 				DOMExceptionNameEnum.domException
 			);
@@ -106,7 +106,7 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 */
 	public setProperty(name: string, value: string, priority?: 'important' | '' | undefined): void {
 		if (this.#computed) {
-			throw new DOMException(
+			throw new this[PropertySymbol.window].DOMException(
 				`Failed to execute 'setProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`,
 				DOMExceptionNameEnum.domException
 			);
@@ -139,7 +139,7 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 */
 	public removeProperty(name: string): void {
 		if (this.#computed) {
-			throw new DOMException(
+			throw new this[PropertySymbol.window].DOMException(
 				`Failed to execute 'removeProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`,
 				DOMExceptionNameEnum.domException
 			);

package/src/css/declaration/element-style/CSSStyleDeclarationElementStyle.ts

@@ -17,7 +17,7 @@ import CSSStyleDeclarationCSSParser from '../css-parser/CSSStyleDeclarationCSSPa
 import QuerySelector from '../../../query-selector/QuerySelector.js';
 import CSSMeasurementConverter from '../measurement-converter/CSSMeasurementConverter.js';
 import MediaQueryList from '../../../match-media/MediaQueryList.js';
-import WindowBrowserSettingsReader from '../../../window/WindowBrowserSettingsReader.js';
+import WindowBrowserContext from '../../../window/WindowBrowserContext.js';
 
 const CSS_MEASUREMENT_REGEXP = /[0-9.]+(px|rem|em|vw|vh|%|vmin|vmax|cm|mm|in|pt|pc|Q)/g;
 const CSS_VARIABLE_REGEXP = /var\( *(--[^), ]+)\)|var\( *(--[^), ]+), *(.+)\)/;
@@ -333,7 +333,7 @@ export default class CSSStyleDeclarationElementStyle {
 			return;
 		}
 
-		const ownerWindow = this.element[PropertySymbol.ownerDocument][PropertySymbol.ownerWindow];
+		const window = this.element[PropertySymbol.window];
 
 		for (const rule of options.cssRules) {
 			if (rule.type === CSSRuleTypeEnum.styleRule) {
@@ -371,7 +371,7 @@ export default class CSSStyleDeclarationElementStyle {
 				rule.type === CSSRuleTypeEnum.mediaRule &&
 				// TODO: We need to send in a predfined root font size as it will otherwise be calculated using Window.getComputedStyle(), which will cause a never ending loop. Is there another solution?
 				new MediaQueryList({
-					ownerWindow,
+					window,
 					media: (<CSSMediaRule>rule).conditionText,
 					rootFontSize: this.element[PropertySymbol.tagName] === 'HTML' ? 16 : null
 				}).matches
@@ -425,9 +425,8 @@ export default class CSSStyleDeclarationElementStyle {
 		parentSize: string | number | null;
 	}): string {
 		if (
-			WindowBrowserSettingsReader.getSettings(
-				this.element[PropertySymbol.ownerDocument][PropertySymbol.ownerWindow]
-			).disableComputedStyleRendering
+			new WindowBrowserContext(this.element[PropertySymbol.window]).getSettings()
+				?.disableComputedStyleRendering
 		) {
 			return options.value;
 		}
@@ -439,7 +438,7 @@ export default class CSSStyleDeclarationElementStyle {
 		while ((match = regexp.exec(options.value)) !== null) {
 			if (match[1] !== 'px') {
 				const valueInPixels = CSSMeasurementConverter.toPixels({
-					ownerWindow: this.element[PropertySymbol.ownerDocument][PropertySymbol.ownerWindow],
+					window: this.element[PropertySymbol.window],
 					value: match[0],
 					rootFontSize: options.rootFontSize,
 					parentFontSize: options.parentFontSize,

package/src/css/declaration/measurement-converter/CSSMeasurementConverter.ts

@@ -8,7 +8,7 @@ export default class CSSMeasurementConverter {
 	 * Returns measurement in pixels.
 	 *
 	 * @param options Options.
-	 * @param options.ownerWindow Owner window.
+	 * @param options.window Owner window.
 	 * @param options.value Measurement (e.g. "10px", "10rem" or "10em").
 	 * @param options.rootFontSize Root font size in pixels.
 	 * @param options.parentFontSize Parent font size in pixels.
@@ -16,7 +16,7 @@ export default class CSSMeasurementConverter {
 	 * @returns Measurement in pixels.
 	 */
 	public static toPixels(options: {
-		ownerWindow: BrowserWindow;
+		window: BrowserWindow;
 		value: string;
 		rootFontSize: string | number;
 		parentFontSize: string | number;
@@ -37,21 +37,19 @@ export default class CSSMeasurementConverter {
 			case 'em':
 				return this.round(value * parseFloat(<string>options.parentFontSize));
 			case 'vw':
-				return this.round((value * options.ownerWindow.innerWidth) / 100);
+				return this.round((value * options.window.innerWidth) / 100);
 			case 'vh':
-				return this.round((value * options.ownerWindow.innerHeight) / 100);
+				return this.round((value * options.window.innerHeight) / 100);
 			case '%':
 				return options.parentSize !== undefined && options.parentSize !== null
 					? this.round((value * parseFloat(<string>options.parentSize)) / 100)
 					: null;
 			case 'vmin':
 				return this.round(
-					(value * Math.min(options.ownerWindow.innerWidth, options.ownerWindow.innerHeight)) / 100
+					(value * Math.min(options.window.innerWidth, options.window.innerHeight)) / 100
 				);
 			case 'vmax':
-				return (
-					(value * Math.max(options.ownerWindow.innerWidth, options.ownerWindow.innerHeight)) / 100
-				);
+				return (value * Math.max(options.window.innerWidth, options.window.innerHeight)) / 100;
 			case 'cm':
 				return this.round(value * 37.7812);
 			case 'mm':