@markuplint/ml-spec 2.0.1 → 3.0.0-alpha.82

package/lib/dom-traverse/accname-computation.d.ts

@@ -0,0 +1 @@
+export declare function getAccname(el: Element): string;

package/lib/dom-traverse/accname-computation.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccname = void 0;
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+function getAccname(el) {
+    return (0, dom_accessibility_api_1.computeAccessibleName)(el);
+}
+exports.getAccname = getAccname;

package/lib/dom-traverse/focusability-computation.d.ts

@@ -0,0 +1 @@
+export declare function isFocusable(el: Element): boolean;

package/lib/dom-traverse/focusability-computation.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFocusable = void 0;
+const tabbable_1 = require("tabbable");
+function isFocusable(el) {
+    return (0, tabbable_1.isFocusable)(el, { displayCheck: 'none' });
+}
+exports.isFocusable = isFocusable;

package/lib/dom-traverse/get-aria.d.ts

@@ -0,0 +1,9 @@
+import type { ARIAVersion, Matches, MLMLSpec } from '../types';
+import type { ARIA } from '../types/aria';
+export declare function getARIA(
+	specs: Readonly<MLMLSpec>,
+	localName: string,
+	namespace: string | null,
+	version: ARIAVersion,
+	matches: Matches,
+): Omit<ARIA, ARIAVersion | 'conditions'> | null;

package/lib/dom-traverse/get-aria.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getARIA = void 0;
+const html_spec_1 = require("../specs/html-spec");
+const resolve_version_1 = require("../specs/resolve-version");
+const cache = new Map();
+function getARIA(specs, localName, namespace, version, matches) {
+    var _a, _b, _c, _d, _e;
+    const aria = getVersionResolvedARIA(specs, localName, namespace, version);
+    if (!aria) {
+        return null;
+    }
+    const conditions = aria.conditions;
+    if (!conditions) {
+        return aria;
+    }
+    const conds = Object.keys(conditions);
+    let { implicitRole, permittedRoles, implicitProperties, properties, namingProhibited } = aria;
+    for (const cond of conds) {
+        if (!matches(cond)) {
+            continue;
+        }
+        const condARIA = conditions[cond];
+        implicitRole = (_a = condARIA.implicitRole) !== null && _a !== void 0 ? _a : implicitRole;
+        permittedRoles = (_b = condARIA.permittedRoles) !== null && _b !== void 0 ? _b : permittedRoles;
+        implicitProperties = (_c = condARIA.implicitProperties) !== null && _c !== void 0 ? _c : implicitProperties;
+        properties = (_d = condARIA.properties) !== null && _d !== void 0 ? _d : properties;
+        namingProhibited = (_e = condARIA.namingProhibited) !== null && _e !== void 0 ? _e : namingProhibited;
+    }
+    return {
+        implicitRole,
+        permittedRoles,
+        implicitProperties,
+        properties,
+        namingProhibited,
+    };
+}
+exports.getARIA = getARIA;
+function getVersionResolvedARIA(specs, localName, namespace, version) {
+    var _a;
+    const key = localName + namespace + version;
+    let aria = cache.get(key);
+    if (aria !== undefined) {
+        return aria;
+    }
+    const spec = (_a = (0, html_spec_1.htmlSpec)(specs, localName, namespace)) === null || _a === void 0 ? void 0 : _a.aria;
+    if (!spec) {
+        cache.set(key, null);
+        return null;
+    }
+    aria = (0, resolve_version_1.resolveVersion)(spec, version);
+    cache.set(key, aria);
+    return aria;
+}

package/lib/dom-traverse/get-attr-specs.d.ts

@@ -0,0 +1,2 @@
+import type { MLMLSpec } from '../types';
+export declare function getAttrSpecs(el: Element, schema: MLMLSpec): import("../types").Attribute[] | null;

package/lib/dom-traverse/get-attr-specs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttrSpecs = void 0;
+const get_attr_specs_1 = require("../specs/get-attr-specs");
+function getAttrSpecs(el, schema) {
+    return (0, get_attr_specs_1.getAttrSpecs)(el.localName, el.namespaceURI, schema);
+}
+exports.getAttrSpecs = getAttrSpecs;

package/lib/dom-traverse/get-computed-role.d.ts

@@ -0,0 +1,2 @@
+import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
+export declare function getComputedRole(specs: Readonly<MLMLSpec>, el: Element, version: ARIAVersion): ComputedRole;

package/lib/dom-traverse/get-computed-role.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComputedRole = void 0;
+const aria_specs_1 = require("../specs/aria-specs");
+const get_selectors_by_content_model_category_1 = require("../specs/get-selectors-by-content-model-category");
+const is_presentational_1 = require("../specs/is-presentational");
+const get_attr_specs_1 = require("./get-attr-specs");
+const get_explicit_role_1 = require("./get-explicit-role");
+const get_implicit_role_1 = require("./get-implicit-role");
+const get_non_presentational_ancestor_1 = require("./get-non-presentational-ancestor");
+const has_required_owned_elements_1 = require("./has-required-owned-elements");
+function getComputedRole(specs, el, version) {
+    var _a, _b, _c, _d;
+    const implicitRole = (0, get_implicit_role_1.getImplicitRole)(specs, el, version);
+    const explicitRole = (0, get_explicit_role_1.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 ((_a = computedRole.role) === null || _a === void 0 ? void 0 : _a.requiredContextRole.length) {
+        const nonPresentationalAncestor = (0, get_non_presentational_ancestor_1.getNonPresentationalAncestor)(el, specs, version);
+        if (!nonPresentationalAncestor.role) {
+            return {
+                el,
+                role: null,
+                errorType: 'NO_OWNER',
+            };
+        }
+        if (!((_b = computedRole.role) === null || _b === void 0 ? void 0 : _b.requiredContextRole.includes(nonPresentationalAncestor.role.name))) {
+            return {
+                el,
+                role: null,
+                errorType: 'INVALID_REQUIRED_CONTEXT_ROLE',
+            };
+        }
+    }
+    if (computedRole.role && !(0, is_presentational_1.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 (
+    /**
+     * Interactive element
+     */
+    [
+        /**
+         * Interactive content
+         *
+         * THIS CONDITION(SELECTORS) 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`).
+         *
+         * @see  https://html.spec.whatwg.org/multipage/dom.html#interactive-content
+         */
+        ...(0, get_selectors_by_content_model_category_1.getSelectorsByContentModelCategory)(specs, '#interactive'),
+        /**
+         * Interaction
+         *
+         * @see  https://html.spec.whatwg.org/multipage/interaction.html
+         */
+        '[tabindex]',
+        '[contenteditable]:not([contenteditable="false" i])',
+    ].some(selector => el.matches(selector)) &&
+        /**
+         * No disabled
+         */
+        !someAncestors(el, p => isEnabledAttr(p, specs, 'disabled')) &&
+        /**
+         * No inert
+         */
+        !someAncestors(el, p => isEnabledAttr(p, specs, 'inert')) &&
+        /**
+         * 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 = (0, get_non_presentational_ancestor_1.getNonPresentationalAncestor)(el, specs, version);
+        if ((_c = nonPresentationalAncestor.role) === null || _c === void 0 ? void 0 : _c.requiredOwnedElements.length) {
+            if (nonPresentationalAncestor.role.requiredOwnedElements.some(expected => {
+                // const ancestor = nonPresentationalAncestor.el;
+                // const ancestorImplicitRole = getImplicitRole(specs, ancestor, version);
+                // console.log({ nonPresentationalAncestor, ancestorImplicitRole });
+                return (0, has_required_owned_elements_1.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 } = (0, aria_specs_1.ariaSpecs)(specs, version);
+    for (const attr of Array.from(el.attributes)) {
+        if ((_d = props.find(p => p.name === attr.name)) === null || _d === void 0 ? void 0 : _d.isGlobal) {
+            return {
+                ...implicitRole,
+                errorType: 'GLOBAL_PROP_MUST_NOT_BE_PRESENTATIONAL',
+            };
+        }
+    }
+    return computedRole;
+}
+exports.getComputedRole = getComputedRole;
+/**
+ * The attribute is available in its owner element,
+ * it has the attribute.
+ */
+function isEnabledAttr(el, specs, attrName) {
+    const attrs = (0, get_attr_specs_1.getAttrSpecs)(el, specs);
+    const attr = attrs === null || attrs === void 0 ? void 0 : 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, predicate) {
+    const list = [];
+    let current = el;
+    while (current) {
+        list.push(current);
+        current = current.parentElement;
+    }
+    return list.some(predicate);
+}

package/lib/dom-traverse/get-explicit-role.d.ts

@@ -0,0 +1,2 @@
+import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
+export declare function getExplicitRole(specs: MLMLSpec, el: Element, version: ARIAVersion): ComputedRole;

package/lib/dom-traverse/get-explicit-role.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExplicitRole = void 0;
+const get_role_spec_1 = require("../specs/get-role-spec");
+const resolve_namespace_1 = require("../utils/resolve-namespace");
+const get_permitted_roles_1 = require("./get-permitted-roles");
+function getExplicitRole(specs, el, version) {
+    const roleValue = el.getAttribute('role');
+    const roleNames = (roleValue === null || roleValue === void 0 ? void 0 : roleValue.toLowerCase().trim().split(/\s+/g)) || [];
+    const permittedRoles = (0, get_permitted_roles_1.getPermittedRoles)(el, version, specs);
+    const { namespaceURI } = (0, resolve_namespace_1.resolveNamespace)(el.localName, el.namespaceURI);
+    let error = '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 = (0, get_role_spec_1.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,
+    };
+}
+exports.getExplicitRole = getExplicitRole;
+function isLandmarkRole(role) {
+    return role === null || role === void 0 ? void 0 : role.superClassRoles.some(su => su.name === 'landmark');
+}
+function isValidLandmarkRole(el, role) {
+    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/lib/dom-traverse/get-implicit-role.d.ts

@@ -0,0 +1,3 @@
+import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
+export declare function getImplicitRole(specs: Readonly<MLMLSpec>, el: Element, version: ARIAVersion): ComputedRole;
+export declare function getImplicitRoleName(el: Element, version: ARIAVersion, specs: Readonly<MLMLSpec>): import("..").ImplicitRole;

package/lib/dom-traverse/get-implicit-role.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplicitRoleName = exports.getImplicitRole = void 0;
+const get_implicit_role_1 = require("../specs/get-implicit-role");
+const get_role_spec_1 = require("../specs/get-role-spec");
+const resolve_namespace_1 = require("../utils/resolve-namespace");
+function getImplicitRole(specs, el, version) {
+    const implicitRole = getImplicitRoleName(el, version, specs);
+    if (implicitRole === false) {
+        // No Corresponding Role
+        return {
+            el,
+            role: null,
+        };
+    }
+    const { namespaceURI } = (0, resolve_namespace_1.resolveNamespace)(el.localName, el.namespaceURI);
+    const spec = (0, get_role_spec_1.getRoleSpec)(specs, implicitRole, namespaceURI, version);
+    if (!spec) {
+        return {
+            el,
+            role: null,
+            errorType: 'IMPLICIT_ROLE_NAMESPACE_ERROR',
+        };
+    }
+    return {
+        el,
+        role: {
+            ...spec,
+            isImplicit: true,
+        },
+    };
+}
+exports.getImplicitRole = getImplicitRole;
+function getImplicitRoleName(el, version, specs) {
+    return (0, get_implicit_role_1.getImplicitRole)(specs, el.localName, el.namespaceURI, version, el.matches.bind(el));
+}
+exports.getImplicitRoleName = getImplicitRoleName;

package/lib/dom-traverse/get-non-presentational-ancestor.d.ts

@@ -0,0 +1,5 @@
+import type { ARIAVersion, MLMLSpec } from '../types';
+export declare function getNonPresentationalAncestor(el: Element, specs: MLMLSpec, version: ARIAVersion): import("../types").ComputedRole | {
+    el: null;
+    role: null;
+};

package/lib/dom-traverse/get-non-presentational-ancestor.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNonPresentationalAncestor = void 0;
+const is_presentational_1 = require("../specs/is-presentational");
+const get_computed_role_1 = require("./get-computed-role");
+function getNonPresentationalAncestor(el, specs, version) {
+    var _a;
+    let ancestor = el.parentElement;
+    while (ancestor) {
+        const ancestorRole = (0, get_computed_role_1.getComputedRole)(specs, ancestor, version);
+        if (!(0, is_presentational_1.isPresentational)((_a = ancestorRole.role) === null || _a === void 0 ? void 0 : _a.name)) {
+            return ancestorRole;
+        }
+        ancestor = ancestor.parentElement;
+    }
+    return {
+        el: ancestor,
+        role: null,
+    };
+}
+exports.getNonPresentationalAncestor = getNonPresentationalAncestor;

package/lib/dom-traverse/get-permitted-roles.d.ts

@@ -0,0 +1,5 @@
+import type { ARIAVersion, MLMLSpec } from '../types';
+export declare function getPermittedRoles(el: Element, version: ARIAVersion, specs: Readonly<MLMLSpec>): {
+    name: string;
+    deprecated?: boolean | undefined;
+}[];

package/lib/dom-traverse/get-permitted-roles.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermittedRoles = void 0;
+const get_permitted_roles_1 = require("../specs/get-permitted-roles");
+function getPermittedRoles(el, version, specs) {
+    return (0, get_permitted_roles_1.getPermittedRoles)(specs, el.localName, el.namespaceURI, version, el.matches.bind(el));
+}
+exports.getPermittedRoles = getPermittedRoles;

package/lib/dom-traverse/get-spec.d.ts

@@ -0,0 +1,2 @@
+import type { MLMLSpec } from '../types';
+export declare function getSpec(el: Element, schema: MLMLSpec): import("../types").ElementSpec | null;

package/lib/dom-traverse/get-spec.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpec = void 0;
+const get_spec_by_tag_name_1 = require("../specs/get-spec-by-tag-name");
+function getSpec(el, schema) {
+    return (0, get_spec_by_tag_name_1.getSpecByTagName)(schema, el.localName, el.namespaceURI);
+}
+exports.getSpec = getSpec;

package/lib/dom-traverse/has-required-owned-elements.d.ts

@@ -0,0 +1,3 @@
+import type { ARIAVersion, ComputedRole, MLMLSpec } from '../types';
+export declare function hasRequiredOwnedElement(el: Element, specs: Readonly<MLMLSpec>, version: ARIAVersion): boolean;
+export declare function isRequiredOwnedElement(owned: ComputedRole, query: string, specs: MLMLSpec, version: ARIAVersion): boolean;

package/lib/dom-traverse/has-required-owned-elements.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequiredOwnedElement = exports.hasRequiredOwnedElement = void 0;
+const is_presentational_1 = require("../specs/is-presentational");
+const get_computed_role_1 = require("./get-computed-role");
+const get_explicit_role_1 = require("./get-explicit-role");
+const get_implicit_role_1 = require("./get-implicit-role");
+function hasRequiredOwnedElement(el, specs, version) {
+    const computed = (0, get_computed_role_1.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;
+}
+exports.hasRequiredOwnedElement = hasRequiredOwnedElement;
+function isRequiredOwnedElement(owned, query, specs, version) {
+    var _a, _b;
+    const [baseRole, owningRole] = query.split(' > ');
+    if (((_a = owned.role) === null || _a === void 0 ? void 0 : _a.name) !== baseRole) {
+        return false;
+    }
+    if (!owningRole) {
+        return true;
+    }
+    for (const owning of getClosestNonPresentationalDescendants(owned.el, specs, version)) {
+        if (((_b = owning.role) === null || _b === void 0 ? void 0 : _b.name) === owningRole) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isRequiredOwnedElement = isRequiredOwnedElement;
+/**
+ * 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, specs, version) {
+    var _a;
+    const owned = [];
+    for (const child of Array.from(el.children)) {
+        const implicitRole = (0, get_implicit_role_1.getImplicitRole)(specs, child, version);
+        const explicitRole = (0, get_explicit_role_1.getExplicitRole)(specs, child, version);
+        const computed = explicitRole.role ? explicitRole : implicitRole;
+        if ((0, is_presentational_1.isPresentational)((_a = computed.role) === null || _a === void 0 ? void 0 : _a.name)) {
+            owned.push(...getClosestNonPresentationalDescendants(child, specs, version));
+            continue;
+        }
+        owned.push({ ...computed, el: child });
+    }
+    return owned;
+}

package/lib/index.d.ts

@@ -1,7 +1,17 @@
-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-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 './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-structres';
+export * from './utils/resolve-namespace';

package/lib/index.js

@@ -1,10 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./permitted-structres"), exports);
-(0, tslib_1.__exportStar)(require("./attributes"), exports);
-(0, tslib_1.__exportStar)(require("./get-attr-specs"), exports);
-(0, tslib_1.__exportStar)(require("./get-spec-by-tag-name"), exports);
-(0, tslib_1.__exportStar)(require("./get-spec"), exports);
-(0, tslib_1.__exportStar)(require("./get-ns"), exports);
-(0, tslib_1.__exportStar)(require("./types"), exports);
+tslib_1.__exportStar(require("./dom-traverse/accname-computation"), exports);
+tslib_1.__exportStar(require("./dom-traverse/get-attr-specs"), exports);
+tslib_1.__exportStar(require("./dom-traverse/get-computed-role"), exports);
+tslib_1.__exportStar(require("./dom-traverse/get-implicit-role"), exports);
+tslib_1.__exportStar(require("./dom-traverse/get-permitted-roles"), exports);
+tslib_1.__exportStar(require("./dom-traverse/get-spec"), exports);
+tslib_1.__exportStar(require("./dom-traverse/has-required-owned-elements"), exports);
+tslib_1.__exportStar(require("./specs/aria-specs"), exports);
+tslib_1.__exportStar(require("./specs/content-model-category-to-tag-names"), exports);
+tslib_1.__exportStar(require("./specs/get-role-spec"), exports);
+tslib_1.__exportStar(require("./specs/get-spec-by-tag-name"), exports);
+tslib_1.__exportStar(require("./specs/schema-to-spec"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./types/aria"), exports);
+tslib_1.__exportStar(require("./types/attributes"), exports);
+tslib_1.__exportStar(require("./types/permitted-structres"), exports);
+tslib_1.__exportStar(require("./utils/resolve-namespace"), exports);

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

@@ -0,0 +1,5 @@
+import type { MLMLSpec } from '../types';
+export declare function ariaSpec(specs: Readonly<MLMLSpec>): {
+	roles: import('../types').ARIRRoleAttribute[];
+	ariaAttrs: import('../types').ARIAAttribute[];
+};

package/lib/specs/aria-spec.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ariaSpec = void 0;
+function ariaSpec(specs) {
+    const roles = specs.def['#roles'];
+    const ariaAttrs = specs.def['#ariaAttrs'];
+    return {
+        roles,
+        ariaAttrs,
+    };
+}
+exports.ariaSpec = ariaSpec;

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

@@ -0,0 +1,6 @@
+import type { ARIAVersion, MLMLSpec } from '../types';
+export declare function ariaSpecs(specs: Readonly<MLMLSpec>, version: ARIAVersion): {
+    roles: import("../types").ARIARoleInSchema[];
+    graphicsRoles: import("../types").ARIARoleInSchema[];
+    props: import("../types").ARIAProperty[];
+};