buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-input-element/HTMLInputElementDateUtility.ts

@@ -0,0 +1,50 @@
+/**
+ * Date utility for HTML input elements.
+ */
+export default class HTMLInputElementDateUtility {
+	/**
+	 * Returns iso week number from given date
+	 *
+	 * @see https://stackoverflow.com/a/6117889
+	 * @param date Date or number.
+	 * @returns Iso-week string.
+	 */
+	public static dateIsoWeek(date: Date | number): string {
+		date = typeof date === 'number' ? new Date(date) : date;
+		// Copy date so don't modify original
+		date = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+		// Set to nearest Thursday: current date + 4 - current day number
+		// Make Sunday's day number 7
+		date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+		// Get first day of year
+		const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+		// Calculate full weeks to nearest Thursday
+		const weekNo = Math.ceil(
+			((<number>(<unknown>date) - <number>(<unknown>yearStart)) / 86400000 + 1) / 7
+		);
+		return `${date.getUTCFullYear()}-W${weekNo < 10 ? '0' : ''}${weekNo}`;
+	}
+
+	/**
+	 * Returns a date object for monday of given iso week string (\d\d\d\d-W\d\d)
+	 *
+	 * @param isoWeek Iso-week string.
+	 * @returns Date.
+	 */
+	public static isoWeekDate(isoWeek: string): Date {
+		// Algorythm adapted from https://en.wikipedia.org/wiki/ISO_week_date
+		const [, Y, W] = isoWeek.match(/^(\d{4})-W(\d{2})$/) || [];
+		if (!Y || !W || Number(W) > 53 || Number(W) < 1) {
+			return new Date('x'); // Return an invalid date
+		}
+		const date = new Date(`${Y}-01-01T00:00Z`);
+		const jan4th = new Date(`${Y}-01-04T00:00Z`);
+		const jan4thDay = (jan4th.getUTCDay() + 6) % 7;
+		const ordinalDate = 1 + (Number(W) - 1) * 7 - jan4thDay + 3;
+		date.setUTCDate(ordinalDate);
+		if (date.getUTCFullYear() > Number(Y)) {
+			return new Date('x'); // Return an invalid date
+		}
+		return date;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-input-element/HTMLInputElementSelectionDirectionEnum.ts

@@ -0,0 +1,6 @@
+enum HTMLInputElementSelectionDirectionEnum {
+	none = 'none',
+	forward = 'forward',
+	backward = 'backward'
+}
+export default HTMLInputElementSelectionDirectionEnum;

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-input-element/HTMLInputElementSelectionModeEnum.ts

@@ -0,0 +1,7 @@
+enum HTMLInputElementSelectionModeEnum {
+	preserve = 'preserve',
+	select = 'select',
+	start = 'start',
+	end = 'end'
+}
+export default HTMLInputElementSelectionModeEnum;

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-input-element/HTMLInputElementValueSanitizer.ts

@@ -0,0 +1,211 @@
+import type HTMLInputElement from './HTMLInputElement.js';
+
+const NEW_LINES_REGEXP = /[\n\r]/gm;
+const parseInts = (a: string[]): number[] => a.map((v) => parseInt(v, 10));
+
+/**
+ * HTML input element value sanitizer.
+ */
+export default class HTMLInputElementValueSanitizer {
+	/**
+	 * Sanitizes a value.
+	 *
+	 * @param input Input.
+	 * @param value Value.
+	 */
+	public static sanitize(input: HTMLInputElement, value: string): string {
+		switch (input.type) {
+			case 'password':
+			case 'search':
+			case 'tel':
+			case 'text':
+				return value.replace(NEW_LINES_REGEXP, '');
+			case 'color':
+				// https://html.spec.whatwg.org/multipage/forms.html#color-state-(type=color):value-sanitization-algorithm
+				return /^#[a-fA-F\d]{6}$/.test(value) ? value.toLowerCase() : '#000000';
+			case 'email':
+				// https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email):value-sanitization-algorithm
+				// https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email):value-sanitization-algorithm-2
+				if (input.multiple) {
+					return value
+						.split(',')
+						.map((token) => token.trim())
+						.join(',');
+				}
+				return value.trim().replace(NEW_LINES_REGEXP, '');
+			case 'number':
+				// https://html.spec.whatwg.org/multipage/input.html#number-state-(type=number):value-sanitization-algorithm
+				return !isNaN(Number.parseFloat(value)) ? value : '';
+			case 'range': {
+				// https://html.spec.whatwg.org/multipage/input.html#range-state-(type=range):value-sanitization-algorithm
+				const number = Number.parseFloat(value);
+				const min = parseFloat(input.min) || 0;
+				const max = parseFloat(input.max) || 100;
+
+				if (isNaN(number)) {
+					return max < min ? String(min) : String((min + max) / 2);
+				} else if (number < min) {
+					return String(min);
+				} else if (number > max) {
+					return String(max);
+				}
+
+				return value;
+			}
+			case 'url':
+				// https://html.spec.whatwg.org/multipage/forms.html#url-state-(type=url):value-sanitization-algorithm
+				return value.trim().replace(NEW_LINES_REGEXP, '');
+			case 'date':
+				// https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):value-sanitization-algorithm
+				return this.sanitizeDate(value);
+			case 'datetime-local': {
+				// https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type=datetime-local):value-sanitization-algorithm
+				const match = value.match(
+					/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d)(?::(\d\d)(?:\.(\d{1,3}))?)?$/
+				);
+				if (!match) {
+					return '';
+				}
+				const dateString = this.sanitizeDate(value.slice(0, 10));
+				let timeString = this.sanitizeTime(value.slice(11));
+				if (!(dateString && timeString)) {
+					return '';
+				}
+				// Has seconds so needs to remove trailing zeros
+				if (match[6] !== undefined) {
+					if (timeString.indexOf('.') !== -1) {
+						// Remove unecessary zeros milliseconds
+						timeString = timeString.replace(/(?:\.0*|(\.\d+?)0+)$/, '$1');
+					}
+					timeString = timeString.replace(/(\d\d:\d\d)(:00)$/, '$1');
+				}
+				return dateString + 'T' + timeString;
+			}
+			case 'month':
+				// https://html.spec.whatwg.org/multipage/input.html#month-state-(type=month):value-sanitization-algorithm
+				if (!(value.match(/^(\d\d\d\d)-(\d\d)$/) && this.parseMonthComponent(value))) {
+					return '';
+				}
+				return this.checkBoundaries(value, input.min, input.max) ? value : '';
+			case 'time': {
+				// https://html.spec.whatwg.org/multipage/input.html#time-state-(type=time):value-sanitization-algorithm
+				value = this.sanitizeTime(value);
+				return value && this.checkBoundaries(value, input.min, input.max) ? value : '';
+			}
+			case 'week': {
+				// https://html.spec.whatwg.org/multipage/input.html#week-state-(type=week):value-sanitization-algorithm
+				const match = value.match(/^(\d\d\d\d)-W(\d\d)$/);
+				if (!match) {
+					return '';
+				}
+				const [intY, intW] = parseInts(match.slice(1, 3));
+				if (intY <= 0 || intW < 1 || intW > 53) {
+					return '';
+				}
+				// Check date is valid
+				const lastWeek = this.lastIsoWeekOfYear(intY);
+				if (intW < 1 || intW > 52 + lastWeek) {
+					return '';
+				}
+				if (!this.checkBoundaries(value, input.min, input.max)) {
+					return '';
+				}
+				return value;
+			}
+		}
+
+		return value;
+	}
+	/**
+	 * Checks if a value is within the boundaries of min and max.
+	 *
+	 * @param value
+	 * @param min
+	 * @param max
+	 */
+	private static checkBoundaries<T>(value: T, min: T, max: T): boolean {
+		if (min && min > value) {
+			return false;
+		} else if (max && max < value) {
+			return false;
+		}
+		return true;
+	}
+	/**
+	 * Parses the month component of a date string.
+	 *
+	 * @param value
+	 */
+	private static parseMonthComponent(value: string): string {
+		const [Y, M] = value.split('-');
+		const [intY, intM] = parseInts([Y, M]);
+		if (isNaN(intY) || isNaN(intM) || intY <= 0 || intM < 1 || intM > 12) {
+			return '';
+		}
+		return value;
+	}
+	/**
+	 * Returns the last ISO week of a year.
+	 *
+	 * @param year
+	 */
+	private static lastIsoWeekOfYear = (year: string | number): number => {
+		const date = new Date(+year, 11, 31);
+		const day = (date.getDay() + 6) % 7;
+		date.setDate(date.getDate() - day + 3);
+		const firstThursday = date.getTime();
+		date.setMonth(0, 1);
+		if (date.getDay() !== 4) {
+			date.setMonth(0, 1 + ((4 - date.getDay() + 7) % 7));
+		}
+		return 1 + Math.ceil((firstThursday - date.getTime()) / 604800000);
+	};
+
+	/**
+	 * Sanitizes a date string.
+	 *
+	 * @param value
+	 */
+	private static sanitizeDate(value: string): string {
+		const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+		if (!match) {
+			return '';
+		}
+		const month = this.parseMonthComponent(value.slice(0, 7));
+		if (!month) {
+			return '';
+		}
+		const [intY, intM, intD] = parseInts(match.slice(1, 4));
+		if (intD < 1 || intD > 31) {
+			return '';
+		}
+		// Check date is valid
+		const lastDayOfMonth = new Date(intY, intM, 0).getDate();
+		if (intD > lastDayOfMonth) {
+			return '';
+		}
+		return value;
+	}
+
+	/**
+	 * Sanitizes a time string.
+	 *
+	 * @param value
+	 */
+	private static sanitizeTime(value: string): string {
+		const match = value.match(/^(\d{2}):(\d{2})(?::(\d{2}(?:\.(\d{1,3}))?))?$/);
+		if (!match) {
+			return '';
+		}
+		const [intH, intM] = parseInts(match.slice(1, 3));
+		const ms = parseFloat(match[3] || '0') * 1000;
+		if (intH > 23 || intM > 59 || ms > 59999) {
+			return '';
+		}
+		if (ms === 0) {
+			return `${match[1]}:${match[2]}`;
+		} else {
+			return `${match[1]}:${match[2]}${ms >= 10000 ? `:${ms / 1000}` : `:0${ms / 1000}`}`;
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-input-element/HTMLInputElementValueStepping.ts

@@ -0,0 +1,92 @@
+import DOMException from '../../exception/DOMException.js';
+import type HTMLInputElement from './HTMLInputElement.js';
+
+/**
+ * HTML input element value stepping.
+ */
+export default class HTMLInputElementValueStepping {
+	/**
+	 * Steps up or down.
+	 *
+	 * @param input Input element.
+	 * @param direction Direction.
+	 * @param [increment] Increment.
+	 * @returns New value.
+	 */
+	public static step(
+		input: HTMLInputElement,
+		direction: -1 | 1,
+		increment?: number
+	): string | null {
+		const type = input.type;
+		switch (type) {
+			case 'number':
+				return this.getNumberValue(input, direction, increment);
+			case 'date':
+			case 'month':
+			case 'week':
+			case 'time':
+			case 'datetime-local':
+			case 'range':
+				// TODO: Implement support for additional types
+				return null;
+			default:
+				throw new DOMException('This form element is not steppable.');
+		}
+	}
+
+	/**
+	 * Returns the stepped value for "number" input field.
+	 *
+	 * @see https://html.spec.whatwg.org/multipage/input.html#dom-input-stepup
+	 * @param input Input element.
+	 * @param direction Direction.
+	 * @param [increment] Increment.
+	 */
+	private static getNumberValue(
+		input: HTMLInputElement,
+		direction: -1 | 1,
+		increment?: number
+	): string {
+		const stepValue = input.step;
+		const minValue = input.min;
+		const maxValue = input.max;
+
+		const min = minValue !== '' ? Number(minValue) : null;
+		const max = maxValue !== '' ? Number(maxValue) : null;
+		let value = Number(input.value);
+		let step = stepValue !== '' ? Number(stepValue) : 1;
+
+		value = isNaN(value) ? 0 : value;
+		step = isNaN(step) || step === 0 ? 1 : step;
+
+		if (min !== null && !isNaN(min) && max !== null && !isNaN(max) && (min > max || max < min)) {
+			return input.value;
+		}
+
+		if (increment === 0) {
+			return input.value;
+		}
+
+		const validIncrementValue = increment !== undefined ? Math.ceil(increment / step) * step : step;
+		const candidate = value + validIncrementValue * direction;
+		const minOrZero = min !== null && !isNaN(min) ? min : 0;
+
+		switch (direction) {
+			// Step down
+			case -1:
+				if (min !== null && !isNaN(min) && candidate < min) {
+					return String(min);
+				}
+				// Previous valid step from value
+				return String(candidate + ((value - minOrZero) % step));
+			// Step up
+			case 1:
+				if (max !== null && !isNaN(max) && candidate > max) {
+					return String(minOrZero + Math.floor((max - minOrZero) / step) * step);
+				}
+				// Next valid step from value
+				return String(candidate - ((value - minOrZero) % step));
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-label-element/HTMLLabelElement.ts

@@ -0,0 +1,128 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type HTMLFormElement from '../html-form-element/HTMLFormElement.js';
+import type Event from '../../event/Event.js';
+import EventPhaseEnum from '../../event/EventPhaseEnum.js';
+import type HTMLInputElement from '../html-input-element/HTMLInputElement.js';
+import type Document from '../document/Document.js';
+import MouseEvent from '../../event/events/MouseEvent.js';
+import type HTMLButtonElement from '../html-button-element/HTMLButtonElement.js';
+import type HTMLMeterElement from '../html-meter-element/HTMLMeterElement.js';
+import type HTMLOutputElement from '../html-output-element/HTMLOutputElement.js';
+import type HTMLProgressElement from '../html-progress-element/HTMLProgressElement.js';
+import type HTMLSelectElement from '../html-select-element/HTMLSelectElement.js';
+import type HTMLTextAreaElement from '../html-text-area-element/HTMLTextAreaElement.js';
+
+/**
+ * HTML Label Element.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement.
+ */
+export default class HTMLLabelElement extends HTMLElement {
+	// Public properties
+	public declare cloneNode: (deep?: boolean) => HTMLLabelElement;
+
+	/**
+	 * Returns a string containing the ID of the labeled control. This reflects the "for" attribute.
+	 *
+	 * @returns ID of the labeled control.
+	 */
+	public get htmlFor(): string {
+		const htmlFor = this.getAttribute('for');
+		if (htmlFor !== null) {
+			return htmlFor;
+		}
+		return htmlFor !== null ? htmlFor : '';
+	}
+
+	/**
+	 * Sets a string containing the ID of the labeled control. This reflects the "for" attribute.
+	 *
+	 * @param htmlFor ID of the labeled control.
+	 */
+	public set htmlFor(htmlFor: string) {
+		this.setAttribute('for', htmlFor);
+	}
+
+	/**
+	 * Returns an HTML element representing the control with which the label is associated.
+	 *
+	 * @returns Control element.
+	 */
+	public get control():
+		| HTMLInputElement
+		| HTMLButtonElement
+		| HTMLMeterElement
+		| HTMLOutputElement
+		| HTMLProgressElement
+		| HTMLSelectElement
+		| HTMLTextAreaElement
+		| null {
+		const htmlFor = this.getAttribute('for');
+		if (htmlFor !== null) {
+			if (!htmlFor || !this[PropertySymbol.isConnected]) {
+				return null;
+			}
+			const control = <HTMLElement | null>(
+				(<Document>this[PropertySymbol.rootNode]).getElementById(htmlFor)
+			);
+			if (control) {
+				switch (control[PropertySymbol.tagName]) {
+					case 'INPUT':
+						return (<HTMLInputElement>control).type !== 'hidden' ? <HTMLInputElement>control : null;
+					case 'BUTTON':
+					case 'METER':
+					case 'OUTPUT':
+					case 'PROGRESS':
+					case 'SELECT':
+					case 'TEXTAREA':
+						return <HTMLInputElement>control;
+					default:
+						return null;
+				}
+			}
+		}
+		return <HTMLInputElement | null>(
+			this.querySelector('button,input:not([type="hidden"]),meter,output,progress,select,textarea')
+		);
+	}
+
+	/**
+	 * Returns the parent form element.
+	 *
+	 * @returns Form.
+	 */
+	public get form(): HTMLFormElement | null {
+		return (<HTMLInputElement>this.control)?.form || null;
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.cloneNode](deep = false): HTMLLabelElement {
+		return <HTMLLabelElement>super[PropertySymbol.cloneNode](deep);
+	}
+
+	/**
+	 * @override
+	 */
+	public override dispatchEvent(event: Event): boolean {
+		const returnValue = super.dispatchEvent(event);
+
+		if (
+			!event[PropertySymbol.defaultPrevented] &&
+			event.type === 'click' &&
+			(event.eventPhase === EventPhaseEnum.atTarget ||
+				event.eventPhase === EventPhaseEnum.bubbling) &&
+			event instanceof MouseEvent
+		) {
+			const control = this.control;
+			if (control && event.target !== control) {
+				control.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+			}
+		}
+
+		return returnValue;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-label-element/HTMLLabelElementUtility.ts

@@ -0,0 +1,45 @@
+import type Document from '../document/Document.js';
+import type HTMLElement from '../html-element/HTMLElement.js';
+import type HTMLLabelElement from './HTMLLabelElement.js';
+import NodeList from '../node/NodeList.js';
+import type ShadowRoot from '../shadow-root/ShadowRoot.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Element from '../element/Element.js';
+
+/**
+ * Utility for finding labels associated with a form element.
+ */
+export default class HTMLLabelElementUtility {
+	/**
+	 * Returns label elements for a form element.
+	 *
+	 * @param element Element to get labels for.
+	 * @returns Label elements.
+	 */
+	public static getAssociatedLabelElements(element: HTMLElement): NodeList<HTMLLabelElement> {
+		const id = element.id;
+		let labels: HTMLLabelElement[];
+
+		if (id && element[PropertySymbol.isConnected]) {
+			const rootNode =
+				<Document | ShadowRoot>element[PropertySymbol.rootNode] ||
+				element[PropertySymbol.ownerDocument];
+			labels = <HTMLLabelElement[]>(
+				rootNode.querySelectorAll(`label[for="${id}"]`)[PropertySymbol.items].slice()
+			);
+		} else {
+			labels = [];
+		}
+
+		let parent = element[PropertySymbol.parentNode];
+		while (parent) {
+			if ((<Element>parent)['tagName'] === 'LABEL') {
+				labels.push(<HTMLLabelElement>parent);
+				break;
+			}
+			parent = parent[PropertySymbol.parentNode];
+		}
+
+		return new NodeList<HTMLLabelElement>(PropertySymbol.illegalConstructor, labels);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-legend-element/HTMLLegendElement.ts

@@ -0,0 +1,27 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+import type HTMLFormElement from '../html-form-element/HTMLFormElement.js';
+import HTMLFieldSetElement from '../html-field-set-element/HTMLFieldSetElement.js';
+import type Node from '../node/Node.js';
+
+/**
+ * HTMLLegendElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLLegendElement
+ */
+export default class HTMLLegendElement extends HTMLElement {
+	/**
+	 * Returns the parent form element.
+	 *
+	 * @returns Form.
+	 */
+	public get form(): HTMLFormElement | null {
+		let parent: Node | null = this;
+		while (parent) {
+			if (parent instanceof HTMLFieldSetElement) {
+				return parent.form;
+			}
+			parent = parent.parentNode;
+		}
+		return null;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-li-element/HTMLLIElement.ts

@@ -0,0 +1,31 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+/**
+ * HTMLLIElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLLIElement
+ */
+export default class HTMLLIElement extends HTMLElement {
+	/**
+	 * Returns value.
+	 *
+	 * @returns Value.
+	 */
+	public get value(): number {
+		if (!this.hasAttribute('value')) {
+			return 0;
+		}
+
+		const parsedValue = Number(this.getAttribute('value'));
+		return isNaN(parsedValue) ? 0 : parsedValue;
+	}
+
+	/**
+	 * Sets value.
+	 *
+	 * @param value Value.
+	 */
+	public set value(value: number) {
+		const parsedValue = Number(value);
+		this.setAttribute('value', isNaN(parsedValue) ? '0' : String(parsedValue));
+	}
+}