@markuplint/ml-spec 2.1.1 → 3.0.0-alpha.1

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

@@ -0,0 +1,112 @@
+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_roles
+	 */
+	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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,85 @@
+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;
+}

package/src/dom-traverse/may-be-focusable.ts

@@ -0,0 +1,21 @@
+import type { MLMLSpec } from '../types';
+
+import { getSelectorsByContentModelCategory } from '../specs/get-selectors-by-content-model-category';
+
+export function mayBeFocusable(el: Element, specs: Readonly<MLMLSpec>): boolean {
+	return [
+		/**
+		 * Interactive content
+		 *
+		 * @see  https://html.spec.whatwg.org/multipage/dom.html#interactive-content
+		 */
+		...getSelectorsByContentModelCategory(specs, '#interactive'),
+		/**
+		 * Interaction
+		 *
+		 * @see  https://html.spec.whatwg.org/multipage/interaction.html
+		 */
+		'[tabindex]',
+		'[contenteditable]:not([contenteditable="false" i])',
+	].some(selector => el.matches(selector));
+}

package/src/index.ts

@@ -1,7 +1,19 @@
-export * from './permitted-structres';
-export * from './attributes';
-export * from './get-attr-specs';
-export * from './get-spec-by-tag-name';
-export * from './get-spec';
-export * from './get-ns';
+export * from './dom-traverse/accname-computation';
+export * from './dom-traverse/get-attr-specs';
+export * from './dom-traverse/get-computed-role';
+export * from './dom-traverse/get-content-model';
+export * from './dom-traverse/get-implicit-role';
+export * from './dom-traverse/get-permitted-roles';
+export * from './dom-traverse/get-spec';
+export * from './dom-traverse/has-required-owned-elements';
+export * from './dom-traverse/may-be-focusable';
+export * from './specs/aria-specs';
+export * from './specs/content-model-category-to-tag-names';
+export * from './specs/get-role-spec';
+export * from './specs/get-spec-by-tag-name';
+export * from './specs/schema-to-spec';
 export * from './types';
+export * from './types/aria';
+export * from './types/attributes';
+export * from './types/permitted-structures';
+export * from './utils/resolve-namespace';

package/src/specs/aria-specs.ts

@@ -0,0 +1,6 @@
+import type { ARIAVersion, MLMLSpec } from '../types';
+
+export function ariaSpecs(specs: Readonly<MLMLSpec>, version: ARIAVersion) {
+	const aria = specs.def['#aria'];
+	return aria[version];
+}

package/src/specs/content-model-category-to-tag-names.ts

@@ -0,0 +1,15 @@
+import type { MLMLSpec } from '../types';
+import type { Category } from '../types/permitted-structures';
+
+const cache = new Map<Category, ReadonlyArray<string>>();
+
+export function contentModelCategoryToTagNames(contentModel: Category, def: MLMLSpec['def']): ReadonlyArray<string> {
+	const cached = cache.get(contentModel);
+	if (cached) {
+		return cached;
+	}
+	const tags: string[] | undefined = def['#contentModels'][contentModel];
+	const sortedTag = Object.freeze(tags && Array.isArray(tags) ? tags.sort() : []);
+	cache.set(contentModel, sortedTag);
+	return sortedTag;
+}

package/src/specs/get-aria.ts

@@ -0,0 +1,85 @@
+import type { ARIAVersion, Matches, MLMLSpec } from '../types';
+import type { ARIA, PermittedRoles } from '../types/aria';
+
+import { getSpecByTagName } from './get-spec-by-tag-name';
+import { resolveVersion } from './resolve-version';
+
+const cache = new Map<string, Omit<ARIA, ARIAVersion> | null>();
+
+export function getARIA(
+	specs: Readonly<MLMLSpec>,
+	localName: string,
+	namespace: string | null,
+	version: ARIAVersion,
+	matches: Matches,
+): Omit<ARIA, ARIAVersion | 'conditions'> | null {
+	const aria = getVersionResolvedARIA(specs, localName, namespace, version);
+	if (!aria) {
+		return null;
+	}
+	const conditions = aria.conditions;
+	if (!conditions) {
+		return aria;
+	}
+	const conditionKeys = Object.keys(conditions);
+	let { implicitRole, permittedRoles, implicitProperties, properties, namingProhibited } = aria;
+	for (const cond of conditionKeys) {
+		if (!matches(cond)) {
+			continue;
+		}
+		const condARIA = conditions[cond];
+		implicitRole = condARIA.implicitRole ?? implicitRole;
+		permittedRoles = condARIA.permittedRoles ?? permittedRoles;
+		implicitProperties = condARIA.implicitProperties ?? implicitProperties;
+		properties = condARIA.properties ?? properties;
+		namingProhibited = condARIA.namingProhibited ?? namingProhibited;
+	}
+	return {
+		implicitRole,
+		permittedRoles,
+		implicitProperties,
+		properties,
+		namingProhibited,
+	};
+}
+
+function getVersionResolvedARIA(
+	specs: Readonly<MLMLSpec>,
+	localName: string,
+	namespace: string | null,
+	version: ARIAVersion,
+) {
+	const key = localName + namespace + version;
+	let aria = cache.get(key);
+	if (aria !== undefined) {
+		return aria;
+	}
+	const spec = getSpecByTagName(specs.specs, localName, namespace)?.aria;
+	if (!spec) {
+		cache.set(key, null);
+		return null;
+	}
+	aria = resolveVersion(spec, version);
+	if (aria.permittedRoles) {
+		aria.permittedRoles = optimizePermittedRoles(aria.permittedRoles);
+	}
+	cache.set(key, aria);
+	return aria;
+}
+
+function optimizePermittedRoles(permittedRoles: PermittedRoles) {
+	if (!Array.isArray(permittedRoles)) {
+		return permittedRoles;
+	}
+	const unique = new Set(permittedRoles);
+
+	// https://www.w3.org/TR/wai-aria-1.2/#note-regarding-the-aria-1-1-none-role
+	if (unique.has('presentation')) {
+		unique.add('none');
+	}
+	if (unique.has('none')) {
+		unique.add('presentation');
+	}
+
+	return Array.from(unique).sort();
+}

package/src/{get-attr-specs.spec.ts → specs/get-attr-specs.spec.ts}

@@ -4,10 +4,9 @@ import { getAttrSpecs } from './get-attr-specs';
 
 describe('getSpec', () => {
 	test('svg:image[x]', () => {
-		const specs = getAttrSpecs('svg:image', htmlSpec);
+		const specs = getAttrSpecs('image', 'http://www.w3.org/2000/svg', htmlSpec);
 		const x = specs?.find(spec => spec.name === 'x');
 		expect(x).toStrictEqual({
-			ref: 'https://svgwg.org/svg2-draft/geometry.html#XProperty',
 			defaultValue: '0',
 			name: 'x',
 			type: ['<svg-length>', '<percentage>'],
@@ -16,10 +15,9 @@ describe('getSpec', () => {
 	});
 
 	test('svg:foreignObject[x]', () => {
-		const specs = getAttrSpecs('svg:foreignObject', htmlSpec);
+		const specs = getAttrSpecs('foreignObject', 'http://www.w3.org/2000/svg', htmlSpec);
 		const x = specs?.find(spec => spec.name === 'x');
 		expect(x).toStrictEqual({
-			ref: 'https://svgwg.org/svg2-draft/geometry.html#XProperty',
 			defaultValue: '0',
 			description:
 				'The x coordinate of the foreignObject. Value type: <length>|<percentage> ; Default value: 0; Animatable: yes',
@@ -30,10 +28,9 @@ describe('getSpec', () => {
 	});
 
 	test('svg:linearGradient[xlink:href]', () => {
-		const specs = getAttrSpecs('svg:linearGradient', htmlSpec);
+		const specs = getAttrSpecs('linearGradient', 'http://www.w3.org/2000/svg', htmlSpec);
 		const x = specs?.find(spec => spec.name === 'xlink:href');
 		expect(x).toStrictEqual({
-			ref: 'https://www.w3.org/TR/xlink11/#link-locators',
 			description:
 				'Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.An <IRI> reference to another <linearGradient> element that will be used as a template. Value type: <IRI> ; Default value: none; Animatable: yes',
 			name: 'xlink:href',
@@ -43,7 +40,7 @@ describe('getSpec', () => {
 	});
 
 	test('img[fetchpriority] (experimental spec)', () => {
-		const attrs = getAttrSpecs('img', htmlSpec);
+		const attrs = getAttrSpecs('img', null, htmlSpec);
 		const fetchpriority = attrs?.find(attr => attr.name === 'fetchpriority');
 		expect(fetchpriority?.experimental).toBe(true);
 	});

package/src/{get-attr-specs.ts → specs/get-attr-specs.ts}

@@ -1,14 +1,19 @@
-import type { MLMLSpec, Attribute } from './types';
+import type { MLMLSpec, Attribute } from '../types';
+import type { NamespaceURI } from '@markuplint/ml-ast';
+
+import { resolveNamespace } from '../utils/resolve-namespace';
 
 const cacheMap = new Map<string, Attribute[] | null>();
 const schemaCache = new WeakSet<MLMLSpec>();
 
-export function getAttrSpecs(nameWithNS: string, schema: MLMLSpec) {
+export function getAttrSpecs(localName: string, namespace: NamespaceURI | null, schema: MLMLSpec) {
 	if (!schemaCache.has(schema)) {
 		cacheMap.clear();
 	}
 
-	const cache = cacheMap.get(nameWithNS);
+	const { localNameWithNS } = resolveNamespace(localName, namespace || undefined);
+
+	const cache = cacheMap.get(localNameWithNS);
 
 	if (cache !== undefined) {
 		return cache;
@@ -16,9 +21,9 @@ export function getAttrSpecs(nameWithNS: string, schema: MLMLSpec) {
 
 	schemaCache.add(schema);
 
-	const elSpec = schema.specs.find(spec => spec.name === nameWithNS);
+	const elSpec = schema.specs.find(spec => spec.name === localNameWithNS);
 	if (!elSpec) {
-		cacheMap.set(nameWithNS, null);
+		cacheMap.set(localNameWithNS, null);
 		return null;
 	}
 
@@ -78,7 +83,7 @@ export function getAttrSpecs(nameWithNS: string, schema: MLMLSpec) {
 	for (const attr of attrList) {
 		if (!attr.type) {
 			throw new Error(
-				`The type is empty in the ${attr.name} attribute of the ${nameWithNS} element,
+				`The type is empty in the ${attr.name} attribute of the ${localName} element,
 					'packages',
 					'@markuplint',
 					'html-spec',
@@ -92,7 +97,7 @@ export function getAttrSpecs(nameWithNS: string, schema: MLMLSpec) {
 
 	attrList.sort(nameCompare);
 
-	cacheMap.set(nameWithNS, attrList);
+	cacheMap.set(localNameWithNS, attrList);
 	return attrList;
 }
 

package/src/specs/get-implicit-role.spec.ts

@@ -0,0 +1,81 @@
+import type { ARIAVersion } from '../types';
+
+import specs from '@markuplint/html-spec';
+import { createSelector } from '@markuplint/selector';
+import { createJSDOMElement } from '@markuplint/test-tools';
+
+import { getImplicitRole } from './get-implicit-role';
+
+function c(html: string, version: ARIAVersion) {
+	const el = createJSDOMElement(html);
+	return getImplicitRole(
+		specs,
+		el.localName,
+		el.namespaceURI,
+		version,
+		selector => !!createSelector(selector, specs).match(el),
+	);
+}
+
+describe('getImplicitRole', () => {
+	test('the a element', () => {
+		expect(c('<a></a>', '1.2')).toBe(false);
+		expect(c('<a name="foo"></a>', '1.2')).toBe(false);
+		expect(c('<a href></a>', '1.2')).toBe('link');
+		expect(c('<a href=""></a>', '1.2')).toBe('link');
+		expect(c('<a href="path/to"></a>', '1.2')).toBe('link');
+	});
+
+	test('the area element', () => {
+		expect(c('<area />', '1.2')).toBe(false);
+		expect(c('<area shape="rect" />', '1.2')).toBe(false);
+		expect(c('<area href />', '1.2')).toBe('link');
+		expect(c('<area href="" />', '1.2')).toBe('link');
+		expect(c('<area href="path/to" />', '1.2')).toBe('link');
+	});
+
+	test('the article element', () => {
+		expect(c('<article></article>', '1.2')).toBe('article');
+	});
+
+	test('the aside element', () => {
+		expect(c('<aside></aside>', '1.2')).toBe('complementary');
+	});
+
+	test('the audio element', () => {
+		expect(c('<audio></audio>', '1.2')).toBe(false);
+	});
+
+	test('the h1 element', () => {
+		expect(c('<h1></h1>', '1.2')).toBe('heading');
+	});
+
+	test('the header element', () => {
+		expect(c('<header></header>', '1.2')).toBe('banner');
+		expect(c('<header><article></article></header>', '1.2')).toBe('generic');
+		expect(c('<header><article></article></header>', '1.1')).toBe(false);
+		expect(c('<header><div></div></header>', '1.2')).toBe('banner');
+		expect(c('<header><div role="article"></div></header>', '1.2')).toBe('generic');
+		expect(c('<header><div role="article"></div></header>', '1.1')).toBe(false);
+	});
+
+	test('the img element', () => {
+		expect(c('<img />', '1.2')).toBe('img');
+		expect(c('<img alt />', '1.2')).toBe('presentation');
+		expect(c('<img alt="" />', '1.2')).toBe('presentation');
+		expect(c('<img alt="foo" />', '1.2')).toBe('img');
+		expect(c('<img aria-label="foo" />', '1.2')).toBe('img');
+	});
+
+	test('the form element', () => {
+		expect(c('<form></form>', '1.2')).toBe('form');
+		expect(c('<form></form>', '1.1')).toBe(false);
+		expect(c('<form aria-label="foo"></form>', '1.2')).toBe('form');
+		expect(c('<form aria-label="foo"></form>', '1.1')).toBe('form');
+	});
+
+	test('the section element', () => {
+		expect(c('<section></section>', '1.2')).toBe(false);
+		expect(c('<section aria-label="foo"></section>', '1.2')).toBe('region');
+	});
+});

package/src/specs/get-implicit-role.ts

@@ -0,0 +1,17 @@
+import type { ARIAVersion, Matches, MLMLSpec } from '../types';
+
+import { getARIA } from './get-aria';
+
+export function getImplicitRole(
+	specs: Readonly<MLMLSpec>,
+	localName: string,
+	namespace: string | null,
+	version: ARIAVersion,
+	matches: Matches,
+) {
+	const aria = getARIA(specs, localName, namespace, version, matches);
+	if (!aria) {
+		return false;
+	}
+	return aria.implicitRole;
+}