@markuplint/rules 2.0.0-dev.20211209.0 → 2.0.0-dev.20211213.0

package/lib/create-message.js

@@ -25,6 +25,7 @@ function __createMessageValueExpected(t, baseTarget, expected, matches) {
     let target = baseTarget;
     let reasonPart;
     let expectPart;
+    let unnecessaryPart;
     let candicatePart;
     let expectOrNeed = 'expects';
     if (matches.partName) {
@@ -52,6 +53,10 @@ function __createMessageValueExpected(t, baseTarget, expected, matches) {
         case 'extra-token': {
             const token = matches.partName || 'token';
             reasonPart = t('Found {0}', t('extra {0}', token)) + ' ' + t([matches.raw]);
+            if (matches.extra) {
+                const extra = expectValueToWord(t, matches.extra, 'Any');
+                unnecessaryPart = t("It doesn't need {0}", extra);
+            }
             break;
         }
         case 'illegal-combination': {
@@ -86,6 +91,12 @@ function __createMessageValueExpected(t, baseTarget, expected, matches) {
             expectOrNeed = 'needs';
             break;
         }
+        case 'must-be-percent-encoded': {
+            break;
+        }
+        case 'must-be-serialized': {
+            break;
+        }
         case 'out-of-range': {
             break;
         }
@@ -129,7 +140,7 @@ function __createMessageValueExpected(t, baseTarget, expected, matches) {
                             expectedDigits = t('{0} digits', gte);
                         }
                         else if (lte != null) {
-                            // expects = t('{0} that has {1}', t('the {0}', expects), t('{0} or more digits', gte));
+                            expectedDigits = t('{0} to {1} digits', gte, lte);
                         }
                         else {
                             expectedDigits = t('{0} or more digits', gte);
@@ -180,7 +191,7 @@ function __createMessageValueExpected(t, baseTarget, expected, matches) {
     if (matches.candicate) {
         candicatePart = t('Did you mean "{0*}"?', matches.candicate);
     }
-    let message = [reasonPart, expectPart, candicatePart].filter(s => s).join(t('. '));
+    let message = [reasonPart, unnecessaryPart, expectPart, candicatePart].filter(s => s).join(t('. '));
     if (matches.ref) {
         message += ` (${matches.ref})`;
     }
@@ -192,21 +203,7 @@ function createExpectedObject(type, matches, t) {
     const expectedObject = [];
     if ((_a = matches.expects) === null || _a === void 0 ? void 0 : _a.length) {
         expectedObject.push(...matches.expects.map(expect => {
-            switch (expect.type) {
-                case 'common':
-                    return expect.value;
-                case 'const':
-                    return expect.value ? `%${expect.value}%` : '';
-                case 'format':
-                    return t('the {0} format', expect.value);
-                case 'regxp':
-                    return t('{0} ({1})', 'regular expression', expect.value);
-                case 'syntax':
-                    if ((0, types_1.isKeyword)(type) && type[0] === '<') {
-                        return t('the CSS Syntax "{0}"', expect.value);
-                    }
-                    return t('{0} syntax', expect.value);
-            }
+            return expectValueToWord(t, expect, type);
         }));
     }
     else if ((0, types_1.isKeyword)(type)) {
@@ -227,6 +224,23 @@ function createExpectedObject(type, matches, t) {
             : expectedObject[0];
     return expects;
 }
+function expectValueToWord(t, expect, type) {
+    switch (expect.type) {
+        case 'common':
+            return expect.value;
+        case 'const':
+            return expect.value ? `%${expect.value}%` : '';
+        case 'format':
+            return t('the {0} format', expect.value);
+        case 'regxp':
+            return t('{0} ({1})', 'regular expression', expect.value);
+        case 'syntax':
+            if ((0, types_1.isKeyword)(type) && type[0] === '<') {
+                return t('the CSS Syntax "{0}"', expect.value);
+            }
+            return t('{0} syntax', expect.value);
+    }
+}
 function createExpectedNumber(t, type) {
     if (type.gt != null) {
         if (type.lt != null) {

package/lib/deprecated-attr/index.js

@@ -1,13 +1,12 @@
 "use strict";
 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)({
     defaultValue: null,
     defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (element) => {
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(element.nameWithNS, document.specs);
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(element.nameWithNS, document.specs);
             if (!attrSpecs) {
                 return;
             }

package/lib/helpers.d.ts

@@ -1,7 +1,7 @@
+import type { Log } from './debug';
 import type { Translator } from '@markuplint/i18n';
 import type { Element, RuleConfigValue } from '@markuplint/ml-core';
-import type { ARIRRoleAttribute, Attribute, MLMLSpec, PermittedRoles } from '@markuplint/ml-spec';
-export declare function getAttrSpecs(nameWithNS: string, { specs, def }: MLMLSpec): Attribute[] | null;
+import type { ARIRRoleAttribute, Attribute, PermittedRoles } from '@markuplint/ml-spec';
 export declare function attrMatches<T extends RuleConfigValue, R>(node: Element<T, R>, condition: Attribute['condition']): boolean;
 export declare function match(needle: string, pattern: string): boolean;
 /**
@@ -21,9 +21,14 @@ export declare function match(needle: string, pattern: string): boolean;
  */
 export declare const rePCENChar: string;
 export declare function htmlSpec(nameWithNS: string): import("@markuplint/ml-spec").ElementSpec | null;
-export declare function isValidAttr(t: Translator, name: string, value: string, isDynamicValue: boolean, node: Element<any, any>, attrSpecs: Attribute[]): false | {
+export declare function isValidAttr(t: Translator, name: string, value: string, isDynamicValue: boolean, node: Element<any, any>, attrSpecs: Attribute[], log?: Log): false | {
     invalidType: "non-existent" | "invalid-value";
     message: string;
+    loc?: {
+        raw: string;
+        line: number;
+        col: number;
+    } | undefined;
 };
 export declare function ariaSpec(): {
     roles: ARIRRoleAttribute[];

package/lib/helpers.js

@@ -1,45 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAria = exports.checkAriaValue = exports.getComputedRole = exports.getImplicitRole = exports.getPermittedRoles = exports.getRoleSpec = exports.ariaSpec = exports.isValidAttr = exports.htmlSpec = exports.rePCENChar = exports.match = exports.attrMatches = exports.getAttrSpecs = void 0;
+exports.checkAria = exports.checkAriaValue = exports.getComputedRole = exports.getImplicitRole = exports.getPermittedRoles = exports.getRoleSpec = exports.ariaSpec = exports.isValidAttr = exports.htmlSpec = exports.rePCENChar = exports.match = exports.attrMatches = void 0;
 const html_spec_1 = require("@markuplint/html-spec");
 const attr_check_1 = require("./attr-check");
-function getAttrSpecs(nameWithNS, { specs, def }) {
-    const spec = specs.find(spec => spec.name === nameWithNS);
-    if (!spec) {
-        return null;
-    }
-    const globalAttrs = def['#globalAttrs'];
-    const attrs = [];
-    if (!/[a-z]:[a-z]/i.test(nameWithNS)) {
-        // It's HTML tag
-        const hasGlobalAttr = spec.attributes.some(attr => attr === '#globalAttrs');
-        if (hasGlobalAttr) {
-            attrs.push(...(globalAttrs['#HTMLGlobalAttrs'] || []));
-        }
-    }
-    for (const attr of spec.attributes) {
-        if (typeof attr === 'string') {
-            const globalAttr = globalAttrs[attr];
-            if (!globalAttr) {
-                continue;
-            }
-            attrs.push(...globalAttr);
-            continue;
-        }
-        const definedIndex = attrs.findIndex(a => a.name === attr.name);
-        if (definedIndex !== -1) {
-            attrs[definedIndex] = {
-                ...attrs[definedIndex],
-                ...attr,
-            };
-            continue;
-        }
-        attrs.push(attr);
-    }
-    attrs.push(...(globalAttrs['#extends'] || []));
-    return attrs;
-}
-exports.getAttrSpecs = getAttrSpecs;
 function attrMatches(node, condition) {
     if (!condition) {
         return true;
@@ -53,7 +16,10 @@ function attrMatches(node, condition) {
         let _node = node.parentNode;
         while (_node) {
             if (_node.type === 'Element') {
-                if (_node.matches(condition.ancestor)) {
+                const condSelector = Array.isArray(condition.ancestor)
+                    ? condition.ancestor.join(',')
+                    : condition.ancestor;
+                if (_node.matches(condSelector)) {
                     matched = true;
                     break;
                 }
@@ -114,9 +80,10 @@ function htmlSpec(nameWithNS) {
     return spec || null;
 }
 exports.htmlSpec = htmlSpec;
-function isValidAttr(t, name, value, isDynamicValue, node, attrSpecs) {
+function isValidAttr(t, name, value, isDynamicValue, node, attrSpecs, log) {
     let invalid = false;
-    const spec = attrSpecs.find(s => s.name === name);
+    const spec = attrSpecs.find(s => s.name.toLowerCase() === name.toLowerCase());
+    log && log('Spec of the %s attr: %o', name, spec);
     invalid = (0, attr_check_1.attrCheck)(t, name, value, false, spec);
     if (!invalid && spec && spec.condition && !node.hasSpreadAttr && !attrMatches(node, spec.condition)) {
         invalid = {

package/lib/index.d.ts

@@ -15,13 +15,16 @@ declare const _default: {
     }>;
     'id-duplication': import("packages/@markuplint/ml-core/lib").RuleSeed<null, null>;
     indentation: import("packages/@markuplint/ml-core/lib").RuleSeed<import("./indentation").Value, import("./indentation").IndentationOptions>;
+    'ineffective-attr': import("packages/@markuplint/ml-core/lib").RuleSeed<boolean, null>;
     'invalid-attr': import("packages/@markuplint/ml-core/lib").RuleSeed<true, {
         attrs?: Record<string, {
-            enum: string[];
+            enum: [string, ...string[]];
         } | {
             pattern: string;
         } | {
             type: import("packages/@markuplint/ml-spec/lib").AttributeType;
+        } | {
+            disallowed: true;
         }> | undefined;
         ignoreAttrNamePrefix?: string | string[] | undefined;
     }>;
@@ -29,10 +32,14 @@ declare const _default: {
         ignoreRoles?: (("banner" | "main" | "complementary" | "contentinfo") | "form" | "navigation" | "region")[] | undefined;
         labelEachArea?: boolean | undefined;
     }>;
+    'no-boolean-attr-value': import("packages/@markuplint/ml-core/lib").RuleSeed<boolean, null>;
     'permitted-contents': import("packages/@markuplint/ml-core/lib").RuleSeed<import("packages/@markuplint/ml-spec/lib").PermittedStructuresSchema[], {
         ignoreHasMutableChildren: boolean;
     }>;
-    'required-attr': import("packages/@markuplint/ml-core/lib").RuleSeed<string | string[], null>;
+    'required-attr': import("packages/@markuplint/ml-core/lib").RuleSeed<string | (string | {
+        name: string;
+        value: string | string[];
+    })[], null>;
     'required-h1': import("packages/@markuplint/ml-core/lib").RuleSeed<boolean, import("./required-h1").RequiredH1Options>;
     'wai-aria': import("packages/@markuplint/ml-core/lib").RuleSeed<true, {
         checkingValue?: boolean | undefined;

package/lib/index.js

@@ -15,8 +15,10 @@ const deprecated_element_1 = (0, tslib_1.__importDefault)(require("./deprecated-
 const doctype_1 = (0, tslib_1.__importDefault)(require("./doctype"));
 const id_duplication_1 = (0, tslib_1.__importDefault)(require("./id-duplication"));
 const indentation_1 = (0, tslib_1.__importDefault)(require("./indentation"));
+const ineffective_attr_1 = (0, tslib_1.__importDefault)(require("./ineffective-attr"));
 const invalid_attr_1 = (0, tslib_1.__importDefault)(require("./invalid-attr"));
 const landmark_roles_1 = (0, tslib_1.__importDefault)(require("./landmark-roles"));
+const no_boolean_attr_value_1 = (0, tslib_1.__importDefault)(require("./no-boolean-attr-value"));
 const permitted_contents_1 = (0, tslib_1.__importDefault)(require("./permitted-contents"));
 const required_attr_1 = (0, tslib_1.__importDefault)(require("./required-attr"));
 const required_h1_1 = (0, tslib_1.__importDefault)(require("./required-h1"));
@@ -36,8 +38,10 @@ exports.default = {
     doctype: doctype_1.default,
     'id-duplication': id_duplication_1.default,
     indentation: indentation_1.default,
+    'ineffective-attr': ineffective_attr_1.default,
     'invalid-attr': invalid_attr_1.default,
     'landmark-roles': landmark_roles_1.default,
+    'no-boolean-attr-value': no_boolean_attr_value_1.default,
     'permitted-contents': permitted_contents_1.default,
     'required-attr': required_attr_1.default,
     'required-h1': required_h1_1.default,

package/lib/ineffective-attr/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, null>;
+export default _default;

package/lib/ineffective-attr/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    defaultServerity: 'warning',
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        document.walkOn('Element', el => {
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(el.nameWithNS, document.specs);
+            if (!attrSpec) {
+                return;
+            }
+            for (const attr of el.attributes) {
+                if (attr.attrType === 'ps-attr') {
+                    continue;
+                }
+                const name = attr.getName().potential;
+                const spec = attrSpec.find(s => s.name === name);
+                if (!spec) {
+                    continue;
+                }
+                const ineffectiveConditions = spec.ineffective
+                    ? Array.isArray(spec.ineffective)
+                        ? spec.ineffective
+                        : [spec.ineffective]
+                    : [];
+                if (ineffectiveConditions.some(selector => el.matches(selector))) {
+                    report({
+                        scope: el,
+                        raw: attr.raw,
+                        line: attr.startLine,
+                        col: attr.startCol,
+                        message: t('{0} is {1:c}', t('the "{0}" {1}', name, 'attribute'), 'ineffective') +
+                            t('. ') +
+                            t("It doesn't need {0}", t('the {0}', 'attribute')),
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/invalid-attr/index.d.ts

@@ -4,11 +4,13 @@ declare type Option = {
     ignoreAttrNamePrefix?: string | string[];
 };
 declare type Rule = {
-    enum: string[];
+    enum: [string, ...string[]];
 } | {
     pattern: string;
 } | {
     type: AttributeType;
+} | {
+    disallowed: true;
 };
 declare const _default: import("@markuplint/ml-core").RuleSeed<true, Option>;
 export default _default;

package/lib/invalid-attr/index.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 const attr_check_1 = require("../attr-check");
+const debug_1 = require("../debug");
 const helpers_1 = require("../helpers");
+const log = debug_1.log.extend('invalid-attr');
 exports.default = (0, ml_core_1.createRule)({
     defaultValue: true,
     defaultOptions: {},
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
             for (const attr of node.attributes) {
                 if (attr.attrType === 'html-attr' && attr.isDirective) {
                     continue;
@@ -61,9 +64,16 @@ exports.default = (0, ml_core_1.createRule)({
                     else if ('type' in customRule) {
                         invalid = (0, attr_check_1.attrCheck)(t, name, value, true, { name, type: customRule.type, description: '' });
                     }
+                    else if ('disallowed' in customRule && customRule.disallowed) {
+                        invalid = {
+                            invalidType: 'non-existent',
+                            message: t('{0} is disallowed', t('the "{0}" {1}', name, 'attribute')),
+                        };
+                    }
                 }
                 else if (!node.isCustomElement && attrSpecs) {
-                    invalid = (0, helpers_1.isValidAttr)(t, name, value, (attr.attrType === 'html-attr' && attr.isDynamicValue) || false, node, attrSpecs);
+                    log('Checking %s[%s="%s"]', node.nodeName, name, value);
+                    invalid = (0, helpers_1.isValidAttr)(t, name, value, (attr.attrType === 'html-attr' && attr.isDynamicValue) || false, node, attrSpecs, log);
                 }
                 if (invalid) {
                     switch (invalid.invalidType) {
@@ -71,9 +81,9 @@ exports.default = (0, ml_core_1.createRule)({
                             report({
                                 scope: node,
                                 message: invalid.message,
-                                line: attrValue.line,
-                                col: attrValue.col,
-                                raw: value,
+                                line: attrValue.line + ((_b = (_a = invalid.loc) === null || _a === void 0 ? void 0 : _a.line) !== null && _b !== void 0 ? _b : 0),
+                                col: ((_c = invalid.loc) === null || _c === void 0 ? void 0 : _c.line) ? ((_d = invalid.loc) === null || _d === void 0 ? void 0 : _d.col) + 1 : attrValue.col + ((_f = (_e = invalid.loc) === null || _e === void 0 ? void 0 : _e.col) !== null && _f !== void 0 ? _f : 0),
+                                raw: (_h = (_g = invalid.loc) === null || _g === void 0 ? void 0 : _g.raw) !== null && _h !== void 0 ? _h : value,
                             });
                             break;
                         }

package/lib/no-boolean-attr-value/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, null>;
+export default _default;

package/lib/no-boolean-attr-value/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    defaultServerity: 'warning',
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        document.walkOn('Element', el => {
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(el.nameWithNS, document.specs);
+            if (!attrSpec) {
+                return;
+            }
+            for (const attr of el.attributes) {
+                if (attr.attrType === 'ps-attr') {
+                    continue;
+                }
+                const name = attr.getName().potential;
+                const spec = attrSpec.find(s => s.name === name);
+                if (!spec) {
+                    continue;
+                }
+                if (spec.type !== 'Boolean') {
+                    continue;
+                }
+                const extraTokens = [
+                    attr.spacesBeforeEqual,
+                    attr.equal,
+                    attr.spacesAfterEqual,
+                    attr.startQuote,
+                    attr.value,
+                    attr.endQuote,
+                ];
+                const extraRaw = extraTokens.reduce((raw, t) => raw + t.raw, '');
+                if (extraRaw) {
+                    report({
+                        scope: el,
+                        raw: extraRaw,
+                        line: attr.spacesBeforeEqual.startLine,
+                        col: attr.spacesBeforeEqual.startCol,
+                        message: t('{0} is {1}', t('the "{0}" {1}', name, 'attribute'), t('a {0}', 'boolean attribute')) +
+                            t('. ') +
+                            t("It doesn't need {0}", t('the {0}', 'value')),
+                    });
+                }
+            }
+        });
+    },
+});

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

@@ -1,3 +1,7 @@
-declare type RequiredAttributes = string | string[];
+declare type RequiredAttributes = string | (string | Attr)[];
+declare type Attr = {
+    name: string;
+    value: string | string[];
+};
 declare const _default: import("@markuplint/ml-core").RuleSeed<RequiredAttributes, null>;
 export default _default;

package/lib/required-attr/index.js

@@ -7,29 +7,45 @@ exports.default = (0, ml_core_1.createRule)({
     defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
+            var _a;
             if (node.hasSpreadAttr) {
                 return;
             }
             const customRequiredAttrs = typeof node.rule.value === 'string' ? [node.rule.value] : node.rule.value;
-            const attrSpec = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
-            const attributeSpecs = attrSpec
-                ? attrSpec.map(attr => {
-                    const required = customRequiredAttrs.includes(attr.name);
-                    if (required) {
-                        return {
-                            ...attr,
-                            required: true,
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const attributeSpecs = {};
+            if (attrSpec) {
+                for (const spec of attrSpec) {
+                    if (spec.required || spec.requiredEither || spec.condition) {
+                        attributeSpecs[spec.name] = {
+                            ...spec,
+                            values: [],
                         };
                     }
-                    return attr;
-                })
-                : customRequiredAttrs.map(attr => ({
-                    name: attr,
+                }
+            }
+            for (const req of customRequiredAttrs) {
+                let name;
+                const values = [];
+                if (typeof req === 'string') {
+                    name = req;
+                }
+                else {
+                    name = req.name;
+                    if (Array.isArray(req.value)) {
+                        values.push(...req.value);
+                    }
+                    else {
+                        values.push(req.value);
+                    }
+                }
+                attributeSpecs[name] = {
+                    name,
+                    values,
                     required: true,
-                    requiredEither: undefined,
-                    condition: undefined,
-                }));
-            for (const spec of attributeSpecs) {
+                };
+            }
+            for (const spec of Object.values(attributeSpecs)) {
                 const didntHave = !node.hasAttribute(spec.name);
                 let invalid = false;
                 if (spec.requiredEither) {
@@ -41,17 +57,43 @@ exports.default = (0, ml_core_1.createRule)({
                 }
                 else if (spec.required) {
                     if ('ancestor' in spec.required && spec.required.ancestor) {
-                        const ancestors = spec.required.ancestor.split(',').map(a => a.trim());
+                        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;
                     }
                 }
                 if (invalid) {
-                    const message = t('{0} expects {1}', t('the "{0}" {1}', spec.name, 'attribute'), t('the "{0}" {1}', node.nodeName, 'element'));
+                    const message = t('{0} expects {1}', t('the "{0}" {1}', node.nodeName, 'element'), t('the "{0}" {1}', spec.name, 'attribute'));
                     report({
                         scope: node,
                         message,
                     });
                 }
+                const value = node.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].value : null;
+                        const token = valueToken || attrToken[0];
+                        report({
+                            scope: {
+                                rule: node.rule,
+                                raw: token.raw,
+                                startCol: token.startCol,
+                                startLine: token.startLine,
+                            },
+                            message,
+                        });
+                    }
+                }
             }
         });
     },

package/lib/wai-aria/index.js

@@ -14,7 +14,7 @@ exports.default = (0, ml_core_1.createRule)({
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
             const html = (0, helpers_1.htmlSpec)(node.nodeName);
             const { roles, ariaAttrs } = (0, helpers_1.ariaSpec)();
             if (!html || !attrSpecs) {
@@ -167,7 +167,7 @@ exports.default = (0, ml_core_1.createRule)({
                                 scope: node,
                                 message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0}"', value), 'disallowed'), t('the "{0}" {1}', attrName, 'ARIA state/property')) +
                                     ('enum' in result && result.enum.length
-                                        ? t('. ') + t('Arrowed values are: {0}', t(result.enum))
+                                        ? t('. ') + t('Allowed values are: {0}', t(result.enum))
                                         : ''),
                                 line: attr.startLine,
                                 col: attr.startCol,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "2.0.0-dev.20211209.0",
+	"version": "2.0.0-dev.20211213.0",
 	"description": "Rules for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,10 +17,15 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "2.0.0-dev.2021117.0",
-		"@markuplint/ml-core": "2.0.0-dev.20211209.0",
-		"@markuplint/ml-spec": "2.0.0-dev.20211115.0",
+		"@markuplint/html-spec": "2.0.0-dev.20211213.0",
+		"@markuplint/ml-core": "2.0.0-dev.20211213.0",
+		"@markuplint/ml-spec": "2.0.0-dev.20211213.0",
+		"@markuplint/types": "1.0.0-dev.20211213.0",
+		"debug": "^4.3.2",
 		"tslib": "^2.3.1"
 	},
-	"gitHead": "6c0d7ada880a331257624180d593f6d53b73e98f"
+	"devDependencies": {
+		"@types/debug": "^4.1.7"
+	},
+	"gitHead": "8f4682ca3e0937082af8c39b999443afa4a1aef3"
 }