buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/css/style-property-map/CSSStyleValue.ts

@@ -0,0 +1,37 @@
+import type CSSStyleDeclaration from '../declaration/CSSStyleDeclaration.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * CSSStyleValue interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleValue
+ */
+export default class CSSStyleValue {
+	#style: CSSStyleDeclaration;
+	#property: string;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol
+	 * @param style Style.
+	 * @param property Property.
+	 */
+	constructor(illegalConstructorSymbol: symbol, style: CSSStyleDeclaration, property: string) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		this.#style = style;
+		this.#property = property;
+	}
+
+	/**
+	 * Returns value as string.
+	 *
+	 * @returns Value.
+	 */
+	public toString(): string {
+		return this.#style.getPropertyValue(this.#property);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/css/style-property-map/StylePropertyMap.ts

@@ -0,0 +1,45 @@
+import StylePropertyMapReadOnly from './StylePropertyMapReadOnly.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * StylePropertyMapReadOnly interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly
+ */
+export default class StylePropertyMap extends StylePropertyMapReadOnly {
+	/**
+	 * Appends a property.
+	 *
+	 * @param property Property.
+	 * @param value Value.
+	 */
+	public append(property: string, value: string): void {
+		this[PropertySymbol.style].setProperty(property, value);
+	}
+
+	/**
+	 * Clears all properties.
+	 */
+	public clear(): void {
+		this[PropertySymbol.style].cssText = '';
+	}
+
+	/**
+	 * Deletes a property.
+	 *
+	 * @param property Property.
+	 */
+	public delete(property: string): void {
+		this[PropertySymbol.style].removeProperty(property);
+	}
+
+	/**
+	 * Sets a property.
+	 *
+	 * @param property Property.
+	 * @param value Value.
+	 */
+	public set(property: string, value: string): void {
+		this[PropertySymbol.style].setProperty(property, value);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/css/style-property-map/StylePropertyMapReadOnly.ts

@@ -0,0 +1,128 @@
+import type CSSStyleDeclaration from '../declaration/CSSStyleDeclaration.js';
+import CSSKeywordValue from './CSSKeywordValue.js';
+import CSSStyleValue from './CSSStyleValue.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * StylePropertyMapReadOnly interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly
+ */
+export default class StylePropertyMapReadOnly {
+	public [PropertySymbol.style]: CSSStyleDeclaration;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol Illegal constructor symbol.
+	 * @param style Style.
+	 */
+	constructor(illegalConstructorSymbol: symbol, style: CSSStyleDeclaration) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		this[PropertySymbol.style] = style;
+	}
+
+	/**
+	 * Returns size.
+	 *
+	 * @returns Size.
+	 */
+	public get size(): number {
+		return this[PropertySymbol.style].length;
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public [Symbol.iterator](): IterableIterator<[string, CSSKeywordValue[]]> {
+		return this.entries();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all key/value pairs contained in this object.
+	 *
+	 * @returns Entries.
+	 */
+	public entries(): IterableIterator<[string, CSSKeywordValue[]]> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			const property = (<any>this[PropertySymbol.style])[i];
+			array[i] = [
+				property,
+				[new CSSKeywordValue(this[PropertySymbol.style].getPropertyValue(property))]
+			];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Values.
+	 */
+	public values(): IterableIterator<CSSKeywordValue[]> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			const property = (<any>this[PropertySymbol.style])[i];
+			array[i] = [new CSSKeywordValue(this[PropertySymbol.style].getPropertyValue(property))];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all keys of the key/value pairs contained in this object.
+	 *
+	 * @returns Keys.
+	 */
+	public keys(): IterableIterator<string> {
+		const length = this[PropertySymbol.style].length;
+		const array = new Array(length);
+		for (let i = 0; i < length; i++) {
+			array[i] = (<any>this[PropertySymbol.style])[i];
+		}
+		return array.values();
+	}
+
+	/**
+	 * Returns a property value.
+	 *
+	 * @param property Property.
+	 * @returns Value.
+	 */
+	public get(property: string): CSSStyleValue {
+		return new CSSStyleValue(
+			PropertySymbol.illegalConstructor,
+			this[PropertySymbol.style],
+			property
+		);
+	}
+
+	/**
+	 * Returns array of property values.
+	 *
+	 * @param property Property.
+	 * @returns Values.
+	 */
+	public getAll(property: string): CSSStyleValue[] {
+		return [
+			new CSSStyleValue(PropertySymbol.illegalConstructor, this[PropertySymbol.style], property)
+		];
+	}
+
+	/**
+	 * Checks if a property is present.
+	 *
+	 * @param property Property.
+	 * @returns True if the property is present.
+	 */
+	public has(property: string): boolean {
+		return !!this[PropertySymbol.style].getPropertyValue(property);
+	}
+}

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

@@ -0,0 +1,87 @@
+/**
+ * CSS escaper.
+ */
+export default class CSSEscaper {
+	/**
+	 * Escapes CSS.
+	 *
+	 * Based on:
+	 * https://github.com/mathiasbynens/CSS.escape
+	 *
+	 * @param cssText CSS.
+	 * @returns Escaped CSS.
+	 */
+	public static escape(cssText: string): string {
+		if (arguments.length == 0) {
+			throw new TypeError('`CSS.escape` requires an argument.');
+		}
+		const returnValue = String(cssText);
+		const length = returnValue.length;
+		let index = -1;
+		let codeUnit;
+		let result = '';
+		const firstCodeUnit = returnValue.charCodeAt(0);
+
+		if (
+			// If the character is the first character and is a `-` (U+002D), and
+			// There is no second character, […]
+			length == 1 &&
+			firstCodeUnit == 0x002d
+		) {
+			return '\\' + returnValue;
+		}
+
+		while (++index < length) {
+			codeUnit = returnValue.charCodeAt(index);
+			// Note: there’s no need to special-case astral symbols, surrogate
+			// Pairs, or lone surrogates.
+
+			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+			// (U+FFFD).
+			if (codeUnit == 0x0000) {
+				result += '\uFFFD';
+				continue;
+			}
+
+			if (
+				// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+				// U+007F, […]
+				(codeUnit >= 0x0001 && codeUnit <= 0x001f) ||
+				codeUnit == 0x007f ||
+				// If the character is the first character and is in the range [0-9]
+				// (U+0030 to U+0039), […]
+				(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+				// If the character is the second character and is in the range [0-9]
+				// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+				(index == 1 && codeUnit >= 0x0030 && codeUnit <= 0x0039 && firstCodeUnit == 0x002d)
+			) {
+				// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+				result += '\\' + codeUnit.toString(16) + ' ';
+				continue;
+			}
+
+			// If the character is not handled by one of the above rules and is
+			// Greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+			// Is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+			// U+005A), or [a-z] (U+0061 to U+007A), […]
+			if (
+				codeUnit >= 0x0080 ||
+				codeUnit == 0x002d ||
+				codeUnit == 0x005f ||
+				(codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+				(codeUnit >= 0x0041 && codeUnit <= 0x005a) ||
+				(codeUnit >= 0x0061 && codeUnit <= 0x007a)
+			) {
+				// The character itself
+				result += returnValue.charAt(index);
+				continue;
+			}
+
+			// Otherwise, the escaped character.
+			// https://drafts.csswg.org/cssom/#escape-a-character
+			result += '\\' + returnValue.charAt(index);
+		}
+
+		return result;
+	}
+}

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

@@ -0,0 +1,315 @@
+import type CSSRule from '../CSSRule.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type CSSStyleSheet from '../CSSStyleSheet.js';
+import CSSStyleRule from '../rules/CSSStyleRule.js';
+import CSSKeyframeRule from '../rules/CSSKeyframeRule.js';
+import CSSKeyframesRule from '../rules/CSSKeyframesRule.js';
+import CSSMediaRule from '../rules/CSSMediaRule.js';
+import CSSContainerRule from '../rules/CSSContainerRule.js';
+import CSSSupportsRule from '../rules/CSSSupportsRule.js';
+import CSSFontFaceRule from '../rules/CSSFontFaceRule.js';
+import SelectorParser from '../../query-selector/SelectorParser.js';
+import CSSRuleTypeEnum from '../CSSRuleTypeEnum.js';
+import CSSScopeRule from '../rules/CSSScopeRule.js';
+import QuerySelector from '../../query-selector/QuerySelector.js';
+
+const COMMENT_REGEXP = /\/\*[\s\S]*?\*\//gm;
+
+/**
+ * CSS parser.
+ */
+export default class CSSRuleParser {
+	#parentStyleSheet: CSSStyleSheet;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param parentStyleSheet Parent style sheet.
+	 */
+	constructor(parentStyleSheet: CSSStyleSheet) {
+		this.#parentStyleSheet = parentStyleSheet;
+	}
+	/**
+	 * Parses HTML and returns a root element.
+	 *
+	 * @param cssText CSS code.
+	 * @returns CSS rules.
+	 */
+	public parseFromString(cssText: string): CSSRule[] {
+		const parentStyleSheet = this.#parentStyleSheet;
+		const window = parentStyleSheet[PropertySymbol.window];
+		const css = cssText.replace(COMMENT_REGEXP, '');
+		const cssRules = [];
+		const regExp = /{|}/gm;
+		const stack: CSSRule[] = [];
+		let parentRule: CSSRule | null = null;
+		let lastIndex = 0;
+		let match: RegExpMatchArray | null;
+
+		while ((match = regExp.exec(css))) {
+			if (match[0] === '{') {
+				const selectorText = css.substring(lastIndex, match.index).trim();
+
+				if (selectorText[0] === '@') {
+					const ruleParts = selectorText.split(' ');
+					const ruleType = ruleParts[0];
+					const ruleParameters = ruleParts.slice(1).join(' ').trim();
+
+					switch (ruleType) {
+						case '@keyframes':
+						case '@-webkit-keyframes':
+							const keyframesRule = new CSSKeyframesRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
+
+							keyframesRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-keyframes' ? '-webkit-' : '';
+							keyframesRule[PropertySymbol.name] = ruleParameters;
+							keyframesRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(keyframesRule);
+								}
+							} else {
+								cssRules.push(keyframesRule);
+							}
+							parentRule = keyframesRule;
+							break;
+						case '@media':
+							const mediums = ruleParameters.split(',');
+							const mediaRule = new CSSMediaRule(PropertySymbol.illegalConstructor, window, this);
+
+							for (const medium of mediums) {
+								mediaRule.media.appendMedium(medium.trim());
+							}
+
+							mediaRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(mediaRule);
+								}
+							} else {
+								cssRules.push(mediaRule);
+							}
+							parentRule = mediaRule;
+							break;
+						case '@container':
+						case '@-webkit-container':
+							const containerRule = new CSSContainerRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
+							containerRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-container' ? '-webkit-' : '';
+							containerRule[PropertySymbol.conditionText] = ruleParameters;
+							containerRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(containerRule);
+								}
+							} else {
+								cssRules.push(containerRule);
+							}
+
+							parentRule = containerRule;
+							break;
+						case '@supports':
+						case '@-webkit-supports':
+							const supportsRule = new CSSSupportsRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
+
+							supportsRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-supports' ? '-webkit-' : '';
+							supportsRule[PropertySymbol.conditionText] = ruleParameters;
+							supportsRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(supportsRule);
+								}
+							} else {
+								cssRules.push(supportsRule);
+							}
+							parentRule = supportsRule;
+							break;
+						case '@font-face':
+							const fontFaceRule = new CSSFontFaceRule(
+								PropertySymbol.illegalConstructor,
+								window,
+								this
+							);
+
+							fontFaceRule[PropertySymbol.cssText] = ruleParameters;
+							fontFaceRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(fontFaceRule);
+								}
+							} else {
+								cssRules.push(fontFaceRule);
+							}
+							parentRule = fontFaceRule;
+							break;
+						case '@scope':
+						case '@-webkit-scope':
+							const scopeRule = new CSSScopeRule(PropertySymbol.illegalConstructor, window, this);
+
+							scopeRule[PropertySymbol.rulePrefix] =
+								ruleType === '@-webkit-scope' ? '-webkit-' : '';
+							scopeRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+
+							if (ruleParameters) {
+								const scopeRuleParts = ruleParameters.split(/\s+to\s+/);
+								if (
+									scopeRuleParts[0] &&
+									scopeRuleParts[0][0] === '(' &&
+									scopeRuleParts[0][scopeRuleParts[0].length - 1] === ')'
+								) {
+									scopeRule[PropertySymbol.start] = scopeRuleParts[0].slice(1, -1);
+								}
+								if (
+									scopeRuleParts[1] &&
+									scopeRuleParts[1][0] === '(' &&
+									scopeRuleParts[1][scopeRuleParts[1].length - 1] === ')'
+								) {
+									scopeRule[PropertySymbol.end] = scopeRuleParts[1].slice(1, -1);
+								}
+							}
+
+							if (parentRule) {
+								if (
+									parentRule.type === CSSRuleTypeEnum.mediaRule ||
+									parentRule.type === CSSRuleTypeEnum.containerRule ||
+									parentRule.type === CSSRuleTypeEnum.supportsRule
+								) {
+									(<CSSMediaRule>parentRule).cssRules.push(scopeRule);
+								}
+							} else {
+								cssRules.push(scopeRule);
+							}
+							parentRule = scopeRule;
+							break;
+						default:
+							// Unknown rule.
+							// We will create a new rule to let it grab its content, but we will not add it to the cssRules array.
+							const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+							newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+							parentRule = newRule;
+							break;
+					}
+				} else if (parentRule && parentRule.type === CSSRuleTypeEnum.keyframesRule) {
+					const newRule = new CSSKeyframeRule(PropertySymbol.illegalConstructor, window, this);
+					let keyText = selectorText.trim();
+					if (keyText === 'from') {
+						keyText = '0%';
+					} else if (keyText === 'to') {
+						keyText = '100%';
+					}
+					newRule[PropertySymbol.keyText] = keyText;
+					newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+					newRule[PropertySymbol.parentRule] = parentRule;
+
+					(<CSSKeyframesRule>parentRule).cssRules.push(<CSSKeyframeRule>newRule);
+					parentRule = newRule;
+				} else if (
+					parentRule &&
+					(parentRule.type === CSSRuleTypeEnum.mediaRule ||
+						parentRule.type === CSSRuleTypeEnum.containerRule ||
+						parentRule.type === CSSRuleTypeEnum.supportsRule)
+				) {
+					if (this.validateSelectorText(selectorText)) {
+						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+						newRule[PropertySymbol.selectorText] = selectorText;
+						newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+						newRule[PropertySymbol.parentRule] = parentRule;
+						(<CSSMediaRule>parentRule).cssRules.push(newRule);
+						parentRule = newRule;
+					}
+				} else {
+					if (this.validateSelectorText(selectorText)) {
+						const newRule = new CSSStyleRule(PropertySymbol.illegalConstructor, window, this);
+						newRule[PropertySymbol.selectorText] = selectorText;
+						newRule[PropertySymbol.parentStyleSheet] = parentStyleSheet;
+						newRule[PropertySymbol.parentRule] = parentRule;
+
+						if (!parentRule) {
+							cssRules.push(newRule);
+						}
+
+						parentRule = newRule;
+					}
+				}
+
+				if (parentRule) {
+					stack.push(parentRule);
+				}
+			} else {
+				if (parentRule) {
+					const cssText = css
+						.substring(lastIndex, match.index)
+						.trim()
+						.replace(/([^;])$/, '$1;'); // Ensure last semicolon
+					switch (parentRule.type) {
+						case CSSRuleTypeEnum.fontFaceRule:
+						case CSSRuleTypeEnum.keyframeRule:
+						case CSSRuleTypeEnum.styleRule:
+							(<CSSStyleRule>parentRule)[PropertySymbol.cssText] = cssText;
+							break;
+					}
+				}
+
+				stack.pop();
+				parentRule = stack[stack.length - 1] || null;
+			}
+
+			lastIndex = match.index! + 1;
+		}
+
+		return cssRules;
+	}
+
+	/**
+	 * Validates a selector text.
+	 *
+	 * @see https://www.w3.org/TR/CSS21/syndata.html#rule-sets
+	 * @param selectorText Selector text.
+	 * @returns True if valid, false otherwise.
+	 */
+	private validateSelectorText(selectorText: string): boolean {
+		const window = this.#parentStyleSheet[PropertySymbol.window];
+		return (
+			new SelectorParser({
+				window,
+				scope: window.document,
+				ignoreErrors: true,
+				globalMatchFunction: QuerySelector.globalMatchFunction
+			}).getSelectorGroups(selectorText).length > 0
+		);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/custom-element/CustomElementReactionStack.ts

@@ -0,0 +1,91 @@
+import type BrowserWindow from '../window/BrowserWindow.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import type Element from '../nodes/element/Element.js';
+
+/**
+ * Custom element reaction stack.
+ *
+ * @see https://html.spec.whatwg.org/multipage/custom-elements.html#custom-element-reactions-stack
+ */
+export default class CustomElementReactionStack {
+	private window: BrowserWindow;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param window Window.
+	 */
+	constructor(window: BrowserWindow) {
+		this.window = window;
+	}
+
+	/**
+	 * Enqueues a custom element reaction.
+	 *
+	 * @see https://html.spec.whatwg.org/multipage/custom-elements.html#enqueue-a-custom-element-callback-reaction
+	 * @see https://html.spec.whatwg.org/multipage/custom-elements.html#enqueue-an-element-on-the-appropriate-element-queue
+	 * @param element Element.
+	 * @param callbackName Callback name.
+	 * @param [args] Arguments.
+	 */
+	public enqueueReaction(element: Element, callbackName: string, args?: any[]): void {
+		// If a polyfill is used, [PropertySymbol.registry] may be undefined
+		const definition = this.window.customElements[PropertySymbol.registry]?.get(element.localName);
+
+		if (!definition) {
+			return;
+		}
+
+		// We need to make sure that the element has been upgraded, otherwise we should not invoke the callback.
+		// If the element is not connected to the main document, we should not invoke the callback.
+		if (
+			!(element instanceof definition.elementClass) ||
+			element[PropertySymbol.ownerDocument] !== this.window.document
+		) {
+			return;
+		}
+
+		// According to the spec, we should use a queue for each element and then invoke the reactions in the order they were enqueued asynchronously.
+		// However, the browser seem to always invoke the reactions synchronously.
+		// TODO: Can we find an example where the reactions are invoked asynchronously? In that case we should use a queue for those cases.
+
+		switch (callbackName) {
+			case 'connectedCallback':
+				if (definition.lifecycleCallbacks.connectedCallback) {
+					const returnValue: any = definition.lifecycleCallbacks.connectedCallback?.call(element);
+
+					/**
+					 * It is common to import dependencies in the connectedCallback() method of web components.
+					 * As Happy DOM doesn't have support for dynamic imports yet, this is a temporary solution to wait for imports in connectedCallback().
+					 *
+					 * @see https://github.com/capricorn86/happy-dom/issues/1442
+					 */
+					if (returnValue instanceof Promise) {
+						const asyncTaskManager = new WindowBrowserContext(this.window).getAsyncTaskManager();
+						if (asyncTaskManager) {
+							const taskID = asyncTaskManager.startTask();
+							returnValue
+								.then(() => asyncTaskManager.endTask(taskID))
+								.catch(() => asyncTaskManager.endTask(taskID));
+						}
+					}
+				}
+				break;
+			case 'disconnectedCallback':
+				if (definition.lifecycleCallbacks.disconnectedCallback) {
+					definition.lifecycleCallbacks.disconnectedCallback.call(element);
+				}
+				break;
+			case 'attributeChangedCallback':
+				if (
+					definition.lifecycleCallbacks.attributeChangedCallback &&
+					args?.length &&
+					definition.observedAttributes.has(args[0])
+				) {
+					definition.lifecycleCallbacks.attributeChangedCallback.apply(element, <any>args);
+				}
+				break;
+		}
+	}
+}