buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/cookie/CookieContainer.ts

@@ -0,0 +1,91 @@
+import type URL from '../url/URL.js';
+import DefaultCookie from './DefaultCookie.js';
+import type ICookie from './ICookie.js';
+import type ICookieContainer from './ICookieContainer.js';
+import type IOptionalCookie from './IOptionalCookie.js';
+import CookieExpireUtility from './urilities/CookieExpireUtility.js';
+import CookieURLUtility from './urilities/CookieURLUtility.js';
+
+/**
+ * Cookie Container.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie.
+ */
+export default class CookieContainer implements ICookieContainer {
+	#cookies: ICookie[] = [];
+
+	/**
+	 * Adds or replaces cookies.
+	 *
+	 * @param cookies Cookies.
+	 * @returns Changed cookies.
+	 */
+	public addCookies(cookies: IOptionalCookie[]): { changed: ICookie[]; deleted: ICookie[] } {
+		const changedCookies: { changed: ICookie[]; deleted: ICookie[] } = {
+			changed: [],
+			deleted: []
+		};
+		const allCookies = this.#cookies;
+		for (const cookie of cookies) {
+			const newCookie = Object.assign({}, DefaultCookie, cookie);
+
+			if (newCookie && newCookie.key && newCookie.originURL) {
+				const hasExpired = CookieExpireUtility.hasExpired(newCookie);
+
+				// Checks if the cookie already exists and removes it.
+				for (let i = 0, max = allCookies.length; i < max; i++) {
+					const existingCookie = allCookies[i];
+					if (
+						existingCookie.key === newCookie.key &&
+						existingCookie.originURL.hostname === newCookie.originURL.hostname &&
+						existingCookie.path === newCookie.path &&
+						typeof existingCookie.value === typeof newCookie.value
+					) {
+						if (hasExpired) {
+							changedCookies.deleted.push(existingCookie);
+						}
+						allCookies.splice(i, 1);
+						break;
+					}
+				}
+
+				if (!hasExpired) {
+					allCookies.push(newCookie);
+					changedCookies.changed.push(newCookie);
+				}
+			}
+		}
+		return changedCookies;
+	}
+
+	/**
+	 * Returns cookies.
+	 *
+	 * @param [url] URL.
+	 * @param [clientSide] "true" if "httpOnly" cookies should be filtered out.
+	 * @returns Cookies.
+	 */
+	public getCookies(url: URL | null = null, clientSide = false): ICookie[] {
+		const cookies = [];
+
+		for (const cookie of this.#cookies) {
+			if (
+				!CookieExpireUtility.hasExpired(cookie) &&
+				(!clientSide || !cookie.httpOnly) &&
+				(!url || CookieURLUtility.cookieMatchesURL(cookie, url))
+			) {
+				cookies.push(cookie);
+			}
+		}
+
+		return cookies;
+	}
+
+	/**
+	 * Clears all cookies.
+	 */
+	public clearCookies(): void {
+		this.#cookies = [];
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/DefaultCookie.ts

@@ -0,0 +1,17 @@
+import CookieSameSiteEnum from './enums/CookieSameSiteEnum.js';
+import type ICookie from './ICookie.js';
+
+export default <ICookie>{
+	// Required
+	key: null!,
+	originURL: null!,
+
+	// Optional
+	value: null,
+	domain: '',
+	path: '',
+	expires: null,
+	httpOnly: false,
+	secure: false,
+	sameSite: CookieSameSiteEnum.lax
+};

package/vendor/happy-dom/packages/happy-dom/src/cookie/ICookie.ts

@@ -0,0 +1,14 @@
+import type CookieSameSiteEnum from './enums/CookieSameSiteEnum.js';
+
+export default interface ICookie {
+	// Required
+	key: string;
+	originURL: URL;
+	value: string | null;
+	domain: string;
+	path: string;
+	expires: Date | null;
+	httpOnly: boolean;
+	secure: boolean;
+	sameSite: CookieSameSiteEnum;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/ICookieContainer.ts

@@ -0,0 +1,33 @@
+import type URL from '../url/URL.js';
+import type ICookie from './ICookie.js';
+import type IOptionalCookie from './IOptionalCookie.js';
+
+/**
+ * Cookie Container.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie.
+ */
+export default interface ICookieContainer {
+	/**
+	 * Adds or replaces cookies.
+	 *
+	 * @param cookies Cookies.
+	 * @returns Changed cookies.
+	 */
+	addCookies(cookies: IOptionalCookie[]): { changed: ICookie[]; deleted: ICookie[] };
+
+	/**
+	 * Returns cookies.
+	 *
+	 * @param [url] URL.
+	 * @param [clientSide] "true" if "httpOnly" cookies should be filtered out.
+	 * @returns Cookies.
+	 */
+	getCookies(url?: URL | null, clientSide?: boolean): ICookie[];
+
+	/**
+	 * Clears all cookies.
+	 */
+	clearCookies(): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/IOptionalCookie.ts

@@ -0,0 +1,16 @@
+import type CookieSameSiteEnum from './enums/CookieSameSiteEnum.js';
+
+export default interface IOptionalCookie {
+	// Required
+	key: string;
+	originURL: URL;
+
+	// Optional
+	value?: string | null;
+	domain?: string;
+	path?: string;
+	expires?: Date | null;
+	httpOnly?: boolean;
+	secure?: boolean;
+	sameSite?: CookieSameSiteEnum;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/enums/CookieSameSiteEnum.ts

@@ -0,0 +1,6 @@
+enum CookieSameSiteEnum {
+	strict = 'Strict',
+	lax = 'Lax',
+	none = 'None'
+}
+export default CookieSameSiteEnum;

package/vendor/happy-dom/packages/happy-dom/src/cookie/urilities/CookieExpireUtility.ts

@@ -0,0 +1,16 @@
+import type ICookie from '../ICookie.js';
+
+/**
+ * Cookie expire utility.
+ */
+export default class CookieExpireUtility {
+	/**
+	 * Returns "true" if cookie has expired.
+	 *
+	 * @param cookie Cookie.
+	 * @returns "true" if cookie has expired.
+	 */
+	public static hasExpired(cookie: ICookie): boolean | null {
+		return cookie.expires && cookie.expires.getTime() < Date.now();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/urilities/CookieStringUtility.ts

@@ -0,0 +1,119 @@
+import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
+import type URL from '../../url/URL.js';
+import type ICookie from '../ICookie.js';
+import DefaultCookie from '../DefaultCookie.js';
+import type Location from '../../location/Location.js';
+
+/**
+ * Cookie string.
+ */
+export default class CookieStringUtility {
+	/**
+	 * Returns cookie.
+	 *
+	 * @param originURL Origin URL.
+	 * @param cookieString Cookie string.
+	 * @returns Cookie.
+	 */
+	public static stringToCookie(originURL: URL | Location, cookieString: string): ICookie | null {
+		const parts = cookieString.split(';');
+		const part = parts.shift();
+
+		if (!part) {
+			return null;
+		}
+
+		const index = part.indexOf('=');
+		const key = index !== -1 ? part.slice(0, index).trim() : part.trim();
+		const value = index !== -1 ? part.slice(index + 1).trim() : null;
+
+		const cookie: ICookie = Object.assign({}, DefaultCookie, {
+			// Required
+			key,
+			value,
+			originURL
+		});
+
+		// Invalid if key is empty.
+		if (!cookie.key) {
+			return null;
+		}
+
+		for (const part of parts) {
+			const index = part.indexOf('=');
+			const key =
+				index !== -1 ? part.slice(0, index).trim().toLowerCase() : part.trim().toLowerCase();
+			const value = index !== -1 ? part.slice(index + 1).trim() : '';
+
+			switch (key) {
+				case 'expires':
+					cookie.expires = new Date(value);
+					break;
+				case 'max-age':
+					cookie.expires = new Date(parseInt(value, 10) * 1000 + Date.now());
+					break;
+				case 'domain':
+					cookie.domain = value;
+					break;
+				case 'path':
+					cookie.path = value[0] === '/' ? value : `/${value}`;
+					break;
+				case 'httponly':
+					cookie.httpOnly = true;
+					break;
+				case 'secure':
+					cookie.secure = true;
+					break;
+				case 'samesite':
+					switch (value.toLowerCase()) {
+						case 'strict':
+							cookie.sameSite = CookieSameSiteEnum.strict;
+							break;
+						case 'lax':
+							cookie.sameSite = CookieSameSiteEnum.lax;
+							break;
+						case 'none':
+							cookie.sameSite = CookieSameSiteEnum.none;
+					}
+					break;
+			}
+		}
+
+		const lowerKey = cookie.key.toLowerCase();
+
+		// Invalid if __secure- prefix is used and cookie is not secure.
+		if (lowerKey.startsWith('__secure-') && !cookie.secure) {
+			return null;
+		}
+
+		// Invalid if __host- prefix is used and cookie is not secure, not on root path or has a domain.
+		if (
+			lowerKey.startsWith('__host-') &&
+			(!cookie.secure || cookie.path !== '/' || cookie.domain)
+		) {
+			return null;
+		}
+
+		return cookie;
+	}
+
+	/**
+	 * Returns cookie string with key and value.
+	 *
+	 * @param cookies Cookies.
+	 * @returns Cookie string.
+	 */
+	public static cookiesToString(cookies: ICookie[]): string {
+		const cookieString: string[] = [];
+
+		for (const cookie of cookies) {
+			if (cookie.value !== null) {
+				cookieString.push(`${cookie.key}=${cookie.value}`);
+			} else {
+				cookieString.push(cookie.key);
+			}
+		}
+
+		return cookieString.join('; ');
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie/urilities/CookieURLUtility.ts

@@ -0,0 +1,27 @@
+import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
+import type URL from '../../url/URL.js';
+import type ICookie from '../ICookie.js';
+
+/**
+ * Cookie string.
+ */
+export default class CookieURLUtility {
+	/**
+	 * Returns "true" if cookie matches URL.
+	 *
+	 * @param cookie Cookie.
+	 * @param url URL.
+	 * @returns "true" if cookie matches URL.
+	 */
+	public static cookieMatchesURL(cookie: ICookie, url: URL): boolean {
+		const isLocalhost = url.hostname === 'localhost' || url.hostname?.endsWith('.localhost');
+		return (
+			(!cookie.secure || url.protocol === 'https:' || isLocalhost) &&
+			(!cookie.domain || url.hostname?.endsWith(cookie.domain)) &&
+			(!cookie.path || url.pathname?.startsWith(cookie.path)) &&
+			// @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value
+			((cookie.sameSite === CookieSameSiteEnum.none && cookie.secure) ||
+				cookie.originURL?.hostname === url.hostname)
+		);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie-store/CookieStore.ts

@@ -0,0 +1,226 @@
+import EventTarget from '../event/EventTarget.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type ICookieStoreGetOptions from './ICookieStoreGetOptions.js';
+import type ICookieStoreSetOptions from './ICookieStoreSetOptions.js';
+import type ICookieStoreDeleteOptions from './ICookieStoreDeleteOptions.js';
+import type ICookieStoreItem from './ICookieStoreItem.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+import CookieSameSiteEnum from '../cookie/enums/CookieSameSiteEnum.js';
+import CookieChangeEvent from '../event/events/CookieChangeEvent.js';
+import type ICookie from '../cookie/ICookie.js';
+import URL from '../url/URL.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+
+/**
+ * CookieStore.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CookieStore
+ */
+export default class CookieStore extends EventTarget {
+	// Internal properties
+	readonly #window: BrowserWindow;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol Illegal constructor symbol.
+	 * @param window Window.
+	 */
+	constructor(illegalConstructorSymbol: symbol, window: BrowserWindow) {
+		super();
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+		this.#window = window;
+	}
+
+	/**
+	 * Returns a cookie.
+	 *
+	 * @param [nameOrOptions] Name or options.
+	 * @returns Cookie.
+	 */
+	public async get(
+		nameOrOptions?: string | ICookieStoreGetOptions
+	): Promise<ICookieStoreItem | null> {
+		const cookies = await this.getAll(nameOrOptions);
+		return cookies.length > 0 ? cookies[0] : null;
+	}
+
+	/**
+	 * Returns all cookies.
+	 *
+	 * @param [nameOrOptions] Name or options.
+	 * @returns Cookies.
+	 */
+	public async getAll(
+		nameOrOptions?: string | ICookieStoreGetOptions
+	): Promise<ICookieStoreItem[]> {
+		const browserFrame = new WindowBrowserContext(this.#window).getBrowserFrame();
+		if (!browserFrame) {
+			return [];
+		}
+
+		const options: ICookieStoreGetOptions =
+			typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions || {};
+
+		let targetURL: URL;
+		if (options.url) {
+			targetURL = new URL(options.url, this.#window.location.href);
+			// In a document context, only the current URL is valid
+			if (targetURL.origin !== this.#window.location.origin) {
+				throw new this.#window.DOMException(
+					`Failed to execute 'getAll' on 'CookieStore': URL must match the document origin`,
+					DOMExceptionNameEnum.securityError
+				);
+			}
+		} else {
+			targetURL = <URL>(<unknown>this.#window.location);
+		}
+
+		const internalCookies = browserFrame.page.context.cookieContainer.getCookies(targetURL, true);
+		const result: ICookieStoreItem[] = [];
+
+		for (const cookie of internalCookies) {
+			if (!options.name || cookie.key === options.name) {
+				result.push(this.#convertToStoreItem(cookie));
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Sets a cookie.
+	 *
+	 * @param nameOrOptions Name or options.
+	 * @param [value] Value.
+	 * @returns Promise.
+	 */
+	public async set(nameOrOptions: string | ICookieStoreSetOptions, value?: string): Promise<void> {
+		const browserFrame = new WindowBrowserContext(this.#window).getBrowserFrame();
+		if (!browserFrame) {
+			return;
+		}
+
+		let options: ICookieStoreSetOptions;
+		if (typeof nameOrOptions === 'string') {
+			if (value === undefined) {
+				throw new this.#window.TypeError(
+					`Failed to execute 'set' on 'CookieStore': Value is required when name is provided as a string.`
+				);
+			}
+			options = { name: nameOrOptions, value };
+		} else {
+			options = { ...nameOrOptions, value: nameOrOptions.value ?? '' };
+		}
+
+		if (!options.name) {
+			throw new this.#window.TypeError(
+				`Failed to execute 'set' on 'CookieStore': Required member name is undefined.`
+			);
+		}
+
+		const originURL = <URL>(<unknown>this.#window.location);
+
+		// Convert expires to Date if it's a number (Unix timestamp in milliseconds)
+		let expires: Date | null = null;
+		if (options.expires !== undefined && options.expires !== null) {
+			expires = options.expires instanceof Date ? options.expires : new Date(options.expires);
+		}
+
+		// Convert sameSite string to enum
+		let sameSite = CookieSameSiteEnum.strict;
+		if (options.sameSite) {
+			switch (options.sameSite.toLowerCase()) {
+				case 'strict':
+					sameSite = CookieSameSiteEnum.strict;
+					break;
+				case 'lax':
+					sameSite = CookieSameSiteEnum.lax;
+					break;
+				case 'none':
+					sameSite = CookieSameSiteEnum.none;
+					break;
+			}
+		}
+
+		const cookie: ICookie = {
+			key: options.name,
+			value: options.value ?? '',
+			originURL,
+			domain: options.domain || '',
+			path: options.path || '/',
+			expires,
+			httpOnly: false, // CookieStore API cannot set httpOnly cookies
+			secure: true,
+			sameSite
+		};
+
+		const cookieContainer = browserFrame.page.context.cookieContainer;
+		const changedCookies = cookieContainer.addCookies([cookie]);
+
+		if (changedCookies.changed.length > 0 || changedCookies.deleted.length > 0) {
+			this.dispatchEvent(
+				new CookieChangeEvent('change', {
+					changed: changedCookies.changed.map((cookie) => this.#convertToStoreItem(cookie)),
+					deleted: changedCookies.deleted.map((cookie) => this.#convertToStoreItem(cookie))
+				})
+			);
+		}
+	}
+
+	/**
+	 * Deletes a cookie.
+	 *
+	 * @param nameOrOptions Name or options.
+	 * @returns Promise.
+	 */
+	public async delete(nameOrOptions: string | ICookieStoreDeleteOptions): Promise<void> {
+		const options: ICookieStoreDeleteOptions =
+			typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
+
+		// Set the cookie with an expired date to delete it
+		await this.set({
+			name: options.name,
+			value: '',
+			domain: options.domain ?? undefined,
+			path: options.path,
+			partitioned: options.partitioned,
+			expires: new Date(0)
+		});
+	}
+
+	/**
+	 * Converts an internal cookie to a CookieStore item.
+	 *
+	 * @param cookie Internal cookie.
+	 * @returns CookieStore item.
+	 */
+	#convertToStoreItem(cookie: ICookie): ICookieStoreItem {
+		let sameSite: 'strict' | 'lax' | 'none' = 'lax';
+		switch (cookie.sameSite) {
+			case CookieSameSiteEnum.strict:
+				sameSite = 'strict';
+				break;
+			case CookieSameSiteEnum.lax:
+				sameSite = 'lax';
+				break;
+			case CookieSameSiteEnum.none:
+				sameSite = 'none';
+				break;
+		}
+
+		return {
+			name: cookie.key,
+			value: cookie.value ?? '',
+			domain: cookie.domain,
+			path: cookie.path,
+			expires: cookie.expires ? cookie.expires.getTime() : null,
+			secure: cookie.secure,
+			sameSite,
+			partitioned: false // Not supported yet
+		};
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie-store/ICookieStoreDeleteOptions.ts

@@ -0,0 +1,9 @@
+/**
+ * Options for CookieStore.delete().
+ */
+export default interface ICookieStoreDeleteOptions {
+	name: string;
+	domain?: string | null;
+	path?: string;
+	partitioned?: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie-store/ICookieStoreGetOptions.ts

@@ -0,0 +1,7 @@
+/**
+ * Options for CookieStore.get() and CookieStore.getAll().
+ */
+export default interface ICookieStoreGetOptions {
+	name?: string;
+	url?: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie-store/ICookieStoreItem.ts

@@ -0,0 +1,13 @@
+/**
+ * Cookie item returned by CookieStore.get() and CookieStore.getAll().
+ */
+export default interface ICookieStoreItem {
+	name: string;
+	value: string;
+	domain: string;
+	path: string;
+	expires: number | null;
+	secure: boolean;
+	sameSite: 'strict' | 'lax' | 'none';
+	partitioned: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/cookie-store/ICookieStoreSetOptions.ts

@@ -0,0 +1,12 @@
+/**
+ * Options for CookieStore.set().
+ */
+export default interface ICookieStoreSetOptions {
+	name: string;
+	value?: string;
+	domain?: string | null;
+	expires?: number | Date | null;
+	path?: string;
+	sameSite?: 'strict' | 'lax' | 'none';
+	partitioned?: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/css/CSS.ts

@@ -0,0 +1,63 @@
+import CSSEscaper from './utilities/CSSEscaper.js';
+import CSSUnitValue from './CSSUnitValue.js';
+
+/**
+ * The CSS interface holds useful CSS-related methods.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/CSS.
+ */
+export default class CSS {
+	public readonly Hz = (value: number): CSSUnitValue => new CSSUnitValue(value, 'Hz');
+	public readonly Q = (value: number): CSSUnitValue => new CSSUnitValue(value, 'Q');
+	public readonly ch = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ch');
+	public readonly cm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'cm');
+	public readonly deg = (value: number): CSSUnitValue => new CSSUnitValue(value, 'deg');
+	public readonly dpcm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dpcm');
+	public readonly dpi = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dpi');
+	public readonly dppx = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dppx');
+	public readonly em = (value: number): CSSUnitValue => new CSSUnitValue(value, 'em');
+	public readonly ex = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ex');
+	public readonly fr = (value: number): CSSUnitValue => new CSSUnitValue(value, 'fr');
+	public readonly grad = (value: number): CSSUnitValue => new CSSUnitValue(value, 'grad');
+	public readonly in = (value: number): CSSUnitValue => new CSSUnitValue(value, 'in');
+	public readonly kHz = (value: number): CSSUnitValue => new CSSUnitValue(value, 'kHz');
+	public readonly mm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'mm');
+	public readonly ms = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ms');
+	public readonly number = (value: number): CSSUnitValue => new CSSUnitValue(value, 'number');
+	public readonly pc = (value: number): CSSUnitValue => new CSSUnitValue(value, 'pc');
+	public readonly percent = (value: number): CSSUnitValue => new CSSUnitValue(value, 'percent');
+	public readonly pt = (value: number): CSSUnitValue => new CSSUnitValue(value, 'pt');
+	public readonly px = (value: number): CSSUnitValue => new CSSUnitValue(value, 'px');
+	public readonly rad = (value: number): CSSUnitValue => new CSSUnitValue(value, 'rad');
+	public readonly rem = (value: number): CSSUnitValue => new CSSUnitValue(value, 'rem');
+	public readonly s = (value: number): CSSUnitValue => new CSSUnitValue(value, 's');
+	public readonly turn = (value: number): CSSUnitValue => new CSSUnitValue(value, 'turn');
+	public readonly vh = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vh');
+	public readonly vmax = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vmax');
+	public readonly vmin = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vmin');
+	public readonly vw = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vw');
+
+	/**
+	 * Returns a Boolean indicating if the pair property-value, or the condition, given in parameter is supported.
+	 *
+	 * TODO: Always returns "true" for now, but it should probably be improved in the future.
+	 *
+	 * @param _condition Property name or condition.
+	 * @param [_value] Value when using property name.
+	 * @returns "true" if supported.
+	 */
+	public supports(_condition: string, _value?: string): boolean {
+		return true;
+	}
+
+	/**
+	 * Escapes a value.
+	 *
+	 * @param value Value to escape.
+	 * @returns Escaped string.
+	 */
+	public escape(value: string): string {
+		return CSSEscaper.escape(value);
+	}
+}