@markuplint/ml-spec 3.0.0-dev.24 → 3.0.0-dev.38

package/src/dom-traverse/get-computed-role.spec.ts

@@ -1,134 +0,0 @@
-import type { ARIAVersion } from '../types';
-
-import specs from '@markuplint/html-spec';
-import { createSelector } from '@markuplint/selector';
-import { createJSDOMElement } from '@markuplint/test-tools';
-
-import { getComputedRole } from './get-computed-role';
-
-function _(html: string, selector?: string) {
-	return createJSDOMElement(html, selector, function (selector) {
-		// JSDOM supports no level 4 selectors yet.
-		return !!createSelector(selector, specs).match(this);
-	});
-}
-
-function c(html: string, version: ARIAVersion, selector?: string) {
-	return getComputedRole(specs, _(html, selector), version);
-}
-
-function tree(html: string, version: ARIAVersion) {
-	const el = _(html);
-	const tree: [string, string | null][] = [];
-	let current: Element | null = el;
-	while (current) {
-		tree.push([current.localName, getComputedRole(specs, current, version).role?.name || null]);
-		current = current.children.item(0);
-	}
-	return tree;
-}
-
-describe('getComputedRole', () => {
-	test('the a element', () => {
-		expect(c('<a></a>', '1.2').role?.name).toBe(undefined);
-		expect(c('<a href></a>', '1.2').role?.name).toBe('link');
-		expect(c('<a role="button"></a>', '1.2').role?.name).toBe('button');
-		expect(c('<a role="button" href></a>', '1.2').role?.name).toBe('button');
-		expect(c('<a role="foo" href></a>', '1.2').role?.name).toBe('link');
-	});
-
-	test('the heading role', () => {
-		expect(c('<h1></h1>', '1.2').role?.name).toBe('heading');
-		expect(c('<h1></h1>', '1.2').role?.isImplicit).toBe(true);
-		expect(c('<div role="heading"></div>', '1.2').role?.name).toBe('heading');
-		expect(c('<div role="heading"></div>', '1.2').role?.isImplicit).toBe(false);
-	});
-
-	test('multiple', () => {
-		expect(c('<div role="presentation heading"></div>', '1.2').role?.name).toBe('presentation');
-		expect(c('<div role="roletype heading"></div>', '1.2').role?.name).toBe('heading');
-		expect(c('<img alt="alt" role="banner button"/>', '1.2').role?.name).toBe('button');
-		expect(c('<img alt="alt" role="foo button"/>', '1.2').role?.name).toBe('button');
-		expect(c('<img alt="alt" role="graphics-symbol button"/>', '1.2').role?.name).toBe('button');
-	});
-
-	test('svg', () => {
-		expect(c('<svg><rect role="graphics-symbol img"></rect></svg>', '1.2', 'rect').role?.name).toBe(
-			'graphics-symbol',
-		);
-		expect(c('<svg><rect role="roletype img"></rect></svg>', '1.2', 'rect').role?.name).toBe('img');
-		expect(c('<svg><rect role="roletype"></rect></svg>', '1.2', 'rect').role?.name).toBe('graphics-symbol');
-	});
-
-	test('landmark', () => {
-		expect(c('<div role="region"></div>', '1.2').role?.name).toBe('generic');
-		expect(c('<div role="region" aria-label="foo"></div>', '1.2').role?.name).toBe('region');
-		expect(c('<div role="form"></div>', '1.2').role?.name).toBe('generic');
-		expect(c('<div role="form" aria-label="foo"></div>', '1.2').role?.name).toBe('form');
-		expect(c('<div role="navigation"></div>', '1.2').role?.name).toBe('navigation');
-		expect(c('<div role="navigation" aria-label="foo"></div>', '1.2').role?.name).toBe('navigation');
-	});
-
-	test('Presentational Roles Conflict Resolution (1) Interactive Elements', () => {
-		expect(c('<a href="path/to"></a>', '1.2').role?.name).toBe('link');
-		expect(c('<a role="none" href="path/to"></a>', '1.2').role?.name).toBe('link'); // No permitted role
-		expect(c('<a></a>', '1.2').role?.name).toBe(undefined);
-		expect(c('<a role="none"></a>', '1.2').role?.name).toBe('none');
-		expect(c('<a role="none" href="path/to" disabled></a>', '1.2').role?.name).toBe('link'); // No permitted role
-		expect(c('<button></button>', '1.2').role?.name).toBe('button');
-		expect(c('<button disabled></button>', '1.2').role?.name).toBe('button');
-		expect(c('<button role="none"></button>', '1.2').role?.name).toBe('button'); // No permitted role
-		expect(c('<button role="none" disabled></button>', '1.2').role?.name).toBe('button'); // No permitted role
-		expect(c('<div></div>', '1.2').role?.name).toBe('generic');
-		expect(c('<div role="none"></div>', '1.2').role?.name).toBe('none');
-		expect(c('<div tabindex="0"></div>', '1.2').role?.name).toBe('generic');
-		expect(c('<div tabindex="0" role="none"></div>', '1.2').role?.name).toBe('generic');
-		expect(c('<div><span></span></div>', '1.2', 'span').role?.name).toBe(undefined);
-		expect(c('<div><span role="none"></span></div>', '1.2', 'span').role?.name).toBe('none');
-		expect(c('<div><span tabindex="0"></span></div>', '1.2', 'span').role?.name).toBe(undefined);
-		expect(c('<div><span tabindex="0" role="none"></span></div>', '1.2', 'span').role?.name).toBe(undefined);
-		expect(c('<div hidden><span></span></div>', '1.2', 'span').role?.name).toBe(undefined);
-		expect(c('<div hidden><span role="none"></span></div>', '1.2', 'span').role?.name).toBe('none');
-		expect(c('<div hidden><span tabindex="0"></span></div>', '1.2', 'span').role?.name).toBe(undefined);
-		expect(c('<div hidden><span tabindex="0" role="none"></span></div>', '1.2', 'span').role?.name).toBe('none');
-	});
-
-	test('Presentational Roles Conflict Resolution (2-1) Required Owned Elements', () => {
-		expect(c('<table><tr><td>foo</td></tr></table>', '1.2', 'td').role?.name).toBe('cell');
-		expect(c('<table><tr><td role="none">foo</td></tr></table>', '1.2', 'td').role?.name).toBe('cell');
-		expect(c('<table><tbody role="none"><tr><td>foo</td></tr></tbody></table>', '1.2', 'tbody').role?.name).toBe(
-			'rowgroup',
-		);
-		expect(c('<ul><li></li></ul>', '1.2', 'li').role?.name).toBe('listitem');
-		expect(c('<ul><li role="presentation"></li></ul>', '1.2', 'li').role?.name).toBe('listitem');
-	});
-
-	test('Presentational Roles Conflict Resolution (2-2) the accessibility tree to be malformed', () => {
-		expect(c('<table><tr><td>foo</td></tr></table>', '1.2', 'td').role?.name).toBe('cell');
-		expect(c('<table role="none"><tr><td>foo</td></tr></table>', '1.2', 'td').role?.name).toBe(undefined);
-		expect(tree('<table><tr><td>foo</td></tr></table>', '1.2')).toStrictEqual([
-			['table', 'table'],
-			['tbody', 'rowgroup'],
-			['tr', 'row'],
-			['td', 'cell'],
-		]);
-		expect(tree('<table role="none"><tr><td>foo</td></tr></table>', '1.2')).toStrictEqual([
-			['table', 'none'],
-			['tbody', null],
-			['tr', null],
-			['td', null],
-		]);
-	});
-
-	test('Presentational Roles Conflict Resolution (3) Global Props', () => {
-		/**
-		 * @see https://w3c.github.io/aria/#example-41
-		 */
-		expect(c('<h1 role="presentation" aria-describedby="comment-1"> Sample Content </h1>', '1.2').role?.name).toBe(
-			'heading',
-		);
-		expect(c('<h1 role="presentation" aria-level="2"> Sample Content </h1>', '1.2').role?.name).toBe(
-			'presentation',
-		);
-	});
-});

package/src/dom-traverse/get-computed-role.ts

@@ -1,181 +0,0 @@
-import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
-
-import { ariaSpecs } from '../specs/aria-specs';
-import { isPresentational } from '../specs/is-presentational';
-
-import { getAttrSpecs } from './get-attr-specs';
-import { getExplicitRole } from './get-explicit-role';
-import { getImplicitRole } from './get-implicit-role';
-import { getNonPresentationalAncestor } from './get-non-presentational-ancestor';
-import { isRequiredOwnedElement } from './has-required-owned-elements';
-import { mayBeFocusable } from './may-be-focusable';
-
-export function getComputedRole(specs: Readonly<MLMLSpec>, el: Element, version: ARIAVersion): ComputedRole {
-	const implicitRole = getImplicitRole(specs, el, version);
-	const explicitRole = getExplicitRole(specs, el, version);
-	const computedRole = explicitRole.role ? explicitRole : implicitRole;
-
-	/**
-	 * Presentational Roles Conflict Resolution
-	 *
-	 * @see https://www.w3.org/TR/wai-aria/#conflict_resolution_presentation_none
-	 * @see https://w3c.github.io/aria/#conflict_resolution_presentation_none
-	 */
-
-	/**
-	 * > If the action of exposing the explicit role
-	 * > causes the accessibility tree to be malformed,
-	 * > the expected results are undefined.
-	 *
-	 * Determines whether the context is valid.
-	 * ⚠ THE SPECIFICATION HAS AN ISSUE
-	 * that has not decided whether the context is a parent or an ancestor.
-	 *
-	 * @see https://github.com/w3c/aria/issues/1033
-	 * @see https://github.com/w3c/aria/issues/748
-	 * @see https://github.com/w3c/aria/pull/1162
-	 * @see https://github.com/w3c/aria/pull/1213
-	 *
-	 * Currently, this process interprets that as A PARENT
-	 * because it wants to be near to HTML semantics.
-	 * However, the presentational role behaves transparently
-	 * according to the sample code in WAI-ARIA specification.
-	 */
-	if (computedRole.role?.requiredContextRole.length) {
-		const nonPresentationalAncestor = getNonPresentationalAncestor(el, specs, version);
-		if (!nonPresentationalAncestor.role) {
-			return {
-				el,
-				role: null,
-				errorType: 'NO_OWNER',
-			};
-		}
-		if (!computedRole.role?.requiredContextRole.includes(nonPresentationalAncestor.role.name)) {
-			return {
-				el,
-				role: null,
-				errorType: 'INVALID_REQUIRED_CONTEXT_ROLE',
-			};
-		}
-	}
-
-	if (computedRole.role && !isPresentational(computedRole.role.name)) {
-		return computedRole;
-	}
-
-	/**
-	 * > If an element is focusable,
-	 * > user agents MUST ignore the presentation/none role
-	 * > and expose the element with its implicit role,
-	 * > in order to ensure that the element is operable.
-	 *
-	 * With the issue: What does focusable or otherwise interactive mean](https://github.com/w3c/aria/issues/1192)
-	 *
-	 * - Focus: https://html.spec.whatwg.org/multipage/interaction.html#focus
-	 * - Interactive content: https://html.spec.whatwg.org/multipage/dom.html#interactive-content
-	 */
-	if (
-		/**
-		 * If interactive element
-		 *
-		 * 1. It may be focusable
-		 *
-		 * THIS CONDITION IS ALMOST MEANINGLESS.
-		 * Because it has already been determined that
-		 * the interactive elements can not specify the presentational role
-		 * in the previous processing that computes the permitted role (`getExplicitRole`).
-		 */
-		mayBeFocusable(el, specs) &&
-		/**
-		 * 2. No disabled
-		 */
-		!someAncestors(el, p => isEnabledAttr(p, specs, 'disabled')) &&
-		/**
-		 * 3. No inert
-		 */
-		!someAncestors(el, p => isEnabledAttr(p, specs, 'inert')) &&
-		/**
-		 * 4. No hidden
-		 */
-		!someAncestors(el, p => isEnabledAttr(p, specs, 'hidden'))
-	) {
-		return {
-			...implicitRole,
-			errorType: 'INTERACTIVE_ELEMENT_MUST_NOT_BE_PRESENTATIONAL',
-		};
-	}
-
-	/**
-	 * > If a required owned element has an explicit non-presentational role,
-	 * > user agents MUST ignore an inherited presentational role
-	 * > and expose the element with its explicit role.
-	 *
-	 * In other words,
-	 * if the element has `role=presentation` and
-	 * the role of the parent element has a required owned element,
-	 * `role=presentation` is to be ignored absolutely.
-	 */
-	if (explicitRole.role) {
-		const nonPresentationalAncestor = getNonPresentationalAncestor(el, specs, version);
-		if (nonPresentationalAncestor.role?.requiredOwnedElements.length) {
-			if (
-				nonPresentationalAncestor.role.requiredOwnedElements.some(expected => {
-					// const ancestor = nonPresentationalAncestor.el;
-					// const ancestorImplicitRole = getImplicitRole(specs, ancestor, version);
-					// console.log({ nonPresentationalAncestor, ancestorImplicitRole });
-					return isRequiredOwnedElement(implicitRole, expected, specs, version);
-				})
-			) {
-				return {
-					...implicitRole,
-					errorType: 'REQUIRED_OWNED_ELEMENT_MUST_NOT_BE_PRESENTATIONAL',
-				};
-			}
-		}
-	}
-
-	/**
-	 * > If an element has global WAI-ARIA states or properties,
-	 * > user agents MUST ignore the presentation role
-	 * > and instead expose the element's implicit role.
-	 * > However, if an element has only non-global,
-	 * > role-specific WAI-ARIA states or properties,
-	 * > the element MUST NOT be exposed
-	 * > unless the presentational role is inherited
-	 * > and an explicit non-presentational role is applied.
-	 */
-	const { props } = ariaSpecs(specs, version);
-	for (const attr of Array.from(el.attributes)) {
-		if (props.find(p => p.name === attr.name)?.isGlobal) {
-			return {
-				...implicitRole,
-				errorType: 'GLOBAL_PROP_MUST_NOT_BE_PRESENTATIONAL',
-			};
-		}
-	}
-
-	return computedRole;
-}
-
-/**
- * The attribute is available in its owner element,
- * it has the attribute.
- */
-function isEnabledAttr(el: Element, specs: MLMLSpec, attrName: string) {
-	const attrs = getAttrSpecs(el, specs);
-	const attr = attrs?.find(attr => attr.name === attrName);
-	return !!attr && el.hasAttribute(attrName);
-}
-
-/**
- * Determines whether some ancestors match the condition that the specified callback function.
- */
-function someAncestors(el: Element, predicate: (ancestor: Element) => boolean) {
-	const list: Element[] = [];
-	let current: Element | null = el;
-	while (current) {
-		list.push(current);
-		current = current.parentElement;
-	}
-	return list.some(predicate);
-}

package/src/dom-traverse/get-content-model.ts

@@ -1,32 +0,0 @@
-import type { ElementSpec } from '../types';
-import type { PermittedContentPattern } from '../types/permitted-structures';
-
-import { getSpec } from './get-spec';
-
-type Specs = Pick<ElementSpec, 'name' | 'contentModel'>[];
-
-const cachesBySpecs = new Map<Specs, Map<Element, PermittedContentPattern[] | boolean | null>>();
-export function getContentModel(el: Element, specs: Pick<ElementSpec, 'name' | 'contentModel'>[]) {
-	const cacheByEl = cachesBySpecs.get(specs) ?? new Map<Element, PermittedContentPattern[] | boolean>();
-	const cached = cacheByEl.get(el);
-	if (cached) {
-		return cached;
-	}
-
-	const spec = getSpec<'contentModel'>(el, specs);
-	if (!spec) {
-		cacheByEl.set(el, null);
-		return null;
-	}
-
-	const conditions = spec.contentModel.conditional ?? [];
-	for (const cond of conditions) {
-		if (el.matches(cond.condition)) {
-			cacheByEl.set(el, cond.contents);
-			return cond.contents;
-		}
-	}
-
-	cacheByEl.set(el, spec.contentModel.contents);
-	return spec.contentModel.contents;
-}

package/src/dom-traverse/get-explicit-role.ts

@@ -1,112 +0,0 @@
-import type { ARIAVersion, ComputedRole, MLMLSpec, RoleComputationError } from '../types';
-
-import { getRoleSpec } from '../specs/get-role-spec';
-import { resolveNamespace } from '../utils/resolve-namespace';
-
-import { getPermittedRoles } from './get-permitted-roles';
-
-export function getExplicitRole(specs: MLMLSpec, el: Element, version: ARIAVersion): ComputedRole {
-	const roleValue = el.getAttribute('role');
-	const roleNames = roleValue?.toLowerCase().trim().split(/\s+/g) || [];
-	const permittedRoles = getPermittedRoles(el, version, specs);
-	const { namespaceURI } = resolveNamespace(el.localName, el.namespaceURI);
-
-	let error: RoleComputationError = 'NO_EXPLICIT';
-
-	/**
-	 * Resolve from values and **Handling Author Errors**
-	 *
-	 * @see https://w3c.github.io/aria/#document-handling_author-errors
-	 */
-	for (const roleName of roleNames) {
-		const spec = getRoleSpec(specs, roleName, namespaceURI, version);
-
-		/**
-		 * If `spec` is null, the role DOES NOT EXIST.
-		 *
-		 * > If the role attribute contains no tokens matching the name
-		 * > of a non-abstract WAI-ARIA role,
-		 * > the user agent MUST treat the element as
-		 * > if no role had been provided. For example,
-		 * > <table role="foo"> should be exposed
-		 * > in the same way as <table> and <input type="text" role="structure">
-		 * > in the same way as <input type="text">.
-		 */
-		if (!spec) {
-			error = 'ROLE_NO_EXISTS';
-			continue;
-		}
-
-		/**
-		 * > As stated in the Definition of Roles section,
-		 * > it is considered an authoring error to use abstract roles in content.
-		 * > User agents MUST NOT map abstract roles
-		 * > via the standard role mechanism of the accessibility API.
-		 */
-		if (spec.isAbstract) {
-			error = 'ABSTRACT';
-			continue;
-		}
-
-		/**
-		 * Whether the role is the permitted role according to ARIA in HTML.
-		 */
-		if (!permittedRoles.some(r => r.name === roleName)) {
-			error = 'NO_PERMITTED';
-			continue;
-		}
-
-		/**
-		 * > Certain landmark roles require names from authors.
-		 * > In situations where an author has not specified names for these landmarks,
-		 * > it is considered an authoring error.
-		 * > The user agent MUST treat such elements as if no role had been provided.
-		 * > If a valid fallback role had been specified,
-		 * > or if the element had an implicit ARIA role,
-		 * > then user agents would continue to expose that role, instead.
-		 */
-		if (isLandmarkRole(spec) && !isValidLandmarkRole(el, spec)) {
-			error = 'INVALID_LANDMARK';
-			continue;
-		}
-
-		/**
-		 * Otherwise
-		 */
-		return {
-			el,
-			role: {
-				...spec,
-				isImplicit: false,
-			},
-		};
-	}
-
-	return {
-		el,
-		role: null,
-		errorType: error,
-	};
-}
-
-function isLandmarkRole(role: NonNullable<ReturnType<typeof getRoleSpec>>) {
-	return role?.superClassRoles.some(su => su.name === 'landmark');
-}
-
-function isValidLandmarkRole(el: Element, role: NonNullable<ReturnType<typeof getRoleSpec>>) {
-	if (!role.accessibleNameRequired) {
-		return true;
-	}
-	if (role.accessibleNameFromAuthor) {
-		if (el.getAttribute('aria-label')) {
-			return true;
-		}
-		const id = el.getAttribute('aria-labelledby');
-		if (id && el.ownerDocument.getElementById(id)) {
-			return true;
-		}
-	}
-	// The landmark role does not require names from the content
-	// if (role.accessibleNameFromContent) {}
-	return false;
-}

package/src/dom-traverse/get-implicit-role.ts

@@ -1,36 +0,0 @@
-import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
-
-import { getImplicitRole as _getImplicitRole } from '../specs/get-implicit-role';
-import { getRoleSpec } from '../specs/get-role-spec';
-import { resolveNamespace } from '../utils/resolve-namespace';
-
-export function getImplicitRole(specs: Readonly<MLMLSpec>, el: Element, version: ARIAVersion): ComputedRole {
-	const implicitRole = getImplicitRoleName(el, version, specs);
-	if (implicitRole === false) {
-		// No Corresponding Role
-		return {
-			el,
-			role: null,
-		};
-	}
-	const { namespaceURI } = resolveNamespace(el.localName, el.namespaceURI);
-	const spec = getRoleSpec(specs, implicitRole, namespaceURI, version);
-	if (!spec) {
-		return {
-			el,
-			role: null,
-			errorType: 'IMPLICIT_ROLE_NAMESPACE_ERROR',
-		};
-	}
-	return {
-		el,
-		role: {
-			...spec,
-			isImplicit: true,
-		},
-	};
-}
-
-export function getImplicitRoleName(el: Element, version: ARIAVersion, specs: Readonly<MLMLSpec>) {
-	return _getImplicitRole(specs, el.localName, el.namespaceURI, version, el.matches.bind(el));
-}

package/src/dom-traverse/get-non-presentational-ancestor.ts

@@ -1,20 +0,0 @@
-import type { ARIAVersion, MLMLSpec } from '../types';
-
-import { isPresentational } from '../specs/is-presentational';
-
-import { getComputedRole } from './get-computed-role';
-
-export function getNonPresentationalAncestor(el: Element, specs: MLMLSpec, version: ARIAVersion) {
-	let ancestor: Element | null = el.parentElement;
-	while (ancestor) {
-		const ancestorRole = getComputedRole(specs, ancestor, version);
-		if (!isPresentational(ancestorRole.role?.name)) {
-			return ancestorRole;
-		}
-		ancestor = ancestor.parentElement;
-	}
-	return {
-		el: ancestor,
-		role: null,
-	};
-}

package/src/dom-traverse/get-permitted-roles.ts

@@ -1,7 +0,0 @@
-import type { ARIAVersion, MLMLSpec } from '../types';
-
-import { getPermittedRoles as _getPermittedRoles } from '../specs/get-permitted-roles';
-
-export function getPermittedRoles(el: Element, version: ARIAVersion, specs: Readonly<MLMLSpec>) {
-	return _getPermittedRoles(specs, el.localName, el.namespaceURI, version, el.matches.bind(el));
-}

package/src/dom-traverse/get-spec.ts

@@ -1,7 +0,0 @@
-import type { ElementSpec } from '../types';
-
-import { getSpecByTagName } from '../specs/get-spec-by-tag-name';
-
-export function getSpec<K extends keyof ElementSpec>(el: Element, specs: Pick<ElementSpec, 'name' | K>[]) {
-	return getSpecByTagName(specs, el.localName, el.namespaceURI);
-}

package/src/dom-traverse/has-required-owned-elements.spec.ts

@@ -1,36 +0,0 @@
-import type { ARIAVersion } from '../types';
-
-import specs from '@markuplint/html-spec';
-import { createSelector } from '@markuplint/selector';
-import { createJSDOMElement } from '@markuplint/test-tools';
-
-import { hasRequiredOwnedElement } from './has-required-owned-elements';
-
-function _(html: string, selector?: string) {
-	return createJSDOMElement(html, selector, function (selector) {
-		// JSDOM supports no level 4 selectors yet.
-		return !!createSelector(selector, specs).match(this);
-	});
-}
-
-function m(html: string, version: ARIAVersion, selector?: string) {
-	const el = _(html, selector);
-	return hasRequiredOwnedElement(el, specs, version);
-}
-
-describe('matchesOwnedRole', () => {
-	test('rowgroup > row', () => {
-		expect(m('<table><tbody><tr><td></td></tr></tbody></table>', '1.2')).toBe(true);
-	});
-	test('row', () => {
-		expect(m('<table><tr><td></td></tr></table>', '1.2', 'tr')).toBe(true);
-	});
-	test('list > listitem', () => {
-		expect(m('<ul><li></li></ul>', '1.2')).toBe(true);
-		expect(m('<ul><div><li></li></div></ul>', '1.2')).toBe(false);
-		expect(m('<ul><div role="none"><li></li></div></ul>', '1.2')).toBe(true);
-		expect(
-			m('<ul><div role="none"><div role="none"><div role="none"><li></li></div></div></div></ul>', '1.2'),
-		).toBe(true);
-	});
-});

package/src/dom-traverse/has-required-owned-elements.ts

@@ -1,85 +0,0 @@
-import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
-
-import { isPresentational } from '../specs/is-presentational';
-
-import { getComputedRole } from './get-computed-role';
-import { getExplicitRole } from './get-explicit-role';
-import { getImplicitRole } from './get-implicit-role';
-
-export function hasRequiredOwnedElement(el: Element, specs: Readonly<MLMLSpec>, version: ARIAVersion): boolean {
-	/**
-	 * The element has aria-owns which means it may have owned elements.
-	 *
-	 * THIS CONDITION IS PARTIAL SUPPORT.
-	 */
-	if (el.hasAttribute('aria-owns')) {
-		// FIXME
-		return true;
-	}
-
-	/**
-	 * Otherwise, traverses descendants to find owned elements.
-	 */
-	const computed = getComputedRole(specs, el, version);
-	if (!computed.role || computed.role.requiredOwnedElements.length === 0) {
-		return true;
-	}
-	for (const expectRole of computed.role.requiredOwnedElements) {
-		for (const owned of getClosestNonPresentationalDescendants(el, specs, version)) {
-			if (isRequiredOwnedElement(owned, expectRole, specs, version)) {
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-export function isRequiredOwnedElement(owned: ComputedRole, query: string, specs: MLMLSpec, version: ARIAVersion) {
-	const [baseRole, owningRole] = query.split(' > ') as [string, string | undefined];
-	if (owned.role?.name !== baseRole) {
-		return false;
-	}
-
-	if (!owningRole) {
-		return true;
-	}
-
-	for (const owning of getClosestNonPresentationalDescendants(owned.el, specs, version)) {
-		if (owning.role?.name === owningRole) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Gets the list of closest non-presentational descendants.
- * ⚠ THE SPECIFICATION HAS AN ISSUE
- * that has not decided whether the owned element is a child or a descendant.
- *
- * @see https://github.com/w3c/aria/issues/1033
- * @see https://github.com/w3c/aria/issues/748
- * @see https://github.com/w3c/aria/pull/1162
- * @see https://github.com/w3c/aria/pull/1213
- *
- * Currently, this process interprets that as A CHILD
- * because it wants to be near to HTML semantics.
- * However, the presentational role behaves transparently
- * according to the sample code in WAI-ARIA specification.
- */
-function getClosestNonPresentationalDescendants(el: Element, specs: MLMLSpec, version: ARIAVersion): ComputedRole[] {
-	const owned: ComputedRole[] = [];
-	for (const child of Array.from(el.children)) {
-		const implicitRole = getImplicitRole(specs, child, version);
-		const explicitRole = getExplicitRole(specs, child, version);
-		const computed = explicitRole.role ? explicitRole : implicitRole;
-		if (isPresentational(computed.role?.name)) {
-			owned.push(...getClosestNonPresentationalDescendants(child, specs, version));
-			continue;
-		}
-		owned.push({ ...computed, el: child });
-	}
-	return owned;
-}