@markuplint/rules 2.4.0 → 3.0.0-alpha.66

package/lib/permitted-contents/permitted-content.spec-to-regexp.js

@@ -1,20 +1,23 @@
 "use strict";
-var _TagList_list;
+var _ExpGenerator_id, _ExpGenerator_specs, _ExpGenerator_idCounter, _TagList_list;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const ml_spec_1 = require("@markuplint/ml-spec");
 const helpers_1 = require("../helpers");
 const array_combination_1 = tslib_1.__importDefault(require("./array.combination"));
-const unfold_content_models_to_tags_1 = tslib_1.__importDefault(require("./unfold-content-models-to-tags"));
 const ALL = '(?:<[^>]+>)?';
 const ___TRANSPARENT___ = '___TRANSPARENT___';
 const ___InTRANSPARENT = '___InTRANSPARENT';
 const CUSTOM_ELEMENT = `(?:<[a-z](?:${helpers_1.rePCENChar})*\\-(?:${helpers_1.rePCENChar})*>)`;
 class ExpGenerator {
-    constructor(_id) {
-        this._id = _id;
-        this._idCounter = 0;
+    constructor(specs, id) {
+        _ExpGenerator_id.set(this, void 0);
+        _ExpGenerator_specs.set(this, void 0);
+        _ExpGenerator_idCounter.set(this, 0);
+        tslib_1.__classPrivateFieldSet(this, _ExpGenerator_id, id, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExpGenerator_specs, specs, "f");
     }
-    specToRegExp(contentRule, parentExp = null, ownNS = null) {
+    specToRegExp(contentRule, parentExp = null, ownNS = 'http://www.w3.org/1999/xhtml') {
         if (contentRule === true) {
             return new RegExp(`^(?:${ALL})+$`);
         }
@@ -22,10 +25,11 @@ class ExpGenerator {
             return new RegExp('^$');
         }
         const parentPattern = parentExp ? parentExp.source.replace(/^\^|\$$/g, '') : ALL;
-        const pattern = this._toPattern(contentRule, null, ownNS, 1, 1).replace(___TRANSPARENT___, () => `(?<TRANSPARENT_${this._id}${this._idCounter++}>${parentPattern})`);
+        const pattern = this._toPattern(contentRule, null, ownNS, 1, 1).replace(___TRANSPARENT___, () => { var _a, _b; return `(?<TRANSPARENT_${tslib_1.__classPrivateFieldGet(this, _ExpGenerator_id, "f")}${tslib_1.__classPrivateFieldSet(this, _ExpGenerator_idCounter, (_b = tslib_1.__classPrivateFieldGet(this, _ExpGenerator_idCounter, "f"), _a = _b++, _b), "f"), _a}>${parentPattern})`; });
         return new RegExp(`^${pattern}$`, 'i');
     }
     _toPattern(contentRule, ignore, ownNS, min, max) {
+        var _a, _b;
         if (isTarget(contentRule)) {
             return this._targetTags(contentRule, ignore, ownNS, min, max);
         }
@@ -87,7 +91,7 @@ class ExpGenerator {
         }
         const range = createRange(min, max);
         const c = notAllowedDescendantsNamedCapture
-            ? `?<NAD_${this._id}${this._idCounter++}_${notAllowedDescendantsNamedCapture}>`
+            ? `?<NAD_${tslib_1.__classPrivateFieldGet(this, _ExpGenerator_id, "f")}${tslib_1.__classPrivateFieldSet(this, _ExpGenerator_idCounter, (_b = tslib_1.__classPrivateFieldGet(this, _ExpGenerator_idCounter, "f"), _a = _b++, _b), "f"), _a}_${notAllowedDescendantsNamedCapture}>`
             : '?:';
         if (1 === exp.length && range === '') {
             if (notAllowedDescendantsNamedCapture) {
@@ -117,6 +121,7 @@ class ExpGenerator {
         return join(Array.from(tagList), createRange(min, max));
     }
     _resolveTags(target, ownNS) {
+        var _a, _b;
         const list = Array.isArray(target) ? target : [target];
         const tagList = new TagList();
         for (const name of list) {
@@ -131,8 +136,8 @@ class ExpGenerator {
                         break;
                     }
                     default: {
-                        const selectors = (0, unfold_content_models_to_tags_1.default)(name);
-                        const counter = this._idCounter++;
+                        const selectors = (0, ml_spec_1.contentModelCategoryToTagNames)(name, tslib_1.__classPrivateFieldGet(this, _ExpGenerator_specs, "f"));
+                        const counter = (tslib_1.__classPrivateFieldSet(this, _ExpGenerator_idCounter, (_b = tslib_1.__classPrivateFieldGet(this, _ExpGenerator_idCounter, "f"), _a = _b++, _b), "f"), _a);
                         selectors.forEach(selector => {
                             if (selector === '#custom') {
                                 tagList.addPattern(CUSTOM_ELEMENT);
@@ -141,7 +146,7 @@ class ExpGenerator {
                             if (/]$/i.test(selector)) {
                                 const [, tagName] = /^([^[\]]+)\[[^\]]+\]$/.exec(selector) || [];
                                 // ACM = Attributes by content model
-                                const exp = `(?<ACM_${this._id}${counter}_${name.slice(1)}_${tagName}><${tagName}>)`;
+                                const exp = `(?<ACM_${tslib_1.__classPrivateFieldGet(this, _ExpGenerator_id, "f")}${counter}_${name.slice(1)}_${tagName}><${tagName}>)`;
                                 tagList.addPattern(exp);
                                 return;
                             }
@@ -157,6 +162,7 @@ class ExpGenerator {
     }
 }
 exports.default = ExpGenerator;
+_ExpGenerator_id = new WeakMap(), _ExpGenerator_specs = new WeakMap(), _ExpGenerator_idCounter = new WeakMap();
 class TagList {
     constructor() {
         _TagList_list.set(this, new Set());
@@ -165,9 +171,8 @@ class TagList {
         tslib_1.__classPrivateFieldGet(this, _TagList_list, "f").add(pattern);
     }
     addTag(tagNameOrSelector, ownNS) {
-        if (ownNS) {
-            tagNameOrSelector = tagNameOrSelector.replace(new RegExp(`^${ownNS}:`, 'i'), '');
-        }
+        tagNameOrSelector = tagNameOrSelector.replace(/\|/g, ':');
+        tagNameOrSelector = tagNameOrSelector.replace(/^html:/i, '');
         tslib_1.__classPrivateFieldGet(this, _TagList_list, "f").add(`<${tagNameOrSelector}>`);
     }
     result() {

package/lib/permitted-contents/unfold-content-models-to-tags.d.ts

@@ -1,2 +1,2 @@
-import type { ContentModel } from '@markuplint/ml-spec';
-export default function unfoldContentModelsToTags(contentModel: ContentModel): string[];
+import type { Category } from '@markuplint/ml-spec';
+export default function unfoldContentModelsToTags(contentModel: Category): string[];

package/lib/require-accessible-name/index.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, null>;
+import type { ARIAVersion } from '@markuplint/ml-spec';
+declare type Option = {
+    ariaVersion: ARIAVersion;
+};
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Option>;
 export default _default;

package/lib/require-accessible-name/index.js

@@ -3,16 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
+    defaultOptions: {
+        ariaVersion: '1.2',
+    },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
             if ((0, helpers_1.accnameMayBeMutable)(el, document)) {
                 return;
             }
-            const role = (0, helpers_1.getComputedRole)(document.specs, el);
-            if (!role) {
+            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.option.ariaVersion);
+            if (!computed.role) {
                 return;
             }
-            const roleSpec = (0, helpers_1.getRoleSpec)(document.specs, role.name);
+            const roleSpec = (0, ml_core_1.getRoleSpec)(document.specs, computed.role.name, el.namespaceURI, el.rule.option.ariaVersion);
             if (!roleSpec || !roleSpec.accessibleNameRequired) {
                 return;
             }

package/lib/required-attr/index.js

@@ -5,15 +5,14 @@ const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
     defaultValue: [],
     async verify({ document, report, t }) {
-        await document.walkOn('Element', async (node) => {
-            var _a;
-            if (node.hasSpreadAttr) {
+        await document.walkOn('Element', el => {
+            if (el.hasSpreadAttr) {
                 return;
             }
-            const customRequiredAttrs = typeof node.rule.value === 'string' ? [node.rule.value] : node.rule.value;
-            const attrSpec = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const customRequiredAttrs = typeof el.rule.value === 'string' ? [el.rule.value] : el.rule.value;
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(el, document.specs);
             const attributeSpecs = {};
-            if (attrSpec && !node.isCustomElement) {
+            if (attrSpec && !el.isCustomElement) {
                 for (const spec of attrSpec) {
                     if (spec.required || spec.requiredEither || spec.condition) {
                         attributeSpecs[spec.name] = {
@@ -45,46 +44,38 @@ exports.default = (0, ml_core_1.createRule)({
                 };
             }
             for (const spec of Object.values(attributeSpecs)) {
-                const didntHave = !node.hasAttribute(spec.name);
+                const didntHave = !el.hasAttribute(spec.name);
                 let invalid = false;
                 if (spec.requiredEither) {
                     const candidate = [...spec.requiredEither, spec.name];
-                    invalid = !candidate.some(attrName => node.hasAttribute(attrName));
+                    invalid = !candidate.some(attrName => el.hasAttribute(attrName));
                 }
                 else if (spec.required === true) {
-                    invalid = (0, helpers_1.attrMatches)(node, spec.condition) && didntHave;
+                    invalid = (0, helpers_1.attrMatches)(el, spec.condition) && didntHave;
                 }
                 else if (spec.required) {
-                    if ('ancestor' in spec.required && spec.required.ancestor) {
-                        const ancestorList = Array.isArray(spec.required.ancestor)
-                            ? spec.required.ancestor
-                            : [spec.required.ancestor];
-                        const ancestors = ancestorList
-                            .join(',')
-                            .split(',')
-                            .map(a => a.trim());
-                        invalid = ancestors.some(a => node.closest(a)) && didntHave;
-                    }
+                    const selector = Array.isArray(spec.required) ? spec.required.join(',') : spec.required;
+                    invalid = el.matches(selector) && didntHave;
                 }
                 if (invalid) {
-                    const message = t('{0} expects {1}', t('the "{0*}" {1}', node.nodeName, 'element'), t('the "{0*}" {1}', spec.name, 'attribute'));
+                    const message = t('{0} expects {1}', t('the "{0*}" {1}', el.localName, 'element'), t('the "{0*}" {1}', spec.name, 'attribute'));
                     report({
-                        scope: node,
+                        scope: el,
                         message,
                     });
                 }
-                const value = node.getAttribute(spec.name);
+                const value = el.getAttribute(spec.name);
                 if (spec.values.length && value) {
                     const matched = spec.values.some(pattern => (0, helpers_1.match)(value, pattern));
                     if (!matched) {
                         const expects = spec.values.length === 1 ? t(spec.values) : t('either {0}', t(spec.values));
                         const message = t('{0} expects {1}', t('the "{0*}" {1}', spec.name, 'attribute'), expects);
-                        const attrToken = node.getAttributeToken(spec.name);
-                        const valueToken = ((_a = attrToken[0]) === null || _a === void 0 ? void 0 : _a.attrType) === 'html-attr' ? attrToken[0].valueNode : null;
+                        const attrToken = el.getAttributeToken(spec.name);
+                        const valueToken = attrToken[0].valueNode;
                         const token = valueToken || attrToken[0];
                         report({
                             scope: {
-                                rule: node.rule,
+                                rule: el.rule,
                                 raw: token.raw,
                                 startCol: token.startCol,
                                 startLine: token.startLine,

package/lib/required-element/index.d.ts

@@ -1,5 +1,5 @@
 declare type Options = {
-    ignoreHasMutableContents?: boolean;
+    ignoreHasMutableContents: boolean;
 };
 declare const _default: import("@markuplint/ml-core").RuleSeed<string[], Options>;
 export default _default;

package/lib/required-element/index.js

@@ -6,11 +6,11 @@ exports.default = (0, ml_core_1.createRule)({
     defaultOptions: {
         ignoreHasMutableContents: true,
     },
-    async verify({ document, report, t, globalRule }) {
-        const hasMutableContent = document.nodeList.some(n => (n.type === 'Element' || n.type === 'OmittedElement') && n.hasMutableChildren());
+    async verify({ document, report, t }) {
+        const hasMutableContent = document.nodeList.some(n => n.is(n.ELEMENT_NODE) && n.hasMutableChildren());
         if (!hasMutableContent) {
-            for (const query of globalRule.value) {
-                const exists = document.matchNodes(query);
+            for (const query of document.rule.value) {
+                const exists = document.querySelectorAll(query);
                 if (exists.length === 0) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({
@@ -23,14 +23,14 @@ exports.default = (0, ml_core_1.createRule)({
             }
         }
         await document.walkOn('Element', el => {
-            if (el.rule.value === globalRule.value) {
+            if (el.rule.value === document.rule.value) {
                 return;
             }
             if (el.rule.option.ignoreHasMutableContents && el.hasMutableChildren()) {
                 return;
             }
             for (const query of el.rule.value) {
-                const exists = el.children.find(child => child.matches(query));
+                const exists = Array.from(el.children).find(child => child.matches(query));
                 if (!exists) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({

package/lib/required-h1/index.d.ts

@@ -1,6 +1,6 @@
 export interface Options {
-    'expected-once'?: boolean;
-    'in-document-fragment'?: boolean;
+    'expected-once': boolean;
+    'in-document-fragment': boolean;
 }
 declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
 export default _default;

package/lib/required-h1/index.js

@@ -6,15 +6,15 @@ exports.default = (0, ml_core_1.createRule)({
         'expected-once': true,
         'in-document-fragment': false,
     },
-    async verify({ document, report, globalRule, t }) {
+    async verify({ document, report, t }) {
         const h1Stack = [];
         if (document.nodeList.length === 0) {
             return;
         }
-        if (!globalRule.option['in-document-fragment'] && document.isFragment) {
+        if (!document.rule.option['in-document-fragment'] && document.isFragment) {
             return;
         }
-        await document.walkOn('Element', async (node) => {
+        await document.walkOn('Element', node => {
             if (node.nodeName.toLowerCase() === 'h1') {
                 h1Stack.push(node);
             }
@@ -28,7 +28,7 @@ exports.default = (0, ml_core_1.createRule)({
                 raw: document.nodeList[0].raw.slice(0, 1),
             });
         }
-        else if (globalRule.option['expected-once'] && h1Stack.length > 1) {
+        else if (document.rule.option['expected-once'] && h1Stack.length > 1) {
             const message = t('{0} is {1:c}', t('the "{0*}" {1}', 'h1', 'element'), 'duplicated');
             report({
                 message,

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingAbstractRole = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const checkingAbstractRole = ({ attr }) => t => {
+    var _a;
+    const { roles } = (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) {
+        const role = roles.find(r => r.name === token.raw);
+        if (role === null || role === void 0 ? void 0 : role.isAbstract) {
+            return {
+                scope: token,
+                message: t('{0} is {1}', t('the "{0*}" {1}', token.raw, 'role'), 'the abstract role'),
+            };
+        }
+    }
+};
+exports.checkingAbstractRole = checkingAbstractRole;

package/lib/wai-aria/checkings/checking-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/checking-required-owned-elements.js

@@ -0,0 +1,63 @@
+"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.children.length) {
+        return {
+            scope: el,
+            message: t('{0}. Or, {1}', t('Require {0} to content', t('the {0*} {1}', t(role.requiredOwnedElements), 'role')), 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 'REQUIRED';
+            }
+            return 'OTHER';
+        }
+        else if (child.MARKUPLINT_PREPROCESSOR_BLOCK) {
+            return 'PB';
+        }
+        return 'NO_ELEMENT';
+    });
+    if (children.includes('PB')) {
+        return {
+            scope: el,
+            message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), t(role.requiredContextRole.map(ownedRole => t('the "{0*}" {1}', ownedRole, 'role')))),
+        };
+    }
+    if (!children.includes('REQUIRED')) {
+        return {
+            scope: el,
+            message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), t('the {0*} {1}', t(role.requiredOwnedElements), 'roles')),
+        };
+    }
+};
+exports.checkingRequiredOwnedElements = checkingRequiredOwnedElements;

package/lib/wai-aria/checkings/default-value.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 checkingDefaultValue: AttrChecker<boolean, Options, {
+    propSpecs: ARIAProperty[];
+}>;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingDefaultValue = void 0;
+const checkingDefaultValue = ({ attr, propSpecs }) => t => {
+    if (attr.isDynamicValue) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    const value = attr.value.trim().toLowerCase();
+    if ((propSpec === null || propSpec === void 0 ? void 0 : propSpec.defaultValue) != null && propSpec.defaultValue === value) {
+        return {
+            scope: attr,
+            message: t('It is {0}', 'default value'),
+        };
+    }
+};
+exports.checkingDefaultValue = checkingDefaultValue;

package/lib/wai-aria/checkings/deprecated-props.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingDeprecatedProps = void 0;
+const checkingDeprecatedProps = ({ attr, role, propSpecs }) => t => {
+    var _a;
+    if (!role) {
+        return;
+    }
+    const props = role.ownedProperties.find(p => p.name === attr.name);
+    if (props === null || props === void 0 ? void 0 : props.deprecated) {
+        const propSpec = propSpecs.find(p => p.name === attr.name);
+        return {
+            scope: attr,
+            message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attr.name, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`), 'deprecated'), t('the "{0*}" {1}', role.name, 'role')),
+        };
+    }
+};
+exports.checkingDeprecatedProps = checkingDeprecatedProps;

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingDisallowedProp = void 0;
+const checkingDisallowedProp = ({ attr, role, propSpecs }) => t => {
+    var _a;
+    if (!role) {
+        return;
+    }
+    if (!/^aria-/i.test(attr.name)) {
+        return;
+    }
+    const statesAndProp = role.ownedProperties.find(p => p.name === attr.name);
+    if (statesAndProp) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    return {
+        scope: attr,
+        message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attr.name, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`), 'disallowed'), t('the "{0*}" {1}', role.name, 'role')),
+    };
+};
+exports.checkingDisallowedProp = checkingDisallowedProp;

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

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

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 implictRole = (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 (implictRole === 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/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-existant-role.d.ts

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingNonExistantRole = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const checkingNonExistantRole = ({ 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.checkingNonExistantRole = checkingNonExistantRole;