@markuplint/ml-spec 4.10.2 → 5.0.0-alpha.0

package/lib/algorithm/aria/accname-computation.js

@@ -1,18 +1,141 @@
-// @ts-ignore
-import { computeAccessibleName } from 'dom-accessibility-api';
+import { computeAccessibleName } from './accname/compute.js';
+import { EMBEDDED_CONTROL_ROLES, escapeCSS } from './accname/helpers.js';
+import { isNativeEmbeddedControl } from '../../const/index.js';
+import { getComputedRole } from './get-computed-role.js';
 /**
- * Computes the accessible name for an element using the WAI-ARIA accessible name computation algorithm.
- * Falls back to the placeholder attribute value for input elements when no accessible name is found.
+ * [Implementation-specific] Reentrant guard to prevent infinite recursion when
+ * getComputedRole evaluates `:aria(has name)` selectors, which call back into getAccname.
+ *
+ * This breaks the cycle: `getAccname → createDomResolver → allowsNameFromContent
+ * → getComputedRole → getARIA → matches(":aria(has name)") → getAccname`.
+ *
+ * Module-level state is intentional: the guard must span the entire call stack
+ * within a single synchronous computation. `WeakSet` ensures no memory leaks
+ * (entries are GC'd with their Element), and `try/finally` in `getAccname`
+ * guarantees cleanup even on exceptions.
+ */
+const computingElements = new WeakSet();
+/**
+ * Computes the accessible name for a DOM `Element` using the AccName 1.2 algorithm.
+ *
+ * This is the public facade that bridges the pure AccName algorithm (in `accname/compute.ts`)
+ * with the DOM environment. It creates a DOM-based `AccnameResolver` and delegates to
+ * `computeAccessibleName`.
+ *
+ * **Reentrant guard**: Uses a `WeakSet<Element>` to detect and short-circuit
+ * recursive calls caused by the `:aria(has name)` pseudo-class selector in
+ * `getComputedRole` → `getARIA` → `matches` chain.
  *
  * @param el - The DOM element to compute the accessible name for
+ * @param specs - The ML specification data for role resolution
+ * @param version - The ARIA version to use for role computation
  * @returns The computed accessible name string, or an empty string if none is found
+ * @see https://www.w3.org/TR/accname-1.2/#computation-steps — AccName 1.2 §4.3.2
  */
 export function getAccname(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, specs, version) {
+    if (computingElements.has(el)) {
+        return '';
+    }
+    computingElements.add(el);
+    const resolver = createDomResolver(el, specs, version);
+    // try/finally ensures the reentrant guard (WeakSet) is cleaned up even
+    // when computeAccessibleName throws. This is NOT a try/catch — exceptions
+    // propagate to the caller (ml-core's getAccname catches them).
+    try {
+        const result = computeAccessibleName(el, resolver);
+        return result.name;
+    }
+    finally {
+        computingElements.delete(el);
+    }
+}
+/**
+ * Creates an `AccnameResolver` from a DOM Element's owner document.
+ *
+ * [Implementation-specific] This resolver bridges the pure AccName algorithm
+ * with the DOM API. It uses `getComputedRole` for spec-driven role resolution
+ * (determining `allowsNameFromContent` and `isEmbeddedControl`) instead of
+ * hardcoded role lists, ensuring accuracy across ARIA versions.
+ */
+function createDomResolver(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, specs, version) {
+    const root = getRootNode(el);
+    return {
+        getElementById(id) {
+            if ('getElementById' in root && typeof root.getElementById === 'function') {
+                return root.getElementById(id);
+            }
+            return root.querySelector(`[id="${escapeCSS(id)}"]`) ?? null;
+        },
+        getLabelsForId(id) {
+            const labels = root.querySelectorAll(`label[for="${escapeCSS(id)}"]`);
+            return [...labels];
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        allowsNameFromContent(target) {
+            // TODO: Remove cast when getComputedRole accepts AccnameElement (#3178)
+            const role = getComputedRole(specs, target, version);
+            return !!role.role?.accessibleNameFromContent;
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        isHidden(target) {
+            if (target.getAttribute('aria-hidden') === 'true') {
+                return true;
+            }
+            if (target.hasAttribute('hidden')) {
+                return true;
+            }
+            // Best-effort CSS visibility check (available in browser/JSDOM).
+            // getComputedStyle may throw on:
+            //   - SecurityError: cross-origin iframes
+            //   - TypeError: detached nodes not connected to a document
+            // These are expected operational failures. On error, fall through
+            // to return false (treat as visible). Attribute-based checks above
+            // (aria-hidden, hidden) are the primary detection for static analysis.
+            if (typeof getComputedStyle === 'function') {
+                try {
+                    // TODO: Remove cast when getComputedStyle dependency is decoupled (#3178)
+                    const style = getComputedStyle(target);
+                    if (style.display === 'none' || style.visibility === 'hidden') {
+                        return true;
+                    }
+                }
+                catch {
+                    // Swallowed intentionally: SecurityError or TypeError from
+                    // getComputedStyle is non-fatal. CSS hidden detection is
+                    // supplementary; attribute checks above cover static analysis.
+                }
+            }
+            return false;
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        isEmbeddedControl(target) {
+            // TODO: Remove cast when getComputedRole accepts AccnameElement (#3178)
+            const role = getComputedRole(specs, target, version);
+            if (role.role?.name && EMBEDDED_CONTROL_ROLES.has(role.role.name)) {
+                return true;
+            }
+            // Native HTML embedded controls without explicit role
+            return isNativeEmbeddedControl(target);
+        },
+    };
+}
+/**
+ * Walks up the DOM tree to find the root node (Document or DocumentFragment).
+ */
+function getRootNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {
-    const name = computeAccessibleName(el);
-    if (!name.trim() && el.nodeName === 'INPUT') {
-        return el.getAttribute('placeholder')?.trim() ?? '';
+    let root = el;
+    while (root.parentNode) {
+        root = root.parentNode;
+    }
+    if (root.nodeType === 9 || root.nodeType === 11) {
+        return root;
     }
-    return name;
+    // Fallback: if we reach a disconnected element, use ownerDocument
+    return el.ownerDocument;
 }

package/lib/algorithm/aria/aria-specs.d.ts

@@ -9,5 +9,6 @@ import type { ARIAVersion, MLMLSpec } from '../../types/index.js';
 export declare function ariaSpecs(specs: MLMLSpec, version: ARIAVersion): {
     readonly roles: readonly import("../../types/index.js").ARIARoleInSchema[];
     readonly graphicsRoles: readonly import("../../types/index.js").ARIARoleInSchema[];
+    readonly dpubRoles: readonly import("../../types/index.js").ARIARoleInSchema[];
     readonly props: readonly import("../../types/index.js").ARIAProperty[];
 };

package/lib/algorithm/aria/get-aria.js

@@ -25,7 +25,23 @@ export function getARIA(specs, localName, namespace, version, matches) {
     const conditionKeys = Object.keys(conditions);
     let { implicitRole, permittedRoles, implicitProperties, properties, namingProhibited } = aria;
     for (const cond of conditionKeys) {
-        if (!matches(cond)) {
+        let matched;
+        try {
+            matched = matches(cond);
+        }
+        catch (error) {
+            // Native Element.prototype.matches() cannot evaluate :aria()
+            // pseudo-class. When called from getImplicitRoleName() or
+            // getPermittedRoles() via accname-computation, native matches
+            // is used, which throws a DOMException (name: "SyntaxError").
+            // Note: JSDOM's DOMException is context-local, so instanceof
+            // checks against the global DOMException/SyntaxError fail.
+            if (error instanceof Error && error.name === 'SyntaxError') {
+                continue;
+            }
+            throw error;
+        }
+        if (!matched) {
             continue;
         }
         const condARIA = conditions[cond];
@@ -61,13 +77,13 @@ function getVersionResolvedARIA(specs, localName, namespace, version) {
     if (aria.permittedRoles !== false) {
         aria = {
             ...aria,
-            permittedRoles: optimizePermittedRoles(aria.permittedRoles),
+            permittedRoles: optimizePermittedRoles(aria.permittedRoles, version),
         };
     }
     cache.set(key, aria);
     return aria;
 }
-function optimizePermittedRoles(permittedRoles) {
+function optimizePermittedRoles(permittedRoles, version) {
     if (!Array.isArray(permittedRoles)) {
         return permittedRoles;
     }
@@ -79,5 +95,15 @@ function optimizePermittedRoles(permittedRoles) {
     if (unique.has('none')) {
         unique.add('presentation');
     }
-    return [...unique].sort();
+    // https://w3c.github.io/aria/#ref-for-image
+    // In ARIA 1.3, `image` is the primary role name and `img` is a synonym.
+    if (version === '1.3') {
+        if (unique.has('image')) {
+            unique.add('img');
+        }
+        if (unique.has('img')) {
+            unique.add('image');
+        }
+    }
+    return [...unique].toSorted();
 }

package/lib/algorithm/aria/get-computed-role.js

@@ -1,6 +1,7 @@
 import { ariaSpecs } from './aria-specs.js';
 import { isPresentational } from './is-presentational.js';
-import { getAccname } from './accname-computation.js';
+import { SVG_NAMESPACE } from '../../const/index.js';
+import { hasSvgAccessibleNameSource } from './accname/svg-helpers.js';
 import { getAttrSpecs } from '../../utils/get-attr-specs.js';
 import { getExplicitRole } from './get-explicit-role.js';
 import { getImplicitRole } from './get-implicit-role.js';
@@ -8,6 +9,24 @@ import { getNonPresentationalAncestor } from './get-non-presentational-ancestor.
 import { isRequiredOwnedElement } from './has-required-owned-elements.js';
 import { matchesContextRole } from './matches-context-role.js';
 import { mayBeFocusable } from '../html/may-be-focusable.js';
+/**
+ * Module-level cache for computed role results.
+ *
+ * Uses WeakMap so entries are automatically garbage-collected
+ * when the Element is released. Cache key format: `${version}:${assumeSingleNode}`.
+ *
+ * Invariants:
+ * - `specs` is always the same `MLMLSpec` instance within a document traversal,
+ *   so it is not included in the cache key.
+ * - Recursive calls from `computeRole` (via `getNonPresentationalAncestor`,
+ *   `matchesContextRole`, `isNativeContextIntact`) always traverse upward
+ *   in the DOM tree, so circular references cannot occur.
+ * - Cache entries become stale if an element's attributes are mutated after
+ *   computation. This is acceptable because markuplint operates on a static
+ *   document snapshot. External consumers that use the algorithm on a live
+ *   DOM with dynamic attribute mutations should be aware of this limitation.
+ */
+const computedRoleCache = new WeakMap();
 /**
  * Computes the final ARIA role for an element according to the WAI-ARIA specification,
  * applying the Presentational Roles Conflict Resolution algorithm. This considers
@@ -23,6 +42,25 @@ import { mayBeFocusable } from '../html/may-be-focusable.js';
 export function getComputedRole(specs, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, version, assumeSingleNode = false) {
+    const cacheKey = `${version}:${assumeSingleNode}`;
+    const elCache = computedRoleCache.get(el);
+    if (elCache) {
+        const cached = elCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    const result = computeRole(specs, el, version, assumeSingleNode);
+    const cache = elCache ?? new Map();
+    cache.set(cacheKey, result);
+    if (!elCache) {
+        computedRoleCache.set(el, cache);
+    }
+    return result;
+}
+function computeRole(specs, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, version, assumeSingleNode) {
     let lazyImplicitRole;
     const explicitRole = getExplicitRole(specs, el, version);
     const computedRole = explicitRole.role
@@ -48,24 +86,36 @@ el, version, assumeSingleNode = false) {
      * > 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.
+     * Determines whether the "Required Accessibility Parent Role" is valid
+     * (called "Required Context Role" in ARIA 1.2).
      *
-     * @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
+     * In ARIA 1.1/1.2, the spec had not decided whether the context
+     * is a parent or an ancestor. This implementation interprets that
+     * as A PARENT, but `presentation`/`none` elements are treated as
+     * transparent by `getNonPresentationalAncestor`.
      *
-     * 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.
+     * ARIA 1.3 formally resolves this with the definitions of
+     * "accessibility child" and "accessibility parent", and
+     * `matchesContextRole` additionally skips `generic` elements.
+     *
+     * @see https://w3c.github.io/aria/#scope
+     * @see https://github.com/w3c/aria/issues/1033
+     * @see https://github.com/w3c/aria/pull/1454
      */
-    if (computedRole.role && computedRole.role.requiredContextRole.length > 0) {
+    if (computedRole.role &&
+        computedRole.role.requiredAccessibilityParentRole.length > 0 &&
+        // For implicit roles in native HTML contexts, skip the context role check
+        // when the direct parent retains its native semantics (no explicit role override
+        // and its own computed role is non-null). This handles spec data mismatches
+        // such as <option> inside <select>, where the ARIA spec requires "listbox"
+        // context but the HTML-ARIA mapping gives <select> the "combobox" role.
+        // When the parent HAS an explicit role or its computed role is null (cascaded
+        // from an ancestor override like <table role="none">), the check proceeds
+        // normally so that role nullification cascades correctly.
+        !isNativeContextIntact(computedRole, el, specs, version)) {
         /**
          * An element fragment that serves as the root without a parent element
-         * cannot satisfy the "Required Context Role" condition.
+         * cannot satisfy the "Required Accessibility Parent Role" condition.
          * Therefore, under normal circumstances, the `role` will disappear.
          * However, in this specific case, it will fall back to both explicit
          * and implicit roles. Note that the explicit role takes precedence.
@@ -84,7 +134,7 @@ el, version, assumeSingleNode = false) {
                 errorType: 'NO_OWNER',
             };
         }
-        if (!matchesContextRole(computedRole.role.requiredContextRole, el, specs, version)) {
+        if (!matchesContextRole(computedRole.role.requiredAccessibilityParentRole, el, specs, version)) {
             return {
                 el,
                 role: null,
@@ -126,15 +176,12 @@ el, version, assumeSingleNode = false) {
     // It doesn't been specified a valid explicit role.
     (explicitRole.role === null || explicitRole.errorType != null) &&
         // It is an SVG element.
-        el.namespaceURI === 'http://www.w3.org/2000/svg') {
-        const accname = getAccname(el).trim() ||
-            [...el.children].find(child => ['title', 'desc'].includes(child.localName))?.textContent?.trim();
-        if (!accname) {
-            return {
-                el,
-                role: null,
-            };
-        }
+        el.namespaceURI === SVG_NAMESPACE &&
+        !hasSvgAccessibleNameSource(el)) {
+        return {
+            el,
+            role: null,
+        };
     }
     if (computedRole.role && !isPresentational(computedRole.role.name)) {
         return computedRole;
@@ -193,8 +240,8 @@ el, version, assumeSingleNode = false) {
     if (explicitRole.role) {
         const nonPresentationalAncestor = getNonPresentationalAncestor(el, specs, version);
         if (nonPresentationalAncestor.role &&
-            nonPresentationalAncestor.role?.requiredOwnedElements.length > 0 &&
-            nonPresentationalAncestor.role.requiredOwnedElements.some(expected => {
+            nonPresentationalAncestor.role?.allowedAccessibilityChildRoles.length > 0 &&
+            nonPresentationalAncestor.role.allowedAccessibilityChildRoles.some(expected => {
                 // const ancestor = nonPresentationalAncestor.el;
                 // const ancestorImplicitRole = getImplicitRole(specs, ancestor, version);
                 // console.log({ nonPresentationalAncestor, ancestorImplicitRole });
@@ -252,3 +299,36 @@ el, predicate) {
     }
     return list.some(predicate);
 }
+/**
+ * Checks whether an element with an implicit role is in its native HTML
+ * context — i.e., the direct parent has no explicit role override and
+ * its own computed role is non-null.
+ *
+ * When this returns `true`, the context role check can be safely skipped
+ * because the native HTML parent-child relationship is intact, even if
+ * the ARIA spec data has a mismatch (e.g., `<option>` requires "listbox"
+ * but `<select>` maps to "combobox").
+ *
+ * When the parent has an explicit role (e.g., `<table role="none">`) or
+ * its computed role is `null` (cascaded from an ancestor override), the
+ * context is NOT considered intact and the check should proceed.
+ */
+function isNativeContextIntact(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+computedRole, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, specs, version) {
+    if (!computedRole.role?.isImplicit) {
+        return false;
+    }
+    const parent = el.parentElement;
+    if (!parent) {
+        return false;
+    }
+    const parentExplicit = getExplicitRole(specs, parent, version);
+    if (parentExplicit.role) {
+        return false;
+    }
+    const parentComputed = getComputedRole(specs, parent, version);
+    return parentComputed.role !== null;
+}

package/lib/algorithm/aria/get-explicit-role.d.ts

@@ -1,2 +1,14 @@
 import type { ARIAVersion, ComputedRole, MLMLSpec } from '../../types/index.js';
+/**
+ * Resolves the ARIA role from the `role` attribute value, implementing the
+ * WAI-ARIA "Handling Author Errors" algorithm. Iterates through whitespace-separated
+ * role tokens and returns the first one that passes all validation checks
+ * (exists, non-abstract, permitted, valid landmark).
+ *
+ * @see https://w3c.github.io/aria/#document-handling_author-errors
+ * @param specs - The full markup language specification
+ * @param el - The DOM element to resolve the explicit role for
+ * @param version - The ARIA specification version to use
+ * @returns The first valid role found as a `ComputedRole`, or `role: null` with the last encountered error type
+ */
 export declare function getExplicitRole(specs: MLMLSpec, el: Element, version: ARIAVersion): ComputedRole;

package/lib/algorithm/aria/get-explicit-role.js

@@ -1,6 +1,18 @@
 import { getRoleSpec } from './get-role-spec.js';
 import { resolveNamespace } from '../../utils/resolve-namespace.js';
 import { getPermittedRoles } from './get-permitted-roles.js';
+/**
+ * Resolves the ARIA role from the `role` attribute value, implementing the
+ * WAI-ARIA "Handling Author Errors" algorithm. Iterates through whitespace-separated
+ * role tokens and returns the first one that passes all validation checks
+ * (exists, non-abstract, permitted, valid landmark).
+ *
+ * @see https://w3c.github.io/aria/#document-handling_author-errors
+ * @param specs - The full markup language specification
+ * @param el - The DOM element to resolve the explicit role for
+ * @param version - The ARIA specification version to use
+ * @returns The first valid role found as a `ComputedRole`, or `role: null` with the last encountered error type
+ */
 export function getExplicitRole(specs, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, version) {

package/lib/algorithm/aria/get-non-presentational-ancestor.d.ts

@@ -1,4 +1,16 @@
 import type { ARIAVersion, MLMLSpec } from '../../types/index.js';
+/**
+ * Traverses the parent element chain to find the nearest ancestor with a
+ * non-presentational role, skipping elements that are transparent for
+ * ownership traversal (via `isTransparentForOwnership`).
+ *
+ * In ARIA 1.3, `generic` role elements are additionally transparent.
+ *
+ * @param el - The DOM element whose ancestors to traverse
+ * @param specs - The full markup language specification
+ * @param version - The ARIA specification version to use
+ * @returns The nearest non-presentational ancestor's `ComputedRole`, or `{ el: null, role: null }` if none exists
+ */
 export declare function getNonPresentationalAncestor(el: Element, specs: MLMLSpec, version: ARIAVersion): import("../../types/index.js").ComputedRole | {
     el: null;
     role: null;

package/lib/algorithm/aria/get-non-presentational-ancestor.js

@@ -1,5 +1,17 @@
-import { isPresentational } from './is-presentational.js';
+import { isTransparentForOwnership } from './is-presentational.js';
 import { getComputedRole } from './get-computed-role.js';
+/**
+ * Traverses the parent element chain to find the nearest ancestor with a
+ * non-presentational role, skipping elements that are transparent for
+ * ownership traversal (via `isTransparentForOwnership`).
+ *
+ * In ARIA 1.3, `generic` role elements are additionally transparent.
+ *
+ * @param el - The DOM element whose ancestors to traverse
+ * @param specs - The full markup language specification
+ * @param version - The ARIA specification version to use
+ * @returns The nearest non-presentational ancestor's `ComputedRole`, or `{ el: null, role: null }` if none exists
+ */
 export function getNonPresentationalAncestor(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, specs, version) {
@@ -12,7 +24,7 @@ el, specs, version) {
     const assumeSingleNode = version !== '1.1' && version !== '1.2';
     while (ancestor) {
         const ancestorRole = getComputedRole(specs, ancestor, version, assumeSingleNode);
-        if (!isPresentational(ancestorRole.role?.name)) {
+        if (!isTransparentForOwnership(ancestorRole.role?.name, version)) {
             return ancestorRole;
         }
         ancestor = ancestor.parentElement;

package/lib/algorithm/aria/get-permitted-roles-spec.d.ts

@@ -1,10 +1,14 @@
 import type { ARIAVersion, Matches, MLMLSpec } from '../../types/index.js';
 /**
- * Getting permitted ARIA roles.
+ * Computes the list of permitted ARIA roles for an element at the spec level,
+ * operating on tag name and namespace rather than a DOM element.
  *
- * - If an array, it is role list.
- * - If `true`, this mean is "Any".
- * - If `false`, this mean is "No".
+ * @param specs - The full markup language specification
+ * @param localName - The element's local tag name
+ * @param namespace - The element's namespace URI
+ * @param version - The ARIA specification version to use
+ * @param matches - A function that tests CSS selector matches for conditional role resolution
+ * @returns A list of permitted roles, each with a `name` and optional `deprecated` flag
  */
 export declare function getPermittedRoles(specs: MLMLSpec, localName: string, namespace: string | null, version: ARIAVersion, matches: Matches): readonly {
     readonly name: string;

package/lib/algorithm/aria/get-permitted-roles-spec.js

@@ -4,11 +4,15 @@ import { mergeArray } from '../../utils/merge-array.js';
 import { ariaSpecs } from './aria-specs.js';
 import { getARIA } from './get-aria.js';
 /**
- * Getting permitted ARIA roles.
+ * Computes the list of permitted ARIA roles for an element at the spec level,
+ * operating on tag name and namespace rather than a DOM element.
  *
- * - If an array, it is role list.
- * - If `true`, this mean is "Any".
- * - If `false`, this mean is "No".
+ * @param specs - The full markup language specification
+ * @param localName - The element's local tag name
+ * @param namespace - The element's namespace URI
+ * @param version - The ARIA specification version to use
+ * @param matches - A function that tests CSS selector matches for conditional role resolution
+ * @returns A list of permitted roles, each with a `name` and optional `deprecated` flag
  */
 export function getPermittedRoles(specs, localName, namespace, version, matches) {
     const aria = getARIA(specs, localName, namespace, version, matches);
@@ -16,7 +20,7 @@ export function getPermittedRoles(specs, localName, namespace, version, matches)
         return [];
     }
     const { implicitRole, permittedRoles } = aria;
-    const { roles, graphicsRoles } = ariaSpecs(specs, version);
+    const { roles, graphicsRoles, dpubRoles } = ariaSpecs(specs, version);
     let permittedRoleList = [];
     if (permittedRoles === true) {
         permittedRoleList = mergeArray(permittedRoleList, roles
@@ -24,6 +28,11 @@ export function getPermittedRoles(specs, localName, namespace, version, matches)
             .map(role => ({
             name: role.name,
         })));
+        permittedRoleList = mergeArray(permittedRoleList, dpubRoles
+            .filter(role => !role.isAbstract)
+            .map(role => ({
+            name: role.name,
+        })));
     }
     if (isAAMInfo(permittedRoles)) {
         if (permittedRoles['core-aam']) {
@@ -54,7 +63,11 @@ export function getPermittedRoles(specs, localName, namespace, version, matches)
     if (implicitRole === false) {
         return permittedRoleList;
     }
-    const implicitRoles = implicitRole === 'presentation' || implicitRole === 'none' ? ['none', 'presentation'] : [implicitRole];
+    const implicitRoles = implicitRole === 'presentation' || implicitRole === 'none'
+        ? ['none', 'presentation']
+        : version === '1.3' && (implicitRole === 'img' || implicitRole === 'image')
+            ? ['image', 'img']
+            : [implicitRole];
     return mergeArray(implicitRoles.map(r => ({ name: r })), permittedRoleList);
 }
 function isAAMInfo(permittedRoles) {

package/lib/algorithm/aria/get-role-spec.js

@@ -16,12 +16,16 @@ export function getRoleSpec(specs, roleName, namespace, version) {
         return null;
     }
     const superClassRoles = recursiveTraverseSuperClassRoles(specs, roleName, namespace, version);
+    const requiredAccessibilityParentRole = role.requiredContextRole ?? role.requiredAccessibilityParentRole ?? [];
+    const allowedAccessibilityChildRoles = role.requiredOwnedElements ?? role.allowedAccessibilityChildRoles ?? [];
     return {
         name: role.name,
         isAbstract: !!role.isAbstract,
         deprecated: !!role.deprecated,
-        requiredContextRole: role.requiredContextRole ?? [],
-        requiredOwnedElements: role.requiredOwnedElements ?? [],
+        requiredAccessibilityParentRole,
+        allowedAccessibilityChildRoles,
+        requiredContextRole: requiredAccessibilityParentRole,
+        requiredOwnedElements: allowedAccessibilityChildRoles,
         accessibleNameRequired: !!role.accessibleNameRequired,
         accessibleNameFromAuthor: !!role.accessibleNameFromAuthor,
         accessibleNameFromContent: !!role.accessibleNameFromContent,
@@ -51,10 +55,13 @@ function getSuperClassRoles(specs, roleName, namespace, version) {
         .filter((role) => !!role) ?? null);
 }
 function getRoleByName(specs, roleName, namespace, version) {
-    const { roles, graphicsRoles } = ariaSpecs(specs, version);
+    const { roles, graphicsRoles, dpubRoles } = ariaSpecs(specs, version);
     let role = roles.find(r => r.name === roleName);
     if (!role && namespace === 'http://www.w3.org/2000/svg') {
         role = graphicsRoles.find(r => r.name === roleName);
     }
+    if (!role) {
+        role = dpubRoles.find(r => r.name === roleName);
+    }
     return role;
 }

package/lib/algorithm/aria/has-required-owned-elements.d.ts

@@ -1,6 +1,7 @@
 import type { ARIAVersion, ComputedRole, MLMLSpec } from '../../types/index.js';
 /**
- * Checks whether an element satisfies the "Required Owned Elements" constraint
+ * Checks whether an element satisfies the "Allowed Accessibility Child Roles"
+ * constraint (called "Required Owned Elements" in ARIA 1.2)
  * defined by its computed ARIA role. An element satisfies this constraint if it
  * has `aria-owns`, or if any of its closest non-presentational descendants match
  * the required owned element roles.