@markuplint/rules 2.4.4 → 2.4.6

package/lib/wai-aria/checkings/implicit-props.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingImplicitProps = void 0;
+const helpers_1 = require("../../helpers");
+const checkingImplicitProps = ({ attr, propSpecs, attrSpecs }) => t => {
+    if (!attrSpecs) {
+        return;
+    }
+    if (attr.isDynamicValue) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    if (!(propSpec === null || propSpec === void 0 ? void 0 : propSpec.equivalentHtmlAttrs)) {
+        return;
+    }
+    for (const equivalentHtmlAttr of propSpec.equivalentHtmlAttrs) {
+        const htmlAttrSpec = attrSpecs.find(a => a.name === equivalentHtmlAttr.htmlAttrName);
+        const isValid = (0, helpers_1.isValidAttr)(t, equivalentHtmlAttr.htmlAttrName, equivalentHtmlAttr.value || '', false, attr.ownerElement, attrSpecs);
+        if (isValid && isValid.invalidType === 'non-existent') {
+            continue;
+        }
+        const value = attr.value.trim().toLowerCase();
+        if (attr.ownerElement.hasAttribute(equivalentHtmlAttr.htmlAttrName)) {
+            const targetAttrValue = attr.ownerElement.getAttribute(equivalentHtmlAttr.htmlAttrName);
+            if ((equivalentHtmlAttr.value == null && targetAttrValue === value) ||
+                equivalentHtmlAttr.value === value) {
+                return {
+                    scope: attr,
+                    message: t('{0} has {1}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec.type}`), t('the same {0} as {1}', 'semantics', t('{0} or {1}', t('the current "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute'), t('the implicit "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')))),
+                };
+            }
+            if ((htmlAttrSpec === null || htmlAttrSpec === void 0 ? void 0 : htmlAttrSpec.type) === 'Boolean' && value !== 'false') {
+                continue;
+            }
+            return {
+                scope: attr,
+                message: t('{0} contradicts {1}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec.type}`), t('the current "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')),
+            };
+        }
+        else if (value === 'true') {
+            if (!equivalentHtmlAttr.isNotStrictEquivalent && (htmlAttrSpec === null || htmlAttrSpec === void 0 ? void 0 : htmlAttrSpec.type) === 'Boolean') {
+                return {
+                    scope: attr,
+                    message: t('{0} contradicts {1}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec.type}`), t('the implicit "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')),
+                };
+            }
+        }
+    }
+};
+exports.checkingImplicitProps = checkingImplicitProps;

package/lib/wai-aria/checkings/implicit-role.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+export declare const checkingImplicitRole: AttrChecker<boolean, Options>;

package/lib/wai-aria/checkings/implicit-role.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingImplicitRole = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const checkingImplicitRole = ({ attr }) => t => {
+    var _a;
+    const implicitRole = (0, ml_spec_1.getImplicitRoleName)(attr.ownerElement, attr.rule.option.version, attr.ownerMLDocument.specs);
+    const tokens = (_a = attr.tokenList) === null || _a === void 0 ? void 0 : _a.allTokens();
+    if (!tokens) {
+        return;
+    }
+    for (const token of tokens) {
+        if (implicitRole === token.raw) {
+            return {
+                scope: token,
+                message: t('{0} is {1}', t('the "{0*}" {1}', token.raw, 'role'), t('{0} of {1}', 'the implicit role', t('the "{0*}" {1}', attr.ownerElement.localName, 'element'))),
+            };
+        }
+    }
+};
+exports.checkingImplicitRole = checkingImplicitRole;

package/lib/wai-aria/checkings/interaction-in-hidden.d.ts

@@ -0,0 +1,11 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+/**
+ * Including Elements in the Accessibility Tree
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ * > Elements that are not hidden and may fire an accessibility API event, including:
+ * > - Elements that are currently focused, even if the element or one of its ancestor elements has its aria-hidden attribute set to true.
+ * > - Elements that are a valid target of an aria-activedescendant attribute.
+ */
+export declare const checkingInteractionInHidden: ElementChecker<boolean, Options>;

package/lib/wai-aria/checkings/interaction-in-hidden.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingInteractionInHidden = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Including Elements in the Accessibility Tree
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ * > Elements that are not hidden and may fire an accessibility API event, including:
+ * > - Elements that are currently focused, even if the element or one of its ancestor elements has its aria-hidden attribute set to true.
+ * > - Elements that are a valid target of an aria-activedescendant attribute.
+ */
+// フォーカスがあたっている場合に限り、先祖がaria-hidden=trueでもアクセシビリティツリーに提示される
+// なので、aria-hidden=trueの子孫要素で且つインタラクティブ要素である場合、
+// それは開発者にとってはほとんどの場合、意図しないことが多いはずなので、
+// 仕様上不正にはならないが、十分に注意しなければならない状態である。
+const checkingInteractionInHidden = ({ el }) => t => {
+    if (!(0, ml_spec_1.mayBeFocusable)(el, el.ownerMLDocument.specs)) {
+        return;
+    }
+    const ariaHidden = getClosestAriaHidden(el);
+    if (!ariaHidden) {
+        return;
+    }
+    if (el === ariaHidden.ownerElement) {
+        return {
+            scope: el,
+            message: t('It may be focusable in spite of it has aria-hidden=true'),
+        };
+    }
+    return {
+        scope: el,
+        message: t('It may be focusable in spite of it has the ancestor that has aria-hidden=true'),
+    };
+};
+exports.checkingInteractionInHidden = checkingInteractionInHidden;
+function getClosestAriaHidden(el) {
+    let current = el;
+    while (current) {
+        const ariaHidden = current.getAttributeNode('aria-hidden');
+        if ((ariaHidden === null || ariaHidden === void 0 ? void 0 : ariaHidden.value) === 'true') {
+            return ariaHidden;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}

package/lib/wai-aria/checkings/no-global-prop.d.ts

@@ -0,0 +1,6 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+import type { ARIAProperty } from '@markuplint/ml-spec';
+export declare const checkingNoGlobalProp: AttrChecker<boolean, Options, {
+    propSpecs: ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/no-global-prop.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingNoGlobalProp = void 0;
+const checkingNoGlobalProp = ({ attr, propSpecs }) => t => {
+    var _a, _b;
+    const propSpec = propSpecs.find(prop => prop.name === attr.name);
+    if (propSpec && !propSpec.isGlobal) {
+        return {
+            scope: attr,
+            message: t('{0} is not {1}', t('the "{0*}" {1}', attr.name, `ARIA ${(_a = propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`), `global ${(_b = propSpec.type) !== null && _b !== void 0 ? _b : 'property'}`),
+        };
+    }
+};
+exports.checkingNoGlobalProp = checkingNoGlobalProp;

package/lib/wai-aria/checkings/non-existent-role.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+export declare const checkingNonExistentRole: AttrChecker<boolean, Options>;

package/lib/wai-aria/checkings/non-existent-role.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingNonExistentRole = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const checkingNonExistentRole = ({ attr }) => t => {
+    var _a;
+    const { roles, graphicsRoles } = (0, ml_spec_1.ariaSpecs)(attr.ownerMLDocument.specs, attr.rule.option.version);
+    const tokens = (_a = attr.tokenList) === null || _a === void 0 ? void 0 : _a.allTokens();
+    if (!tokens) {
+        return;
+    }
+    for (const token of tokens) {
+        let role = roles.find(r => r.name === token.raw);
+        if (!role && attr.ownerElement.namespaceURI === 'http://www.w3.org/2000/svg') {
+            role = graphicsRoles.find(r => r.name === token.raw);
+        }
+        if (!role) {
+            return {
+                scope: token,
+                message: t('{0} according to {1}', t('{0} does not exist', t('the "{0*}" {1}', token.raw, 'role')), 'the WAI-ARIA specification') +
+                    t('.') +
+                    // TODO: Translate
+                    ` This "${token.raw}" role does not exist in WAI-ARIA.`,
+            };
+        }
+    }
+};
+exports.checkingNonExistentRole = checkingNonExistentRole;

package/lib/wai-aria/checkings/permitted-roles.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+export declare const checkingPermittedRoles: AttrChecker<boolean, Options>;

package/lib/wai-aria/checkings/permitted-roles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingPermittedRoles = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const checkingPermittedRoles = ({ attr }) => t => {
+    var _a;
+    const el = attr.ownerElement;
+    const permittedRoles = (0, ml_spec_1.getPermittedRoles)(el, el.rule.option.version, attr.ownerMLDocument.specs);
+    if (permittedRoles.length === 0) {
+        return {
+            scope: attr,
+            message: t('{0} according to {1}', t('Cannot overwrite {0}', t('{0} of {1}', t('the {0}', 'role'), t('the "{0*}" {1}', el.localName, 'element'))), 'ARIA in HTML specification'),
+        };
+    }
+    const tokens = (_a = attr.tokenList) === null || _a === void 0 ? void 0 : _a.allTokens();
+    if (!tokens) {
+        return;
+    }
+    for (const token of tokens) {
+        if (Array.isArray(permittedRoles) && !permittedRoles.map(r => r.name).includes(token.raw)) {
+            return {
+                scope: token,
+                message: t('{0} according to {1}', t('Cannot overwrite {0} to {1}', t('the "{0*}" {1}', token.raw, 'role'), t('the "{0*}" {1}', el.localName, 'element')), 'ARIA in HTML specification'),
+            };
+        }
+    }
+};
+exports.checkingPermittedRoles = checkingPermittedRoles;

package/lib/wai-aria/checkings/presentational-children.d.ts

@@ -0,0 +1,29 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+export declare const checkingPresentationalChildren: ElementChecker<boolean, Options>;

package/lib/wai-aria/checkings/presentational-children.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingPresentationalChildren = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+const checkingPresentationalChildren = ({ el }) => t => {
+    const ancestor = getAncestorHasPresentationalChildren(el);
+    if (!ancestor) {
+        return;
+    }
+    if (!ancestor.role) {
+        return;
+    }
+    const hasAriaAttr = Array.from(el.attributes).some(attr => /^aria-|^role$/i.test(attr.name));
+    if (!hasAriaAttr) {
+        return;
+    }
+    return {
+        scope: el,
+        message: t('it may be ineffective because {0}', t("it has {0} as an ancestor that doesn't expose its descendants to the accessibility tree", t('the "{0*}" {1}', ancestor.role.name, 'role'))),
+    };
+};
+exports.checkingPresentationalChildren = checkingPresentationalChildren;
+function getAncestorHasPresentationalChildren(el) {
+    var _a;
+    let current = el.parentElement;
+    while (current) {
+        const computed = (0, ml_spec_1.getComputedRole)(el.ownerMLDocument.specs, current, el.rule.option.version);
+        if ((_a = computed.role) === null || _a === void 0 ? void 0 : _a.childrenPresentational) {
+            return computed;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}

package/lib/wai-aria/checkings/required-owned-elements.d.ts

@@ -0,0 +1,11 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+import type { ARIARole } from '@markuplint/ml-spec';
+/**
+ * Required Owned Elements
+ *
+ * @see https://w3c.github.io/aria/#mustContain
+ */
+export declare const checkingRequiredOwnedElements: ElementChecker<boolean, Options, {
+    role?: ARIARole | null;
+}>;

package/lib/wai-aria/checkings/required-owned-elements.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingRequiredOwnedElements = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Required Owned Elements
+ *
+ * @see https://w3c.github.io/aria/#mustContain
+ */
+const checkingRequiredOwnedElements = ({ el, role }) => t => {
+    if (!role) {
+        return;
+    }
+    if (!role.requiredOwnedElements.length) {
+        return;
+    }
+    /**
+     * > There may be times that required owned elements are missing,
+     * > for example, while editing or while loading a data set.
+     * > When a widget is missing required owned elements due to script execution or loading,
+     * > authors MUST mark a containing element with aria-busy equal to true.
+     * > For example, until a page is fully initialized and complete,
+     * > an author could mark the document element as busy.
+     *
+     * Stop to evaluate when it has `aria-busy=true` for it considers the contents are missing.
+     */
+    if (el.matches('[aria-busy="true" i]')) {
+        return;
+    }
+    // TODO: Needs to resolve `aria-own`
+    if (el.isEmpty()) {
+        return {
+            scope: el,
+            message: t('{0}. Or, {1}', t('require {0}', role.requiredOwnedElements.length === 1
+                ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+                : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`), t('require {0}', 'aria-busy="true"')),
+        };
+    }
+    const children = Array.from(el.childNodes).map(child => {
+        if (child.is(child.ELEMENT_NODE)) {
+            const computedChild = (0, ml_spec_1.getComputedRole)(child.ownerMLDocument.specs, child, child.rule.option.version);
+            if (role.requiredOwnedElements.some(ownedRole => (0, ml_spec_1.isRequiredOwnedElement)(computedChild, ownedRole, child.ownerMLDocument.specs, child.rule.option.version))) {
+                return [child, 'REQUIRED'];
+            }
+            return [child, 'OTHER'];
+        }
+        else if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            return [child, 'PB'];
+        }
+        return [null, 'NO_ELEMENT'];
+    });
+    /**
+     * > Any element that will be owned by the element with this role.
+     * > For example, an element with the role list
+     * > **will own at least one element** with the role listitem.
+     */
+    if (children.some(([, type]) => type === 'REQUIRED')) {
+        return;
+    }
+    if (children.some(([, type]) => type === 'PB')) {
+        // TODO: https://github.com/markuplint/markuplint/issues/490
+        return;
+    }
+    /**
+     * Has mutable children
+     *
+     * Ex:
+     *
+     * ```jsx
+     * <table>
+     *   <tbody>
+     *     {list.map((item) => <tr><td>{item}</td></tr>)}
+     *   </tbody>
+     * </table>
+     * ```
+     */
+    if (el.hasMutableChildren(true)) {
+        return;
+    }
+    return {
+        scope: el,
+        message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), role.requiredOwnedElements.length === 1
+            ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+            : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`),
+    };
+};
+exports.checkingRequiredOwnedElements = checkingRequiredOwnedElements;

package/lib/wai-aria/checkings/required-prop.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+export declare const checkingRequiredProp: ElementChecker<boolean, Options, {
+    role?: (ARIARole & {
+        isImplicit?: boolean;
+    }) | null;
+    propSpecs: ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/required-prop.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingRequiredProp = void 0;
+const checkingRequiredProp = ({ el, role, propSpecs }) => t => {
+    var _a;
+    if (!role) {
+        return;
+    }
+    if (role.isImplicit) {
+        return;
+    }
+    const requiredProps = role.ownedProperties.filter(s => s.required).map(s => s.name);
+    for (const requiredProp of requiredProps) {
+        const has = el.attributes.some(attr => {
+            const attrName = attr.name.toLowerCase();
+            return attrName === requiredProp;
+        });
+        if (!has) {
+            const propSpec = propSpecs.find(p => p.name === requiredProp);
+            return {
+                scope: el,
+                message: t('{0:c} on {1}', t('Require {0}', t('the "{0*}" {1}', requiredProp, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`)), t('the "{0*}" {1}', role.name, 'role')),
+            };
+        }
+    }
+};
+exports.checkingRequiredProp = checkingRequiredProp;

package/lib/wai-aria/checkings/value.d.ts

@@ -0,0 +1,13 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+export declare const checkingValue: AttrChecker<boolean, Options, {
+    role?: ARIARole | null;
+    propSpecs: ARIAProperty[];
+    booleanish?: boolean;
+}>;
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+export declare function checkAriaValue(type: string, value: string, tokenEnum: string[], booleanish?: boolean): boolean;

package/lib/wai-aria/checkings/value.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAriaValue = exports.checkingValue = void 0;
+const checkingValue = ({ attr, role, propSpecs, booleanish }) => t => {
+    var _a;
+    if (attr.isDynamicValue) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    const result = checkAria(propSpec, attr.value, role === null || role === void 0 ? void 0 : role.name, booleanish);
+    if (result.isValid) {
+        return;
+    }
+    return {
+        scope: attr,
+        message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0}"', attr.value), 'disallowed'), t('the "{0*}" {1}', attr.name, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`)) +
+            ('enum' in result && result.enum.length ? t('. ') + t('Allowed values are: {0}', t(result.enum)) : ''),
+    };
+};
+exports.checkingValue = checkingValue;
+function checkAria(propSpec, currentValue, role, booleanish) {
+    if (!propSpec) {
+        return {
+            currentValue,
+            // For skipping checking
+            isValid: true,
+        };
+    }
+    let valueType = propSpec.value;
+    if (role && propSpec.conditionalValue) {
+        for (const cond of propSpec.conditionalValue) {
+            if (cond.role.includes(role)) {
+                valueType = cond.value;
+                break;
+            }
+        }
+    }
+    const isValid = checkAriaValue(valueType, currentValue, propSpec.enum, booleanish);
+    return {
+        ...propSpec,
+        currentValue,
+        isValid,
+    };
+}
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+function checkAriaValue(type, value, tokenEnum, booleanish) {
+    switch (type) {
+        case 'token': {
+            return tokenEnum.includes(value);
+        }
+        case 'token list': {
+            const list = value.split(/\s+/g).map(s => s.trim());
+            return list.every(token => tokenEnum.includes(token));
+        }
+        case 'string':
+        case 'ID reference':
+        case 'ID reference list': {
+            return true;
+        }
+        case 'true/false': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false'].includes(value);
+        }
+        case 'tristate': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['mixed', 'true', 'false', 'undefined'].includes(value);
+        }
+        case 'true/false/undefined': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false', 'undefined'].includes(value);
+        }
+        case 'integer': {
+            return parseInt(value).toString() === value;
+        }
+        case 'number': {
+            return parseFloat(value).toString() === value;
+        }
+    }
+    // For skipping checking
+    return true;
+}
+exports.checkAriaValue = checkAriaValue;

package/lib/wai-aria/types.d.ts

@@ -0,0 +1,13 @@
+import type { ARIAVersion } from '@markuplint/ml-spec';
+export type Options = {
+    checkingValue: boolean;
+    checkingDeprecatedProps: boolean;
+    permittedAriaRoles: boolean;
+    checkingRequiredOwnedElements: boolean;
+    checkingPresentationalChildren: boolean;
+    checkingInteractionInHidden: boolean;
+    disallowSetImplicitRole: boolean;
+    disallowSetImplicitProps: boolean;
+    disallowDefaultValue: boolean;
+    version: ARIAVersion;
+};

package/lib/wai-aria/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "2.4.4",
+	"version": "2.4.6",
 	"description": "Rules for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,8 +17,8 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "2.8.0",
-		"@markuplint/ml-core": "2.3.4",
+		"@markuplint/html-spec": "2.9.0",
+		"@markuplint/ml-core": "2.3.5",
 		"@markuplint/ml-spec": "2.1.1",
 		"@markuplint/types": "2.2.0",
 		"debug": "^4.3.4",
@@ -28,5 +28,5 @@
 	"devDependencies": {
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "dbe0c72fbd92fc604d6a9908feda3df86795e143"
+	"gitHead": "c3e38fbec92fffa4a44564d1c7a37963f40502ce"
 }