buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/query-selector/QuerySelector.ts

@@ -0,0 +1,849 @@
+import type Element from '../nodes/element/Element.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type SelectorItem from './SelectorItem.js';
+import NodeList from '../nodes/node/NodeList.js';
+import NodeTypeEnum from '../nodes/node/NodeTypeEnum.js';
+import SelectorCombinatorEnum from './SelectorCombinatorEnum.js';
+import type Document from '../nodes/document/Document.js';
+import type DocumentFragment from '../nodes/document-fragment/DocumentFragment.js';
+import SelectorParser from './SelectorParser.js';
+import type ISelectorMatch from './ISelectorMatch.js';
+import type IHTMLElementTagNameMap from '../config/IHTMLElementTagNameMap.js';
+import type ISVGElementTagNameMap from '../config/ISVGElementTagNameMap.js';
+import type ICachedQuerySelectorAllItem from '../nodes/node/ICachedQuerySelectorAllResult.js';
+import type ICachedQuerySelectorItem from '../nodes/node/ICachedQuerySelectorResult.js';
+import type ICachedMatchesItem from '../nodes/node/ICachedMatchesResult.js';
+import type ShadowRoot from '../nodes/shadow-root/ShadowRoot.js';
+import type { TGlobalMatchFunction } from './TGlobalMatchFunction.js';
+
+type DocumentPositionAndElement = {
+	documentPosition: string;
+	element: Element;
+};
+
+/**
+ * Invalid Selector RegExp.
+ */
+const INVALID_SELECTOR_REGEXP = /^[.#\[]?\d|[.#]$/;
+
+/**
+ * Utility for query selection in an HTML element.
+ *
+ * @class QuerySelector
+ */
+export default class QuerySelector {
+	public static globalMatchFunction: TGlobalMatchFunction = this.matches.bind(this);
+
+	/**
+	 * Finds elements based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML elements.
+	 */
+	public static querySelectorAll<K extends keyof IHTMLElementTagNameMap>(
+		node: Element | Document | DocumentFragment,
+		selector: K
+	): NodeList<IHTMLElementTagNameMap[K]>;
+
+	/**
+	 * Finds elements based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML elements.
+	 */
+	public static querySelectorAll<K extends keyof ISVGElementTagNameMap>(
+		node: Element | Document | DocumentFragment,
+		selector: K
+	): NodeList<ISVGElementTagNameMap[K]>;
+
+	/**
+	 * Finds elements based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML elements.
+	 */
+	public static querySelectorAll<E extends Element = Element>(
+		node: Element | Document | DocumentFragment,
+		selector: string
+	): NodeList<E>;
+
+	/**
+	 * Finds elements based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML elements.
+	 */
+	public static querySelectorAll(
+		node: Element | Document | DocumentFragment,
+		selector: string
+	): NodeList<Element> {
+		const window = node[PropertySymbol.window];
+
+		if (<string>selector === '') {
+			throw new window.DOMException(
+				`Failed to execute 'querySelectorAll' on '${node.constructor.name}': The provided selector is empty.`
+			);
+		}
+
+		if (typeof selector === 'function') {
+			throw new window.DOMException(
+				`Failed to execute 'querySelectorAll' on '${node.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		if (typeof selector === 'symbol') {
+			throw new window.TypeError(
+				`Failed to execute 'querySelectorAll' on '${node.constructor.name}': Cannot convert a Symbol value to a string`
+			);
+		}
+
+		selector = String(selector);
+
+		if (INVALID_SELECTOR_REGEXP.test(selector)) {
+			throw new window.DOMException(
+				`Failed to execute 'querySelectorAll' on '${node.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		const cache = node[PropertySymbol.cache].querySelectorAll;
+		const cachedResult = cache.get(selector);
+
+		if (cachedResult) {
+			if (cachedResult.result !== null) {
+				const result = cachedResult.result.deref();
+				if (result) {
+					return result;
+				}
+			}
+			cache.delete(selector);
+		}
+
+		const scope =
+			node[PropertySymbol.nodeType] === NodeTypeEnum.documentNode
+				? (<Document>node).documentElement
+				: node;
+		const globalMatchFunction = this.globalMatchFunction;
+		const groups = new SelectorParser({ window, scope, globalMatchFunction }).getSelectorGroups(
+			selector
+		);
+		const items: Element[] = [];
+		const nodeList = new NodeList<Element>(PropertySymbol.illegalConstructor, items);
+		const matchesMap: Map<string, Element> = new Map();
+		const matchedPositions: string[] = [];
+		const cachedItem = {
+			result: new WeakRef(nodeList)
+		};
+		node[PropertySymbol.cache].querySelectorAll.set(selector, cachedItem);
+
+		if (node[PropertySymbol.isConnected]) {
+			// Document is affected for the ":target" selector
+			(node[PropertySymbol.ownerDocument] || node)[PropertySymbol.affectsCache].push(cachedItem);
+			if (node[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode && (<any>node).host) {
+				(<any>node).host[PropertySymbol.affectsCache].push(cachedItem);
+			}
+		}
+
+		for (const selectorItems of groups) {
+			const rootElement =
+				node[PropertySymbol.nodeType] === NodeTypeEnum.elementNode ||
+				(node[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode && (<any>node).host)
+					? <Element>node
+					: null;
+			const children = rootElement ? [<Element>node] : (<Element>node)[PropertySymbol.elementArray];
+			const matches = this.findAll({ scope, rootElement, children, selectorItems, cachedItem });
+
+			for (const match of matches) {
+				if (!matchesMap.has(match.documentPosition)) {
+					matchesMap.set(match.documentPosition, match.element);
+					matchedPositions.push(match.documentPosition);
+				}
+			}
+		}
+
+		const keys = matchedPositions.sort();
+
+		for (let i = 0, max = keys.length; i < max; i++) {
+			items.push(matchesMap.get(keys[i])!);
+		}
+
+		return nodeList;
+	}
+
+	/**
+	 * Finds an element based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML element.
+	 */
+	public static querySelector<K extends keyof IHTMLElementTagNameMap>(
+		node: Element | Document | DocumentFragment,
+		selector: K
+	): IHTMLElementTagNameMap[K] | null;
+
+	/**
+	 * Finds an element based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML element.
+	 */
+	public static querySelector<K extends keyof ISVGElementTagNameMap>(
+		node: Element | Document | DocumentFragment,
+		selector: K
+	): ISVGElementTagNameMap[K] | null;
+
+	/**
+	 * Finds an element based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML element.
+	 */
+	public static querySelector<E extends Element = Element>(
+		node: Element | Document | DocumentFragment,
+		selector: string
+	): E | null;
+
+	/**
+	 * Finds an element based on a query selector.
+	 *
+	 * @param node Node to search in.
+	 * @param selector Selector.
+	 * @returns HTML element.
+	 */
+	public static querySelector(
+		node: Element | Document | DocumentFragment,
+		selector: string
+	): Element | null {
+		const window = node[PropertySymbol.window];
+
+		if (selector === '') {
+			throw new window.DOMException(
+				`Failed to execute 'querySelector' on '${node.constructor.name}': The provided selector is empty.`
+			);
+		}
+
+		if (typeof selector === 'function') {
+			throw new window.DOMException(
+				`Failed to execute 'querySelector' on '${node.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		if (typeof selector === 'symbol') {
+			throw new window.TypeError(
+				`Failed to execute 'querySelector' on '${node.constructor.name}': Cannot convert a Symbol value to a string`
+			);
+		}
+
+		selector = String(selector);
+
+		if (INVALID_SELECTOR_REGEXP.test(selector)) {
+			throw new window.DOMException(
+				`Failed to execute 'querySelector' on '${node.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		const cachedResult = node[PropertySymbol.cache].querySelector.get(selector);
+
+		if (cachedResult) {
+			if (cachedResult.result !== null) {
+				if (!cachedResult.result.element) {
+					return null;
+				}
+				const result = cachedResult.result.element.deref();
+				if (result) {
+					return result;
+				}
+			}
+			node[PropertySymbol.cache].querySelector.delete(selector);
+		}
+
+		const cachedItem: ICachedQuerySelectorItem = {
+			result: { element: null }
+		};
+
+		node[PropertySymbol.cache].querySelector.set(selector, cachedItem);
+
+		if (node[PropertySymbol.isConnected]) {
+			// Document is affected for the ":target" selector
+			(node[PropertySymbol.ownerDocument] || node)[PropertySymbol.affectsCache].push(cachedItem);
+			if (node[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode && (<any>node).host) {
+				(<any>node).host[PropertySymbol.affectsCache].push(cachedItem);
+			}
+		}
+
+		let bestMatch: DocumentPositionAndElement | null = null;
+		const matchesMap: Map<string, boolean> = new Map();
+		const scope =
+			node[PropertySymbol.nodeType] === NodeTypeEnum.documentNode
+				? (<Document>node).documentElement
+				: node;
+		const globalMatchFunction = this.globalMatchFunction;
+
+		for (const selectorItems of new SelectorParser({
+			window,
+			scope,
+			globalMatchFunction
+		}).getSelectorGroups(selector)) {
+			const rootElement =
+				node[PropertySymbol.nodeType] === NodeTypeEnum.elementNode ||
+				(node[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode && (<any>node).host)
+					? <Element>node
+					: null;
+			const children = rootElement ? [<Element>node] : (<Element>node)[PropertySymbol.elementArray];
+			const match = this.findFirst({ scope, rootElement, children, selectorItems, cachedItem });
+
+			if (match && !matchesMap.has(match.documentPosition)) {
+				matchesMap.set(match.documentPosition, true);
+				if (!bestMatch || match.documentPosition < bestMatch.documentPosition) {
+					bestMatch = match;
+				}
+			}
+		}
+
+		const element = bestMatch?.element || null;
+
+		cachedItem.result = { element: element ? new WeakRef(element) : null };
+
+		return element;
+	}
+
+	/**
+	 * Checks if an element matches a selector and returns priority weight.
+	 *
+	 * @param element Element to match.
+	 * @param selector Selector to match with.
+	 * @param [options] Options.
+	 * @param [options.scope] Scope.
+	 * @param [options.ignoreErrors] Ignores errors.
+	 * @returns Result.
+	 */
+	public static matches(
+		element: Element,
+		selector: string,
+		options?: { scope?: Element | Document | DocumentFragment | null; ignoreErrors?: boolean }
+	): ISelectorMatch | null {
+		const ignoreErrors = options?.ignoreErrors;
+		const window = element[PropertySymbol.window];
+
+		if (selector === '*') {
+			return {
+				priorityWeight: 1
+			};
+		}
+
+		if (<string>selector === '') {
+			if (ignoreErrors) {
+				return null;
+			}
+			throw new window.DOMException(
+				`Failed to execute 'matches' on '${element.constructor.name}': The provided selector is empty.`
+			);
+		}
+
+		if (typeof selector === 'function') {
+			if (ignoreErrors) {
+				return null;
+			}
+			throw new window.DOMException(
+				`Failed to execute 'matches' on '${element.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		if (typeof selector === 'symbol') {
+			if (ignoreErrors) {
+				return null;
+			}
+			throw new window.TypeError(`Cannot convert a Symbol value to a string`);
+		}
+
+		selector = String(selector);
+
+		if (INVALID_SELECTOR_REGEXP.test(selector)) {
+			if (ignoreErrors) {
+				return null;
+			}
+			throw new window.DOMException(
+				`Failed to execute 'matches' on '${element.constructor.name}': '${selector}' is not a valid selector.`
+			);
+		}
+
+		const cachedResult = element[PropertySymbol.cache].matches.get(selector);
+
+		if (cachedResult) {
+			if (cachedResult.result !== null) {
+				return cachedResult.result.match;
+			}
+			element[PropertySymbol.cache].matches.delete(selector);
+		}
+
+		const cachedItem: ICachedMatchesItem = {
+			result: { match: null }
+		};
+
+		element[PropertySymbol.cache].matches.set(selector, cachedItem);
+
+		if (element[PropertySymbol.isConnected]) {
+			// Document is affected for the ":target" selector
+			(element[PropertySymbol.ownerDocument] || element)[PropertySymbol.affectsCache].push(
+				cachedItem
+			);
+			if (
+				element[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode &&
+				(<any>element).host
+			) {
+				(<any>element).host[PropertySymbol.affectsCache].push(cachedItem);
+			}
+		}
+
+		const scopeOrElement = options?.scope || element;
+		const scope =
+			scopeOrElement[PropertySymbol.nodeType] === NodeTypeEnum.documentNode
+				? (<Document>scopeOrElement).documentElement
+				: scopeOrElement;
+		const globalMatchFunction = this.globalMatchFunction;
+		for (const items of new SelectorParser({
+			ignoreErrors: options?.ignoreErrors,
+			window,
+			scope,
+			globalMatchFunction
+		}).getSelectorGroups(selector)) {
+			const result = this.matchSelector({
+				scope,
+				element,
+				selectorItems: items.slice().reverse(),
+				cachedItem,
+				ignoreErrors
+			});
+
+			if (result) {
+				cachedItem.result!.match = result;
+				return result;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Checks if a node matches a selector.
+	 *
+	 * @param options Options.
+	 * @param options.scope Scope.
+	 * @param options.element Target element.
+	 * @param options.currentElement
+	 * @param options.selectorItems Selector items.
+	 * @param options.cachedItem Cached item.
+	 * @param [options.ignoreErrors] Ignores errors.
+	 * @param [previousSelectorItem] Previous selector item.
+	 * @param [priorityWeight] Priority weight.
+	 * @returns Result.
+	 */
+	private static matchSelector(
+		options: {
+			scope: Element | Document | DocumentFragment | null;
+			element: Element | ShadowRoot;
+			selectorItems: SelectorItem[];
+			cachedItem: ICachedMatchesItem;
+			ignoreErrors?: boolean;
+		},
+		previousSelectorItem: SelectorItem | null = null,
+		priorityWeight = 0
+	): ISelectorMatch | null {
+		const { scope, element, selectorItems, cachedItem, ignoreErrors } = options;
+		const selectorItem = selectorItems[0];
+
+		if (!selectorItem) {
+			return null;
+		}
+
+		const result = selectorItem.match(scope, element, ignoreErrors);
+
+		if (result) {
+			if (selectorItems.length === 1) {
+				return {
+					priorityWeight: priorityWeight + result.priorityWeight
+				};
+			}
+
+			switch (selectorItem.combinator) {
+				case SelectorCombinatorEnum.adjacentSibling:
+					const previousElementSibling = (<Element>element).previousElementSibling;
+					if (previousElementSibling) {
+						this.affectsCache(previousElementSibling, cachedItem);
+
+						const match = this.matchSelector(
+							{
+								scope,
+								element: previousElementSibling,
+								selectorItems: selectorItems.slice(1),
+								cachedItem: cachedItem,
+								ignoreErrors
+							},
+							selectorItem,
+							priorityWeight + result.priorityWeight
+						);
+
+						if (match) {
+							return match;
+						}
+					}
+					break;
+				case SelectorCombinatorEnum.none:
+				case SelectorCombinatorEnum.child:
+				case SelectorCombinatorEnum.descendant:
+					const parentElement = element.parentNode;
+					if (parentElement && parentElement !== element[PropertySymbol.ownerDocument]) {
+						this.affectsCache(<Element>parentElement, cachedItem);
+
+						const match = this.matchSelector(
+							{
+								scope,
+								element: <Element>parentElement,
+								selectorItems: selectorItems.slice(1),
+								cachedItem: cachedItem,
+								ignoreErrors
+							},
+							selectorItem,
+							priorityWeight + result.priorityWeight
+						);
+
+						if (match) {
+							return match;
+						}
+					}
+					break;
+				case SelectorCombinatorEnum.subsequentSibling:
+					const siblingParentElement = element.parentNode;
+					if (
+						siblingParentElement &&
+						siblingParentElement !== element[PropertySymbol.ownerDocument]
+					) {
+						const siblings = siblingParentElement[PropertySymbol.elementArray];
+						const index = siblings.indexOf(<Element>element);
+
+						this.affectsCache(<Element>siblingParentElement, cachedItem);
+
+						for (let i = index - 1; i >= 0; i--) {
+							const sibling = siblings[i];
+
+							sibling[PropertySymbol.affectsCache].push(cachedItem);
+
+							const match = this.matchSelector(
+								{
+									scope,
+									element: sibling,
+									selectorItems: selectorItems.slice(1),
+									cachedItem: cachedItem,
+									ignoreErrors
+								},
+								selectorItem,
+								priorityWeight + result.priorityWeight
+							);
+
+							if (match) {
+								return match;
+							}
+						}
+					}
+					break;
+			}
+		}
+
+		if (
+			previousSelectorItem?.combinator === SelectorCombinatorEnum.none ||
+			previousSelectorItem?.combinator === SelectorCombinatorEnum.descendant
+		) {
+			const parentElement = element.parentNode;
+			if (parentElement && parentElement !== element[PropertySymbol.ownerDocument]) {
+				return this.matchSelector(
+					{
+						scope,
+						element: <Element>parentElement,
+						selectorItems: selectorItems,
+						cachedItem: cachedItem,
+						ignoreErrors
+					},
+					previousSelectorItem,
+					priorityWeight
+				);
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Finds elements based on a query selector for a part of a list of selectors separated with comma.
+	 *
+	 * @param options Options.
+	 * @param options.scope Scope.
+	 * @param options.rootElement Root element.
+	 * @param options.children Child elements.
+	 * @param options.selectorItems Selector items.
+	 * @param options.cachedItem Cached item.
+	 * @param [documentPosition] Document position of the element.
+	 * @returns Document position and element map.
+	 */
+	private static findAll(
+		options: {
+			scope: Element | Document | DocumentFragment | null;
+			rootElement: Element | ShadowRoot | null;
+			children: Element[];
+			selectorItems: SelectorItem[];
+			cachedItem: ICachedQuerySelectorAllItem;
+		},
+		documentPosition?: string
+	): DocumentPositionAndElement[] {
+		const { scope, rootElement, children, selectorItems, cachedItem } = options;
+		const selectorItem = selectorItems[0];
+		const nextSelectorItem = selectorItems[1];
+		let matched: DocumentPositionAndElement[] = [];
+
+		if (!selectorItem) {
+			return [];
+		}
+
+		for (let i = 0, max = children.length; i < max; i++) {
+			const child = children[i];
+			const childrenOfChild = (<Element>child)[PropertySymbol.elementArray];
+			const position = (documentPosition ? documentPosition + '>' : '') + String.fromCharCode(i);
+
+			this.affectsCache(child, cachedItem);
+
+			if (selectorItem.match(scope, child)) {
+				if (!nextSelectorItem) {
+					if (rootElement !== child) {
+						matched.push({
+							documentPosition: position,
+							element: child
+						});
+					}
+				} else {
+					switch (nextSelectorItem.combinator) {
+						case SelectorCombinatorEnum.adjacentSibling:
+							const nextElementSibling = child.nextElementSibling;
+							if (nextElementSibling) {
+								matched = matched.concat(
+									this.findAll(
+										{
+											scope,
+											rootElement,
+											children: [nextElementSibling],
+											selectorItems: selectorItems.slice(1),
+											cachedItem: cachedItem
+										},
+										position
+									)
+								);
+							}
+							break;
+						case SelectorCombinatorEnum.none:
+						case SelectorCombinatorEnum.descendant:
+						case SelectorCombinatorEnum.child:
+							matched = matched.concat(
+								this.findAll(
+									{
+										scope,
+										rootElement,
+										children: childrenOfChild,
+										selectorItems: selectorItems.slice(1),
+										cachedItem
+									},
+									position
+								)
+							);
+							break;
+						case SelectorCombinatorEnum.subsequentSibling:
+							const index = children.indexOf(child);
+							for (let j = index + 1; j < children.length; j++) {
+								const sibling = children[j];
+								matched = matched.concat(
+									this.findAll(
+										{
+											scope,
+											rootElement,
+											children: [sibling],
+											selectorItems: selectorItems.slice(1),
+											cachedItem
+										},
+										position
+									)
+								);
+							}
+							break;
+					}
+				}
+			}
+
+			if (
+				(selectorItem.combinator === SelectorCombinatorEnum.none ||
+					selectorItem.combinator === SelectorCombinatorEnum.descendant) &&
+				childrenOfChild.length
+			) {
+				matched = matched.concat(
+					this.findAll(
+						{
+							scope,
+							rootElement,
+							children: childrenOfChild,
+							selectorItems: selectorItems,
+							cachedItem
+						},
+						position
+					)
+				);
+			}
+		}
+
+		return matched;
+	}
+
+	/**
+	 * Finds an element based on a query selector for a part of a list of selectors separated with comma.
+	 *
+	 * @param options Options.
+	 * @param options.scope Scope.
+	 * @param options.rootElement Root element.
+	 * @param options.children Child elements.
+	 * @param options.selectorItems Selector items.
+	 * @param options.cachedItem Cached item.
+	 * @param [documentPosition] Document position of the element.
+	 * @returns Document position and element map.
+	 */
+	private static findFirst(
+		options: {
+			scope: Element | Document | DocumentFragment | null;
+			rootElement: Element | ShadowRoot | null;
+			children: Element[];
+			selectorItems: SelectorItem[];
+			cachedItem: ICachedQuerySelectorItem;
+		},
+		documentPosition?: string
+	): DocumentPositionAndElement | null {
+		const { scope, rootElement, children, selectorItems, cachedItem } = options;
+		const selectorItem = selectorItems[0];
+		const nextSelectorItem = selectorItems[1];
+
+		if (!selectorItem) {
+			return null;
+		}
+
+		for (let i = 0, max = children.length; i < max; i++) {
+			const child = children[i];
+			const childrenOfChild = (<Element>child)[PropertySymbol.elementArray];
+			const position = (documentPosition ? documentPosition + '>' : '') + String.fromCharCode(i);
+
+			this.affectsCache(child, cachedItem);
+
+			if (selectorItem.match(scope, child)) {
+				if (!nextSelectorItem) {
+					if (rootElement !== child) {
+						return { documentPosition: position, element: child };
+					}
+				} else {
+					switch (nextSelectorItem.combinator) {
+						case SelectorCombinatorEnum.adjacentSibling:
+							const nextElementSibling = child.nextElementSibling;
+							if (nextElementSibling) {
+								const match = this.findFirst(
+									{
+										scope,
+										rootElement,
+										children: [nextElementSibling],
+										selectorItems: selectorItems.slice(1),
+										cachedItem
+									},
+									position
+								);
+								if (match) {
+									return match;
+								}
+							}
+							break;
+						case SelectorCombinatorEnum.none:
+						case SelectorCombinatorEnum.descendant:
+						case SelectorCombinatorEnum.child:
+							const match = this.findFirst(
+								{
+									scope,
+									rootElement,
+									children: childrenOfChild,
+									selectorItems: selectorItems.slice(1),
+									cachedItem
+								},
+								position
+							);
+							if (match) {
+								return match;
+							}
+							break;
+						case SelectorCombinatorEnum.subsequentSibling:
+							const index = children.indexOf(child);
+							for (let i = index + 1; i < children.length; i++) {
+								const sibling = children[i];
+								const match = this.findFirst(
+									{
+										scope,
+										rootElement,
+										children: [sibling],
+										selectorItems: selectorItems.slice(1),
+										cachedItem
+									},
+									position
+								);
+								if (match) {
+									return match;
+								}
+							}
+							break;
+					}
+				}
+			}
+
+			if (
+				(selectorItem.combinator === SelectorCombinatorEnum.none ||
+					selectorItem.combinator === SelectorCombinatorEnum.descendant) &&
+				childrenOfChild.length
+			) {
+				const match = this.findFirst(
+					{
+						scope,
+						rootElement,
+						children: childrenOfChild,
+						selectorItems,
+						cachedItem
+					},
+					position
+				);
+
+				if (match) {
+					return match;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Adds the cached item to the element's affectsCache and, if the element is a shadow root, also to its host's affectsCache.
+	 *
+	 * @param element Element.
+	 * @param cachedItem Cached item.
+	 */
+	private static affectsCache(element: Element | DocumentFragment, cachedItem: any): void {
+		element[PropertySymbol.affectsCache].push(cachedItem);
+		if (
+			element[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode &&
+			(<any>element).host
+		) {
+			(<any>element).host[PropertySymbol.affectsCache].push(cachedItem);
+		}
+	}
+}