buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/browser/utilities/BrowserFrameValidator.ts

@@ -0,0 +1,84 @@
+import type IBrowserFrame from '../types/IBrowserFrame.js';
+import type { URL } from 'url';
+import BrowserNavigationCrossOriginPolicyEnum from '../enums/BrowserNavigationCrossOriginPolicyEnum.js';
+import type DetachedBrowserFrame from '../detached-browser/DetachedBrowserFrame.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * Browser frame validator.
+ */
+export default class BrowserFrameValidator {
+	/**
+	 * Returns true if the frame navigation complies with the cross origin policy.
+	 *
+	 * @param frame Frame.
+	 * @param toURL URL.
+	 * @returns True if the frame navigation complies with the cross origin policy.
+	 */
+	public static validateCrossOriginPolicy(frame: IBrowserFrame, toURL: URL): boolean {
+		const settings = frame.page.context.browser.settings;
+		let fromURL = frame.page.mainFrame.window.location;
+
+		if (frame[PropertySymbol.openerFrame]) {
+			fromURL = frame[PropertySymbol.openerFrame].window.location;
+		} else if (frame.parentFrame) {
+			fromURL = frame.parentFrame.window.location;
+		}
+
+		if (
+			settings.navigation.crossOriginPolicy === BrowserNavigationCrossOriginPolicyEnum.sameOrigin &&
+			fromURL.protocol !== 'about:' &&
+			toURL.protocol !== 'about:' &&
+			toURL.protocol !== 'javascript:' &&
+			fromURL.origin !== toURL.origin
+		) {
+			return false;
+		}
+
+		if (
+			settings.navigation.crossOriginPolicy ===
+				BrowserNavigationCrossOriginPolicyEnum.strictOrigin &&
+			fromURL.protocol === 'https:' &&
+			toURL.protocol === 'http:'
+		) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Returns true if navigation is allowed for the frame.
+	 *
+	 * @param frame Frame.
+	 * @returns True if navigation is allowed for the frame.
+	 */
+	public static validateFrameNavigation(frame: IBrowserFrame): boolean {
+		const settings = frame.page.context.browser.settings;
+
+		// When using the Window instance directly and not via the Browser API we should not navigate the browser frame.
+		// Only a detached browser has a windowClass property and we want to avoid a circular dependency.
+		if (
+			(<DetachedBrowserFrame>frame).page.context.browser.windowClass &&
+			frame.page.context === frame.page.context.browser.defaultContext &&
+			frame.page.context.pages[0] === frame.page &&
+			frame.page.mainFrame === frame
+		) {
+			return false;
+		}
+
+		if (settings.navigation.disableMainFrameNavigation && frame.page.mainFrame === frame) {
+			return false;
+		}
+
+		if (settings.navigation.disableChildFrameNavigation && frame.page.mainFrame !== frame) {
+			return false;
+		}
+
+		if (settings.navigation.disableChildPageNavigation && !!frame[PropertySymbol.openerFrame]) {
+			return false;
+		}
+
+		return true;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/utilities/BrowserPageUtility.ts

@@ -0,0 +1,56 @@
+import type IBrowserFrame from '../types/IBrowserFrame.js';
+import type IBrowserPage from '../types/IBrowserPage.js';
+import BrowserFrameFactory from './BrowserFrameFactory.js';
+
+/**
+ * Browser page utility.
+ */
+export default class BrowserPageUtility {
+	/**
+	 * Returns frames for a page.
+	 *
+	 * @param page Page.
+	 * @returns Frames.
+	 */
+	public static getFrames(page: IBrowserPage): IBrowserFrame[] {
+		return this.findFrames(page.mainFrame);
+	}
+
+	/**
+	 * Aborts all ongoing operations and destroys the page.
+	 *
+	 * @param page Page.
+	 */
+	public static closePage(page: IBrowserPage): Promise<void> {
+		if (page.closed) {
+			return Promise.resolve();
+		}
+
+		(<boolean>page.closed) = true;
+
+		const index = page.context.pages.indexOf(page);
+
+		if (index !== -1) {
+			page.context.pages.splice(index, 1);
+		}
+
+		page.virtualConsolePrinter.close();
+
+		// Using Promise instead of async/await to prevent microtask
+		return BrowserFrameFactory.destroyFrame(page.mainFrame);
+	}
+
+	/**
+	 * Returns all frames.
+	 *
+	 * @param parentFrame Parent frame.
+	 * @returns Frames, including the parent.
+	 */
+	private static findFrames(parentFrame: IBrowserFrame): IBrowserFrame[] {
+		let frames = [parentFrame];
+		for (const frame of parentFrame.childFrames) {
+			frames = frames.concat(this.findFrames(frame));
+		}
+		return frames;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasAdapter.ts

@@ -0,0 +1,63 @@
+import type Blob from '../file/Blob.js';
+import type ICanvasAdapterCaller from './ICanvasAdapterCaller.js';
+import type ICanvasRenderingContext2D from './ICanvasRenderingContext2D.js';
+
+/**
+ * Interface for pluggable canvas rendering adapters.
+ *
+ * Implement this interface to provide real canvas rendering support
+ * (e.g., via node-canvas). The adapter is passed via browser settings:
+ *
+ * @example
+ * ```typescript
+ * import { Window } from 'happy-dom';
+ * import { CanvasAdapter } from '@happy-dom/node-canvas-adapter';
+ *
+ * const window = new Window({
+ *   settings: { canvasAdapter: new CanvasAdapter() }
+ * });
+ * ```
+ */
+export default interface ICanvasAdapter {
+	/**
+	 * Creates a rendering context for a canvas element.
+	 *
+	 * @param caller Information about the caller, including the canvas element and its associated window and browser frame.
+	 * @param contextType The context identifier ('2d', 'webgl', etc.).
+	 * @param [contextAttributes] Optional context creation attributes.
+	 * @returns The rendering context, or null if the type is unsupported.
+	 */
+	getContext(
+		caller: ICanvasAdapterCaller,
+		contextType: string,
+		contextAttributes?: Record<string, unknown>
+	): ICanvasRenderingContext2D | null;
+
+	/**
+	 * Serialize the canvas content as a data URL.
+	 *
+	 * @param caller Information about the caller, including the canvas element and its associated window and browser frame.
+	 * @param [type] MIME type of the output image (e.g. `'image/png'`).
+	 * @param [quality] Encoder quality for lossy formats, in the range 0–1.
+	 * @returns A data URL string.
+	 */
+	toDataURL(caller: ICanvasAdapterCaller, type?: string, quality?: unknown): string;
+
+	/**
+	 * Creates a Blob from the canvas content and passes it to the callback.
+	 *
+	 * @param options Options.
+	 * @param options.window The window associated with the canvas.
+	 * @param options.browserFrame The browser frame associated with the canvas.
+	 * @param options.canvas The canvas element to read.
+	 * @param options.callback Receives the resulting Blob, or null on failure.
+	 * @param [options.type] MIME type of the output image.
+	 * @param [options.quality] Encoder quality for lossy formats, in the range 0–1.
+	 */
+	toBlob(
+		caller: ICanvasAdapterCaller,
+		callback: (blob: Blob | null) => void,
+		type?: string,
+		quality?: unknown
+	): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasAdapterCaller.ts

@@ -0,0 +1,9 @@
+import type IBrowserFrame from '../browser/types/IBrowserFrame.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type ICanvasShape from './ICanvasShape.js';
+
+export default interface ICanvasAdapterCaller {
+	window: BrowserWindow;
+	browserFrame: IBrowserFrame;
+	canvas: ICanvasShape;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasGradient.ts

@@ -0,0 +1,8 @@
+/**
+ * The CanvasGradient interface represents an opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient(), CanvasRenderingContext2D.createConicGradient() or CanvasRenderingContext2D.createRadialGradient().
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasGradient
+ */
+export default interface ICanvasGradient {
+	addColorStop(offset: number, color: string): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasPattern.ts

@@ -0,0 +1,10 @@
+import type DOMMatrix from '../dom/dom-matrix/DOMMatrix.js';
+
+/**
+ * The CanvasPattern interface represents an opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasPattern
+ */
+export default interface ICanvasPattern {
+	setTransform(transform?: DOMMatrix): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasRenderingContext2D.ts

@@ -0,0 +1,162 @@
+import type DOMMatrix from '../dom/dom-matrix/DOMMatrix.js';
+import type ICanvasGradient from './ICanvasGradient.js';
+import type ICanvasPattern from './ICanvasPattern.js';
+import type ImageData from './ImageData.js';
+import type ITextMetrics from './ITextMetrics.js';
+import type { TCanvasImage } from './TCanvasImage.js';
+
+type TCanvasFillRule = 'evenodd' | 'nonzero';
+type TGlobalCompositeOperation =
+	| 'clear'
+	| 'copy'
+	| 'destination'
+	| 'source-over'
+	| 'destination-over'
+	| 'source-in'
+	| 'destination-in'
+	| 'source-out'
+	| 'destination-out'
+	| 'source-atop'
+	| 'destination-atop'
+	| 'xor'
+	| 'lighter'
+	| 'normal'
+	| 'multiply'
+	| 'screen'
+	| 'overlay'
+	| 'darken'
+	| 'lighten'
+	| 'color-dodge'
+	| 'color-burn'
+	| 'hard-light'
+	| 'soft-light'
+	| 'difference'
+	| 'exclusion'
+	| 'hue'
+	| 'saturation'
+	| 'color'
+	| 'luminosity'
+	| 'saturate';
+
+type TCanvasLineCap = 'butt' | 'round' | 'square';
+type TCanvasLineJoin = 'bevel' | 'miter' | 'round';
+type TCanvasTextBaseline = 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top';
+type TCanvasTextAlign = 'center' | 'end' | 'left' | 'right' | 'start';
+
+/**
+ * The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a <canvas> element.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D
+ */
+export default interface ICanvasRenderingContext2D {
+	imageSmoothingEnabled: boolean;
+	globalCompositeOperation: TGlobalCompositeOperation;
+	globalAlpha: number;
+	shadowColor: string;
+	miterLimit: number;
+	lineWidth: number;
+	lineCap: TCanvasLineCap;
+	lineJoin: TCanvasLineJoin;
+	lineDashOffset: number;
+	shadowOffsetX: number;
+	shadowOffsetY: number;
+	shadowBlur: number;
+	fillStyle: string | ICanvasGradient | ICanvasPattern;
+	strokeStyle: string | ICanvasGradient | ICanvasPattern;
+	font: string;
+	textBaseline: TCanvasTextBaseline;
+	textAlign: TCanvasTextAlign;
+	canvas: TCanvasImage;
+	direction: 'ltr' | 'rtl';
+	lang: string;
+	drawImage(image: TCanvasImage, dx: number, dy: number): void;
+	drawImage(image: TCanvasImage, dx: number, dy: number, dw: number, dh: number): void;
+	drawImage(
+		image: TCanvasImage,
+		sx: number,
+		sy: number,
+		sw: number,
+		sh: number,
+		dx: number,
+		dy: number,
+		dw: number,
+		dh: number
+	): void;
+	putImageData(imagedata: ImageData, dx: number, dy: number): void;
+	putImageData(
+		imagedata: ImageData,
+		dx: number,
+		dy: number,
+		dirtyX: number,
+		dirtyY: number,
+		dirtyWidth: number,
+		dirtyHeight: number
+	): void;
+	getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+	createImageData(sw: number, sh: number): ImageData;
+	createImageData(imagedata: ImageData): ImageData;
+	save(): void;
+	restore(): void;
+	rotate(angle: number): void;
+	translate(x: number, y: number): void;
+	transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+	getTransform(): DOMMatrix;
+	resetTransform(): void;
+	setTransform(transform?: DOMMatrix): void;
+	setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+	isPointInPath(x: number, y: number, fillRule?: TCanvasFillRule): boolean;
+	scale(x: number, y: number): void;
+	clip(fillRule?: TCanvasFillRule): void;
+	fill(fillRule?: TCanvasFillRule): void;
+	stroke(): void;
+	fillText(text: string, x: number, y: number, maxWidth?: number): void;
+	strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+	fillRect(x: number, y: number, w: number, h: number): void;
+	strokeRect(x: number, y: number, w: number, h: number): void;
+	clearRect(x: number, y: number, w: number, h: number): void;
+	rect(x: number, y: number, w: number, h: number): void;
+	roundRect(x: number, y: number, w: number, h: number, radii?: number | number[]): void;
+	measureText(text: string): ITextMetrics;
+	moveTo(x: number, y: number): void;
+	lineTo(x: number, y: number): void;
+	bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+	quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+	beginPath(): void;
+	closePath(): void;
+	arc(
+		x: number,
+		y: number,
+		radius: number,
+		startAngle: number,
+		endAngle: number,
+		counterclockwise?: boolean
+	): void;
+	arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+	ellipse(
+		x: number,
+		y: number,
+		radiusX: number,
+		radiusY: number,
+		rotation: number,
+		startAngle: number,
+		endAngle: number,
+		counterclockwise?: boolean
+	): void;
+	setLineDash(segments: number[]): void;
+	getLineDash(): number[];
+	createPattern(
+		image: TCanvasImage,
+		repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | '' | null
+	): ICanvasPattern;
+	createLinearGradient(x0: number, y0: number, x1: number, y1: number): ICanvasGradient;
+	createRadialGradient(
+		x0: number,
+		y0: number,
+		r0: number,
+		x1: number,
+		y1: number,
+		r1: number
+	): ICanvasGradient;
+	beginTag(tagName: string, attributes?: string): void;
+	endTag(tagName: string): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ICanvasShape.ts

@@ -0,0 +1,7 @@
+/**
+ * Interface representing a canvas.
+ */
+export default interface ICanvasShape {
+	width: number;
+	height: number;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/IImageBitmapOptions.ts

@@ -0,0 +1,8 @@
+export default interface IImageBitmapOptions {
+	imageOrientation?: 'from-image' | 'flipY' | 'none';
+	premultiplyAlpha?: 'none' | 'premultiply' | 'default';
+	colorSpaceConversion?: 'default' | 'none';
+	resizeWidth?: number;
+	resizeHeight?: number;
+	resizeQuality?: 'pixelated' | 'low' | 'medium' | 'high';
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ITextMetrics.ts

@@ -0,0 +1,12 @@
+export default interface ITextMetrics {
+	readonly alphabeticBaseline: number;
+	readonly actualBoundingBoxAscent: number;
+	readonly actualBoundingBoxDescent: number;
+	readonly actualBoundingBoxLeft: number;
+	readonly actualBoundingBoxRight: number;
+	readonly emHeightAscent: number;
+	readonly emHeightDescent: number;
+	readonly fontBoundingBoxAscent: number;
+	readonly fontBoundingBoxDescent: number;
+	readonly width: number;
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ImageBitmap.ts

@@ -0,0 +1,162 @@
+import HTMLCanvasElement from '../nodes/html-canvas-element/HTMLCanvasElement.js';
+import HTMLImageElement from '../nodes/html-image-element/HTMLImageElement.js';
+import HTMLVideoElement from '../nodes/html-video-element/HTMLVideoElement.js';
+import OffscreenCanvas from './OffscreenCanvas.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+import type IImageBitmapOptions from './IImageBitmapOptions.js';
+import type { TImageBitmapSource } from './TImageBitmapSource.js';
+import type ICanvasShape from './ICanvasShape.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+
+/**
+ * Image Bitmap.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap
+ */
+export default class ImageBitmap implements ICanvasShape {
+	public [PropertySymbol.canvas]: OffscreenCanvas | null = null;
+	public [PropertySymbol.width] = 0;
+	public [PropertySymbol.height] = 0;
+	public [PropertySymbol.options]: IImageBitmapOptions | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol
+	 * @param window Window.
+	 * @param source Source.
+	 * @param [sx] X.
+	 * @param [sy] Y.
+	 * @param [sw] Width.
+	 * @param [sh] Height.
+	 * @param [options] Options.
+	 */
+	constructor(
+		illegalConstructorSymbol: symbol,
+		window: BrowserWindow,
+		source: TImageBitmapSource,
+		sx?: number | IImageBitmapOptions,
+		sy?: number,
+		sw?: number | IImageBitmapOptions,
+		sh?: number,
+		options?: IImageBitmapOptions
+	) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		let validSource: TImageBitmapSource | null = null;
+		if (source instanceof ImageBitmap) {
+			if (source[PropertySymbol.canvas] === null) {
+				throw new window.DOMException(
+					"Failed to execute 'createImageBitmap' on 'Window': The image source is not usable.",
+					DOMExceptionNameEnum.invalidStateError
+				);
+			}
+			validSource = source;
+		}
+
+		if (source instanceof HTMLImageElement) {
+			if (!source[PropertySymbol.buffer]) {
+				throw new window.DOMException(
+					"Failed to execute 'createImageBitmap' on 'Window': The image source is not usable.",
+					DOMExceptionNameEnum.invalidStateError
+				);
+			}
+			validSource = source;
+		} else if (source instanceof HTMLVideoElement) {
+			throw new window.DOMException(
+				"Failed to execute 'createImageBitmap' on 'Window': HTMLVideoElement is not supported as an image source yet in Happy DOM.",
+				DOMExceptionNameEnum.invalidStateError
+			);
+		} else if (source instanceof HTMLCanvasElement || source instanceof OffscreenCanvas) {
+			validSource = source;
+		}
+
+		if (validSource === null) {
+			throw new window.TypeError(
+				`Failed to execute 'createImageBitmap' on 'Window': The provided value is not of type '(Blob or HTMLCanvasElement or HTMLImageElement or HTMLVideoElement or ImageBitmap or ImageData or OffscreenCanvas or SVGImageElement or VideoFrame)'.`
+			);
+		}
+
+		this[PropertySymbol.width] = validSource.width;
+		this[PropertySymbol.height] = validSource.height;
+
+		let x = 0;
+		let y = 0;
+
+		if (
+			typeof sx === 'number' &&
+			typeof sy === 'number' &&
+			typeof sw === 'number' &&
+			typeof sh === 'number'
+		) {
+			x = sx;
+			y = sy;
+			this[PropertySymbol.width] = sw;
+			this[PropertySymbol.height] = sh;
+
+			if (options !== undefined && typeof options !== 'object') {
+				throw new window.TypeError(`The provided value is not of type 'ImageBitmapOptions'.`);
+			}
+
+			this[PropertySymbol.options] = options || null;
+		} else if (typeof sx === 'number' && typeof sy === 'number') {
+			this[PropertySymbol.width] = sx;
+			this[PropertySymbol.height] = sy;
+
+			if (sw !== undefined && typeof sw !== 'object') {
+				throw new window.TypeError(`The provided value is not of type 'ImageBitmapOptions'.`);
+			}
+
+			this[PropertySymbol.options] = sw || null;
+		} else if (typeof sx === 'object') {
+			this[PropertySymbol.options] = sx;
+		} else if (sx !== undefined) {
+			throw new window.TypeError(
+				`Failed to execute 'createImageBitmap' on 'Window': Overload resolution failed.`
+			);
+		}
+
+		const settings = new WindowBrowserContext(window).getSettings();
+		const canvas = new window.OffscreenCanvas(
+			this[PropertySymbol.width],
+			this[PropertySymbol.height]
+		);
+		if (settings?.canvasAdapter) {
+			const context = canvas.getContext('2d')!;
+			context.drawImage(validSource, -x, -y, validSource.width, validSource.height);
+			this[PropertySymbol.canvas] = canvas;
+		}
+	}
+
+	/**
+	 * Returns width.
+	 *
+	 * @returns Width.
+	 */
+	public get width(): number {
+		return this[PropertySymbol.width];
+	}
+
+	/**
+	 * Returns height.
+	 *
+	 * @returns Height.
+	 */
+	public get height(): number {
+		return this[PropertySymbol.height];
+	}
+
+	/**
+	 * Disposes of all graphical resources associated with an ImageBitmap.
+	 */
+	public close(): void {
+		this[PropertySymbol.canvas] = null;
+		this[PropertySymbol.options] = null;
+		this[PropertySymbol.width] = 0;
+		this[PropertySymbol.height] = 0;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/canvas/ImageData.ts

@@ -0,0 +1,83 @@
+import * as PropertySymbol from '../PropertySymbol.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type ICanvasShape from './ICanvasShape.js';
+
+/**
+ * The ImageData interface represents the underlying pixel data of an area of a <canvas> element.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ImageData
+ */
+export default class ImageData implements ICanvasShape {
+	// Injected by WindowContextClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
+
+	public readonly [PropertySymbol.data]: Uint8ClampedArray;
+	public readonly [PropertySymbol.width]: number;
+	public readonly [PropertySymbol.height]: number;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param dataArray A Uint8ClampedArray containing the underlying pixel representation of the image.
+	 * @param width The width of the ImageData, in pixels.
+	 * @param height The height of the ImageData, in pixels. If not specified, it is calculated as `dataArray.length / (sw * 4)`.
+	 */
+	constructor(dataArray: Uint8ClampedArray | number, width: number, height?: number) {
+		if (arguments.length < 2) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to construct 'ImageData': 2 arguments required, but only ${arguments.length} present.`
+			);
+		}
+		if (dataArray instanceof Uint8ClampedArray) {
+			if (typeof width !== 'number') {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to construct 'ImageData': The width argument must be a number.`
+				);
+			}
+			if (height !== undefined && typeof height !== 'number') {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to construct 'ImageData': The height argument must be a number.`
+				);
+			}
+			this[PropertySymbol.data] = dataArray;
+			this[PropertySymbol.width] = width;
+			this[PropertySymbol.height] = height !== undefined ? height : dataArray.length / (width * 4);
+		} else {
+			if (typeof width !== 'number') {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to construct 'ImageData': The height argument must be a number.`
+				);
+			}
+			this[PropertySymbol.data] = new Uint8ClampedArray(new Array(dataArray * width * 4).fill(0));
+			this[PropertySymbol.width] = dataArray;
+			this[PropertySymbol.height] = width;
+		}
+	}
+
+	/**
+	 * Returns data.
+	 *
+	 * @returns Data.
+	 */
+	public get data(): Uint8ClampedArray {
+		return this[PropertySymbol.data];
+	}
+
+	/**
+	 * Returns width.
+	 *
+	 * @returns Width.
+	 */
+	public get width(): number {
+		return this[PropertySymbol.width];
+	}
+
+	/**
+	 * Returns height.
+	 *
+	 * @returns Height.
+	 */
+	public get height(): number {
+		return this[PropertySymbol.height];
+	}
+}