buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/property-manager/types/ICSSPropertyMap.ts

@@ -0,0 +1,5 @@
+import type ICSSPropertyValue from './ICSSPropertyValue.js';
+
+export default interface ICSSPropertyMap {
+	[key: string]: ICSSPropertyValue;
+}

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/property-manager/types/ICSSPropertyValue.ts

@@ -0,0 +1,4 @@
+export default interface ICSSPropertyValue {
+	value: string;
+	important: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/property-manager/utilities/CSSStringUtility.ts

@@ -0,0 +1,90 @@
+const SPLIT_BY_COMMA_REGEXP = /[,()]/gm;
+const SPLIT_BY_SPACE_REGEXP = /[()]|\s+/gm;
+
+/**
+ * Style declaration value parser.
+ */
+export default class CSSStringUtility {
+	/**
+	 * Splits by comma while respecting nested parentheses.
+	 *
+	 * @param value Value to split.
+	 * @returns Array of parts.
+	 */
+	public static splitByComma(value: string): string[] {
+		const parts: string[] = [];
+		const regexp = new RegExp(SPLIT_BY_COMMA_REGEXP);
+		let match: RegExpExecArray | null;
+		let depth = 0;
+		let lastIndex = 0;
+
+		while ((match = regexp.exec(value))) {
+			switch (match[0]) {
+				case '(':
+					depth++;
+					break;
+				case ')':
+					depth--;
+					break;
+				case ',':
+					if (depth === 0) {
+						const part = value.substring(lastIndex, match.index).trim();
+						if (part) {
+							parts.push(part);
+						}
+						lastIndex = regexp.lastIndex;
+					}
+					break;
+			}
+		}
+
+		if (lastIndex < value.length) {
+			parts.push(value.substring(lastIndex).trim());
+		}
+
+		return parts;
+	}
+
+	/**
+	 * Splits by space while respecting nested parentheses.
+	 *
+	 * @param value Value to split.
+	 * @returns Array of parts.
+	 */
+	public static splitBySpace(value: string): string[] {
+		const parts: string[] = [];
+		const regexp = new RegExp(SPLIT_BY_SPACE_REGEXP);
+		let match: RegExpExecArray | null;
+		let depth = 0;
+		let lastIndex = 0;
+
+		while ((match = regexp.exec(value))) {
+			switch (match[0]) {
+				case '(':
+					depth++;
+					break;
+				case ')':
+					depth--;
+					break;
+				default:
+					if (depth === 0) {
+						const part = value.substring(lastIndex, match.index).trim();
+						if (part) {
+							parts.push(part);
+						}
+						lastIndex = regexp.lastIndex;
+					}
+					break;
+			}
+		}
+
+		if (lastIndex < value.length) {
+			const part = value.substring(lastIndex).trim();
+			if (part) {
+				parts.push(part);
+			}
+		}
+
+		return parts;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/property-manager/utilities/CSSValueFormatter.ts

@@ -0,0 +1,447 @@
+import CSSStringUtility from './CSSStringUtility.js';
+
+const COLOR_REGEXP = /^#([0-9a-fA-F]{3,4}){1,2}$|^(rgba?|hsla?)\((.*)\)$/;
+const LENGTH_REGEXP =
+	/^(0|[-+]?[0-9]*\.?[0-9]+)(in|cm|em|mm|pt|pc|px|ex|rem|vh|vw|ch|vw|vh|vmin|vmax|Q)$/;
+const PERCENTAGE_REGEXP = /^[-+]?[0-9]*\.?[0-9]+%$/;
+const DEGREE_REGEXP = /^[0-9]+deg$/;
+const URL_REGEXP = /^url\(\s*([^)]*)\s*\)$/;
+const INTEGER_REGEXP = /^[0-9]+$/;
+const FLOAT_REGEXP = /^[0-9.]+$/;
+const CALC_REGEXP = /^calc\(.+\)$/;
+const FIT_CONTENT_REGEXP = /^fit-content\([^^)]+\)$/;
+const GRADIENT_REGEXP =
+	/^((repeating-linear|linear|radial|repeating-radial|conic|repeating-conic)-gradient)\(((?:[^()]|\([^()]*\))*)\)$/;
+const GLOBALS = ['inherit', 'initial', 'unset', 'revert'];
+const COLORS = [
+	'none',
+	'currentcolor',
+	'transparent',
+	'silver',
+	'gray',
+	'white',
+	'maroon',
+	'red',
+	'purple',
+	'fuchsia',
+	'green',
+	'lime',
+	'olive',
+	'yellow',
+	'navy',
+	'blue',
+	'teal',
+	'aliceblue',
+	'aqua',
+	'antiquewhite',
+	'aquamarine',
+	'azure',
+	'beige',
+	'bisque',
+	'black',
+	'blanchedalmond',
+	'blueviolet',
+	'brown',
+	'burlywood',
+	'cadetblue',
+	'chartreuse',
+	'chocolate',
+	'coral',
+	'cornflowerblue',
+	'cornsilk',
+	'crimson',
+	'cyan',
+	'darkblue',
+	'darkcyan',
+	'darkgoldenrod',
+	'darkgray',
+	'darkgreen',
+	'darkgrey',
+	'darkkhaki',
+	'darkmagenta',
+	'darkolivegreen',
+	'darkorange',
+	'darkorchid',
+	'darkred',
+	'darksalmon',
+	'darkseagreen',
+	'darkslateblue',
+	'darkslategray',
+	'darkslategrey',
+	'darkturquoise',
+	'darkviolet',
+	'deeppink',
+	'deepskyblue',
+	'dimgray',
+	'dimgrey',
+	'dodgerblue',
+	'firebrick',
+	'floralwhite',
+	'forestgreen',
+	'gainsboro',
+	'ghostwhite',
+	'gold',
+	'goldenrod',
+	'greenyellow',
+	'grey',
+	'honeydew',
+	'hotpink',
+	'indianred',
+	'indigo',
+	'ivory',
+	'khaki',
+	'lavender',
+	'lavenderblush',
+	'lawngreen',
+	'lemonchiffon',
+	'lightblue',
+	'lightcoral',
+	'lightcyan',
+	'lightgoldenrodyellow',
+	'lightgray',
+	'lightgreen',
+	'lightgrey',
+	'lightpink',
+	'lightsalmon',
+	'lightseagreen',
+	'lightskyblue',
+	'lightslategray',
+	'lightslategrey',
+	'lightsteelblue',
+	'lightyellow',
+	'limegreen',
+	'linen',
+	'magenta',
+	'mediumaquamarine',
+	'mediumblue',
+	'mediumorchid',
+	'mediumpurple',
+	'mediumseagreen',
+	'mediumslateblue',
+	'mediumspringgreen',
+	'mediumturquoise',
+	'mediumvioletred',
+	'midnightblue',
+	'mintcream',
+	'mistyrose',
+	'moccasin',
+	'navajowhite',
+	'oldlace',
+	'olivedrab',
+	'orange',
+	'orangered',
+	'orchid',
+	'palegoldenrod',
+	'palegreen',
+	'paleturquoise',
+	'palevioletred',
+	'papayawhip',
+	'peachpuff',
+	'peru',
+	'pink',
+	'plum',
+	'powderblue',
+	'rebeccapurple',
+	'rosybrown',
+	'royalblue',
+	'saddlebrown',
+	'salmon',
+	'sandybrown',
+	'seagreen',
+	'seashell',
+	'sienna',
+	'skyblue',
+	'slateblue',
+	'slategray',
+	'slategrey',
+	'snow',
+	'springgreen',
+	'steelblue',
+	'tan',
+	'thistle',
+	'tomato',
+	'turquoise',
+	'violet',
+	'wheat',
+	'whitesmoke',
+	'yellowgreen'
+];
+
+/**
+ * Style declaration value parser.
+ */
+export default class CSSValueFormatter {
+	/**
+	 * Returns length.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getLength(value: string): string | null {
+		if (value === '0') {
+			return '0px';
+		}
+		const match = value.match(LENGTH_REGEXP);
+		if (match) {
+			const number = parseFloat(match[1]);
+			if (isNaN(number)) {
+				return null;
+			}
+			const unit = match[2];
+			return `${Math.round(number * 1000000) / 1000000}${unit}`;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns percentance.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getPercentage(value: string): string | null {
+		if (value === '0') {
+			return '0%';
+		}
+		if (PERCENTAGE_REGEXP.test(value)) {
+			return value;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns degree.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getDegree(value: string): string | null {
+		if (value === '0') {
+			return '0deg';
+		}
+		if (DEGREE_REGEXP.test(value)) {
+			return value;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns calc.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getCalc(value: string): string | null {
+		if (CALC_REGEXP.test(value)) {
+			return value;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns fit content.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getFitContent(value: string): string | null {
+		const lowerValue = value.toLowerCase();
+		if (
+			lowerValue === 'auto' ||
+			lowerValue === 'max-content' ||
+			lowerValue === 'min-content' ||
+			lowerValue === 'fit-content'
+		) {
+			return lowerValue;
+		}
+		if (FIT_CONTENT_REGEXP.test(lowerValue)) {
+			return lowerValue;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns measurement.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getMeasurement(value: string): string | null {
+		return this.getLength(value) || this.getPercentage(value) || this.getCalc(value);
+	}
+
+	/**
+	 * Returns measurement or auto, min-content, max-content or fit-content.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getContentMeasurement(value: string): string | null {
+		return this.getFitContent(value) || this.getMeasurement(value);
+	}
+
+	/**
+	 * Returns measurement or auto, min-content, max-content or fit-content.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getAutoMeasurement(value: string): string | null {
+		if (value.toLocaleLowerCase() === 'auto') {
+			return 'auto';
+		}
+		return this.getMeasurement(value);
+	}
+
+	/**
+	 * Returns integer.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getInteger(value: string): string | null {
+		if (INTEGER_REGEXP.test(value)) {
+			return value;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns float.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getFloat(value: string): string | null {
+		if (FLOAT_REGEXP.test(value)) {
+			const number = parseFloat(value);
+			if (isNaN(number)) {
+				return null;
+			}
+			return String(Math.round(number * 1000000) / 1000000);
+		}
+		return null;
+	}
+
+	/**
+	 * Returns gradient.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getGradient(value: string): string | null {
+		const match = value.match(GRADIENT_REGEXP);
+		if (match) {
+			const args = match[3].trim();
+			const parts = CSSStringUtility.splitByComma(args);
+			return `${match[1]}(${parts.join(', ')})`;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns color.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getColor(value: string): string | null {
+		const lowerValue = value.toLowerCase();
+		if (COLORS.includes(lowerValue)) {
+			return lowerValue;
+		}
+		const match = value.match(COLOR_REGEXP);
+		if (match) {
+			if (match[2] && match[3]) {
+				return `${match[2]}(${match[3].replace(/\s+/g, ' ').replace(/,([^ ])/g, ', $1')})`;
+			}
+			return value;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns URL.
+	 *
+	 * Based on:
+	 * https://github.com/jsdom/cssstyle/blob/master/lib/parsers.js#L222
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getURL(value: string): string | null {
+		if (!value) {
+			return null;
+		}
+
+		if (value.toLowerCase() === 'none') {
+			return 'none';
+		}
+
+		const result = URL_REGEXP.exec(value);
+
+		if (!result) {
+			return null;
+		}
+
+		let url = result[1].trim();
+
+		if ((url[0] === '"' || url[0] === "'") && url[0] !== url[url.length - 1]) {
+			return null;
+		}
+
+		if (url[0] === '"' || url[0] === "'") {
+			url = url.substring(1, url.length - 1);
+		}
+
+		for (let i = 0; i < url.length; i++) {
+			switch (url[i]) {
+				case '(':
+				case ')':
+				case ' ':
+				case '\t':
+				case '\n':
+				case "'":
+				case '"':
+					return null;
+				case '\\':
+					i++;
+					break;
+			}
+		}
+
+		return `url("${url}")`;
+	}
+
+	/**
+	 * Returns global initial value.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getInitial(value: string): string | null {
+		return value.toLowerCase() === 'initial' ? 'initial' : null;
+	}
+
+	/**
+	 * Returns global.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getGlobal(value: string): string | null {
+		const lowerValue = value.toLowerCase();
+		return GLOBALS.includes(lowerValue) ? lowerValue : null;
+	}
+
+	/**
+	 * Returns global, unless it is not set to 'initial' as it is sometimes treated different.
+	 *
+	 * @param value Value.
+	 * @returns Parsed value.
+	 */
+	public static getGlobalExceptInitial(value: string): string | null {
+		const lowerValue = value.toLowerCase();
+		return lowerValue !== 'initial' && GLOBALS.includes(lowerValue) ? lowerValue : null;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/property-manager/utilities/CSSVariableFormatter.ts

@@ -0,0 +1,76 @@
+const GET_SIMPLE_VARIABLE_REGEXP = /^var\(\s*(--[a-zA-Z0-9-_]+)\s*\)$/;
+const GET_FALLBACK_VARIABLE_REGEXP = /^var\(\s*(--[a-zA-Z0-9-_]+),\s*(.+)\)$/;
+const RESOLVE_REGEXP = /var\(\s*(--[a-zA-Z0-9-_]+),?|(\()|(\))/;
+
+/**
+ * CSS variable formatter.
+ */
+export default class CSSVariableFormatter {
+	/**
+	 * Formats CSS variable.
+	 *
+	 * @param value Value containing CSS variable.
+	 * @returns Parsed value.
+	 */
+	public static getVariable(value: string): string | null {
+		const simpleVariableMatch = value.match(GET_SIMPLE_VARIABLE_REGEXP);
+
+		if (simpleVariableMatch) {
+			return `var(${simpleVariableMatch[1]})`;
+		}
+
+		const variableMatch = value.match(GET_FALLBACK_VARIABLE_REGEXP);
+
+		if (variableMatch) {
+			const fallbackValue = variableMatch[2].trim();
+			return `var(${variableMatch[1]}, ${this.getVariable(fallbackValue) || fallbackValue})`;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Resolves CSS variables into it's value.
+	 *
+	 * @param value Value containing CSS variable.
+	 * @param cssVariables CSS variables.
+	 * @returns Parsed value.
+	 */
+	public static resolveVariables(value: string, cssVariables: { [k: string]: string }): string {
+		const regexp = new RegExp(RESOLVE_REGEXP, 'g');
+		let match: RegExpMatchArray | null;
+		let variable: {
+			parentheses: number;
+			name: string;
+			index: number;
+			fallbackIndex: number;
+		} | null = null;
+		let parentheses = 0;
+
+		while ((match = regexp.exec(value)) != null) {
+			if (match[1] && !variable) {
+				variable = {
+					parentheses,
+					name: match[1],
+					index: match.index!,
+					fallbackIndex: match.index! + match[0].length
+				};
+			}
+
+			if (match[1] || match[2]) {
+				parentheses++;
+			} else if (match[3]) {
+				parentheses--;
+			}
+
+			if (variable && variable.parentheses === parentheses) {
+				const fallbackValue = value.substring(variable.fallbackIndex, match.index).trim();
+				const variableValue = cssVariables[variable.name];
+				// The rest of the value may hold further var() references (e.g. "calc(var(--a) + var(--b))").
+				return `${value.substring(0, variable.index)}${this.resolveVariables(variableValue || fallbackValue, cssVariables)}${this.resolveVariables(value.substring(match.index! + match[0].length), cssVariables)}`;
+			}
+		}
+
+		return value;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/css/declaration/utilities/CSSMeasurementConverter.ts

@@ -0,0 +1,79 @@
+import type BrowserWindow from '../../../window/BrowserWindow.js';
+
+/**
+ * CSS Measurement Converter.
+ */
+export default class CSSMeasurementConverter {
+	/**
+	 * Returns measurement in pixels.
+	 *
+	 * @param options Options.
+	 * @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.
+	 * @param [options.parentSize] Parent size in pixels.
+	 * @returns Measurement in pixels.
+	 */
+	public static toPixels(options: {
+		window: BrowserWindow;
+		value: string;
+		rootFontSize: string | number;
+		parentFontSize: string | number;
+		parentSize?: string | number | null;
+	}): number | null {
+		const value = parseFloat(options.value);
+		const unit = options.value.replace(value.toString(), '');
+
+		if (isNaN(value)) {
+			return null;
+		}
+
+		switch (unit) {
+			case 'px':
+				return value;
+			case 'rem':
+				return this.round(value * parseFloat(<string>options.rootFontSize));
+			case 'em':
+				return this.round(value * parseFloat(<string>options.parentFontSize));
+			case 'vw':
+				return this.round((value * options.window.innerWidth) / 100);
+			case 'vh':
+				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.window.innerWidth, options.window.innerHeight)) / 100
+				);
+			case 'vmax':
+				return (value * Math.max(options.window.innerWidth, options.window.innerHeight)) / 100;
+			case 'cm':
+				return this.round(value * 37.7812);
+			case 'mm':
+				return this.round(value * 3.7781);
+			case 'in':
+				return this.round(value * 96);
+			case 'pt':
+				return this.round(value * 1.3281);
+			case 'pc':
+				return this.round(value * 16);
+			case 'Q':
+				return this.round(value * 0.945);
+			default:
+				return null;
+		}
+	}
+
+	/**
+	 * Rounds the number with 4 decimals.
+	 *
+	 * @param value Value.
+	 * @returns Rounded value.
+	 */
+	public static round(value: number): number {
+		return Math.round(value * 10000) / 10000;
+	}
+}