@markuplint/rules 3.0.0 → 3.1.0

package/lib/attr-check.d.ts

@@ -1,7 +1,7 @@
 import type { Translator } from '@markuplint/i18n';
 import type { Attribute as AttrSpec, AttributeType } from '@markuplint/ml-spec';
 type Invalid = {
-    invalidType: 'non-existent' | 'invalid-value';
+    invalidType: 'non-existent' | 'invalid-value' | 'disallowed-attr';
     message: string;
     loc?: Loc;
 };

package/lib/attr-check.js

@@ -41,6 +41,12 @@ function attrCheck(t, name, value, isCustomRule, spec) {
                 t('Did you mean "{0*}"?', spec.name),
         };
     }
+    if (spec.noUse) {
+        return {
+            invalidType: 'disallowed-attr',
+            message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed'),
+        };
+    }
     const types = Array.isArray(spec.type) ? spec.type : [spec.type];
     const invalidList = types.map(type => {
         if (!type) {

package/lib/debug.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.log = void 0;
 const tslib_1 = require("tslib");
 const debug_1 = tslib_1.__importDefault(require("debug"));
-exports.log = (0, debug_1.default)('markuplint-rules');
+exports.log = (0, debug_1.default)('ml-rules');

package/lib/helpers.d.ts

@@ -21,7 +21,7 @@ export declare function match(needle: string, pattern: string): boolean;
  */
 export declare const rePCENChar: string;
 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";
+    invalidType: "non-existent" | "invalid-value" | "disallowed-attr";
     message: string;
     loc?: {
         raw: string;

package/lib/index.js

@@ -25,6 +25,7 @@ const no_refer_to_non_existent_id_1 = tslib_1.__importDefault(require("./no-refe
 const no_use_event_handler_attr_1 = tslib_1.__importDefault(require("./no-use-event-handler-attr"));
 const permitted_contents_1 = tslib_1.__importDefault(require("./permitted-contents"));
 const require_accessible_name_1 = tslib_1.__importDefault(require("./require-accessible-name"));
+const require_datetime_1 = tslib_1.__importDefault(require("./require-datetime"));
 const required_attr_1 = tslib_1.__importDefault(require("./required-attr"));
 const required_element_1 = tslib_1.__importDefault(require("./required-element"));
 const required_h1_1 = tslib_1.__importDefault(require("./required-h1"));
@@ -55,6 +56,7 @@ exports.default = {
     'no-use-event-handler-attr': no_use_event_handler_attr_1.default,
     'permitted-contents': permitted_contents_1.default,
     'require-accessible-name': require_accessible_name_1.default,
+    'require-datetime': require_datetime_1.default,
     'required-attr': required_attr_1.default,
     'required-element': required_element_1.default,
     'required-h1': required_h1_1.default,

package/lib/invalid-attr/index.js

@@ -77,6 +77,13 @@ exports.default = (0, ml_core_1.createRule)({
             }
             if (invalid) {
                 switch (invalid.invalidType) {
+                    case 'disallowed-attr': {
+                        report({
+                            scope: attr,
+                            message: invalid.message,
+                        });
+                        break;
+                    }
                     case 'invalid-value': {
                         if (attr.isDynamicValue) {
                             break;

package/lib/no-empty-palpable-content/index.js

@@ -10,6 +10,14 @@ exports.default = (0, ml_core_1.createRule)({
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
+            /**
+             * Exception
+             *
+             * - The `textarea` element is possibly empty because a user inputs it.
+             */
+            if (el.localName === 'textarea') {
+                return;
+            }
             if (!(0, ml_spec_1.isPalpableElement)(el, el.ownerMLDocument.specs, {
                 extendsSvg: false,
                 extendsExposableElements: el.rule.options.extendsExposableElements,

package/lib/no-refer-to-non-existent-id/index.d.ts

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

package/lib/no-refer-to-non-existent-id/index.js

@@ -1,15 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
+const HYPERLINK_SELECTOR = 'a[href], area[href]';
 exports.default = (0, ml_core_1.createRule)({
     defaultOptions: {
         ariaVersion: '1.2',
+        fragmentRefersNameAttr: false,
     },
     async verify({ document, report, t }) {
         const idList = new Set();
+        const nameList = new Set();
         let hasDynamicId = false;
-        await document.walkOn('Attr', attr => {
-            if (attr.name.toLowerCase() !== 'id') {
+        let hasDynamicName = false;
+        document.querySelectorAll('[id]').forEach(el => {
+            const attr = el.getAttributeNode('id');
+            if (!attr) {
                 return;
             }
             if (attr.isDynamicValue) {
@@ -22,6 +27,18 @@ exports.default = (0, ml_core_1.createRule)({
         if (hasDynamicId) {
             return;
         }
+        document.querySelectorAll('[name]').forEach(el => {
+            const attr = el.getAttributeNode('name');
+            if (!attr) {
+                return;
+            }
+            if (attr.isDynamicValue) {
+                hasDynamicName = true;
+            }
+            if (attr.valueType !== 'code') {
+                nameList.add(attr.value);
+            }
+        });
         await document.walkOn('Attr', attr => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             const attrSpec = (0, ml_core_1.getAttrSpecs)(attr.ownerElement, document.specs);
@@ -100,5 +117,53 @@ exports.default = (0, ml_core_1.createRule)({
                 }
             }
         });
+        /**
+         * @see https://html.spec.whatwg.org/multipage/browsing-the-web.html#scrolling-to-a-fragment
+         */
+        await document.walkOn('Element', el => {
+            var _a, _b, _c, _d;
+            if (el.rule.options.fragmentRefersNameAttr && hasDynamicName) {
+                return;
+            }
+            if (!el.matches(HYPERLINK_SELECTOR)) {
+                return;
+            }
+            const href = el.getAttributeNode('href');
+            if (!href) {
+                return;
+            }
+            const rawFragment = (_a = href.value.match(/^#(.+)/)) === null || _a === void 0 ? void 0 : _a[1];
+            if (rawFragment == null) {
+                return;
+            }
+            const decodedFragment = decode(rawFragment);
+            // > 2. If fragment is the empty string, then return the special value top of the document.
+            // >
+            // > 9. If decodedFragment is an ASCII case-insensitive match for the string top, then return the top of the document.
+            if (decodedFragment === '' || /^top$/i.test(decodedFragment)) {
+                return;
+            }
+            if (!idList.has(decodedFragment) &&
+                (el.rule.options.fragmentRefersNameAttr ? !nameList.has(decodedFragment) : true)) {
+                report({
+                    scope: href,
+                    line: (_b = href.valueNode) === null || _b === void 0 ? void 0 : _b.startLine,
+                    col: (_c = href.valueNode) === null || _c === void 0 ? void 0 : _c.startCol,
+                    raw: (_d = href.valueNode) === null || _d === void 0 ? void 0 : _d.raw,
+                    message: t('Missing {0}', t('"{0*}" ID', decodedFragment)),
+                });
+            }
+        });
     },
 });
+function decode(fragment) {
+    try {
+        return decodeURI(fragment);
+    }
+    catch (e) {
+        if (e instanceof URIError) {
+            return fragment;
+        }
+        throw e;
+    }
+}

package/lib/permitted-contents/choice.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.choice = void 0;
+const debug_1 = require("./debug");
 const order_1 = require("./order");
 const utils_1 = require("./utils");
+const indexes = new WeakMap();
 function choice(pattern, elements, specs, options, depth) {
+    const choiceLog = debug_1.cmLog.extend(`choice#${depth}`);
     const collection = new utils_1.Collection(elements);
     const unmatchedResults = [];
+    let i = 0;
     for (const some of pattern.choice) {
+        choiceLog('Patterns[%s]: %s', i, (0, utils_1.modelLog)(some, ''));
         const result = (0, order_1.order)(some, collection.unmatched, specs, options, depth + 1);
         if (result.type === 'UNEXPECTED_EXTRA_NODE' || result.type === 'MATCHED' || result.type === 'MATCHED_ZERO') {
+            choiceLog('Results[%s]: %s', i, choiceLogString(pattern.choice, i));
             collection.addMatched(result.matched);
             return {
                 type: result.type,
@@ -20,11 +26,27 @@ function choice(pattern, elements, specs, options, depth) {
             };
         }
         unmatchedResults.push(result);
+        indexes.set(result, i);
+        i++;
     }
-    const barelyMatchedResult = unmatchedResults.sort((a, b) => b.matched.length - a.matched.length)[0];
+    const barelyMatchedResult = unmatchedResults.sort((a, b) => {
+        var _c, _d, _e, _f;
+        const computed1 = b.matched.length - a.matched.length;
+        if (computed1 !== 0) {
+            return computed1;
+        }
+        const _a = (_d = (_c = a.hint.missing) === null || _c === void 0 ? void 0 : _c.barelyMatchedElements) !== null && _d !== void 0 ? _d : 0;
+        const _b = (_f = (_e = b.hint.missing) === null || _e === void 0 ? void 0 : _e.barelyMatchedElements) !== null && _f !== void 0 ? _f : 0;
+        const computed2 = _b - _a;
+        return computed2;
+    })[0];
     if (!barelyMatchedResult) {
         throw new Error('Unreachable code');
     }
+    const index = indexes.get(barelyMatchedResult);
+    if (index != null) {
+        choiceLog('Results[%s]: %s', index, choiceLogString(pattern.choice, index, true));
+    }
     return {
         type: barelyMatchedResult.type,
         matched: collection.matched,
@@ -35,3 +57,14 @@ function choice(pattern, elements, specs, options, depth) {
     };
 }
 exports.choice = choice;
+function choiceLogString(choice, index, barely = false) {
+    const colorFn = barely ? debug_1.bgBlue : debug_1.bgGreen;
+    return choice
+        .map((pattern, i) => {
+        if (i === index) {
+            return colorFn((0, utils_1.modelLog)(pattern, ''));
+        }
+        return (0, utils_1.modelLog)(pattern, '');
+    })
+        .join(', ');
+}

package/lib/permitted-contents/count-pattern.js

@@ -15,94 +15,72 @@ const utils_1 = require("./utils");
  * @returns
  */
 function countPattern(pattern, elements, specs, options, depth) {
-    var _a, _b, _c, _d, _e;
     const ptLog = debug_1.cmLog.extend(`countPattern#${depth}`);
     const collection = new utils_1.Collection(elements);
-    let min;
-    let max;
-    let model;
-    let type;
-    let _type;
-    if ((0, utils_1.isRequire)(pattern)) {
-        min = (_a = pattern.min) !== null && _a !== void 0 ? _a : 1;
-        max = Math.max((_b = pattern.max) !== null && _b !== void 0 ? _b : 1, min);
-        model = pattern.require;
-        type = 'MISSING_NODE_REQUIRED';
-        _type = 'require';
-    }
-    else if ((0, utils_1.isOptional)(pattern)) {
-        min = 0;
-        max = Math.max((_c = pattern.max) !== null && _c !== void 0 ? _c : 1, 1);
-        model = pattern.optional;
-        _type = 'optional';
-    }
-    else if ((0, utils_1.isOneOrMore)(pattern)) {
-        min = 1;
-        max = Math.max((_d = pattern.max) !== null && _d !== void 0 ? _d : Infinity, 1);
-        model = pattern.oneOrMore;
-        type = 'MISSING_NODE_ONE_OR_MORE';
-        _type = 'one or more';
-    }
-    else if ((0, utils_1.isZeroOrMore)(pattern)) {
-        min = 0;
-        max = Math.max((_e = pattern.max) !== null && _e !== void 0 ? _e : Infinity, 1);
-        model = pattern.zeroOrMore;
-        _type = 'zero or more';
-    }
-    else {
-        throw new Error('Unreachable code');
-    }
-    ptLog('%s: %o', _type, model);
+    const { model, min, max, repeat, missingType } = (0, utils_1.normalizeModel)(pattern);
+    ptLog('Model:\n  RegEx: %s\n  Schema: %o', (0, utils_1.modelLog)(model, repeat), pattern);
     let prevResult = null;
+    let barelyResult = null;
+    let loopCount = 0;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        ptLog('%s', collection);
+        loopCount++;
+        ptLog('Check#%s: %s', loopCount, collection);
         const result = (0, recursive_branch_1.recursiveBranch)(model, collection.unmatched, specs, options, depth);
         const added = collection.addMatched(result.matched);
+        const { matchedCount } = collection;
         if (result.type === 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY') {
-            ptLog('MATCHED_ZERO: %s', result.query);
-            return {
+            ptLog('MATCHED_ZERO:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', (0, utils_1.modelLog)(model, repeat), max, collection, matchedCount);
+            return compereResult({
                 type: 'MATCHED_ZERO',
                 matched: collection.matched,
                 unmatched: collection.unmatched,
                 zeroMatch: true,
                 query: result.query,
                 hint: result.hint,
-            };
+            }, barelyResult);
         }
         if (max < collection.matchedCount) {
             collection.max(max);
-            ptLog('UNEXPECTED_EXTRA_NODE (max: %s): %s', max, result.query);
-            return {
+            ptLog('UNEXPECTED_EXTRA_NODE:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', (0, utils_1.modelLog)(model, repeat), max, collection, matchedCount);
+            return compereResult({
                 type: 'UNEXPECTED_EXTRA_NODE',
                 matched: collection.matched,
                 unmatched: collection.unmatched,
                 zeroMatch: result.zeroMatch,
                 query: result.query,
-                hint: {
-                    ...result.hint,
-                    max,
-                },
-            };
+                hint: (0, utils_1.mergeHints)(result.hint, { max }),
+            }, barelyResult);
         }
         if (prevResult) {
             if (result.type === 'MISSING_NODE_ONE_OR_MORE' ||
                 result.type === 'MISSING_NODE_REQUIRED' ||
                 result.type === 'TRANSPARENT_MODEL_DISALLOWS') {
-                ptLog('%s(continued): %s', result.type, collection);
-                return {
+                ptLog('%s(continued): %s; Needs', result.type, collection, result.query);
+                return compereResult({
                     type: result.type,
                     matched: collection.matched,
                     unmatched: collection.unmatched,
                     zeroMatch: result.zeroMatch,
                     query: result.query,
                     hint: result.hint,
-                };
+                }, barelyResult);
             }
             ptLog('%s(continued): %s', prevResult.type, collection);
-            return prevResult;
+            return compereResult(prevResult, barelyResult);
         }
         if (added && collection.unmatched.length > 0) {
+            if (result.type !== 'MISSING_NODE' && result.type !== 'UNMATCHED_SELECTORS') {
+                barelyResult = {
+                    type: result.type,
+                    matched: collection.matched,
+                    unmatched: collection.unmatched,
+                    zeroMatch: result.zeroMatch,
+                    query: result.query,
+                    hint: result.hint,
+                };
+            }
+            ptLog('continue⤴️');
             continue;
         }
         if (collection.matchedCount + (result.zeroMatch ? 1 : 0) < min) {
@@ -110,16 +88,21 @@ function countPattern(pattern, elements, specs, options, depth) {
                 result.type === 'MISSING_NODE_ONE_OR_MORE' ||
                 result.type === 'TRANSPARENT_MODEL_DISALLOWS'
                 ? result.type
-                : type !== null && type !== void 0 ? type : 'MISSING_NODE_REQUIRED';
-            ptLog('%s(in %s): %s', resultType, type, result.query);
-            return {
+                : missingType !== null && missingType !== void 0 ? missingType : 'MISSING_NODE_REQUIRED';
+            ptLog('%s(in %s); Needs %s', resultType, missingType, result.query);
+            return compereResult({
                 type: resultType,
                 matched: collection.matched,
                 unmatched: collection.unmatched,
                 zeroMatch: result.zeroMatch,
                 query: result.query,
-                hint: result.hint,
-            };
+                hint: (0, utils_1.mergeHints)(result.hint, {
+                    missing: {
+                        barelyMatchedElements: collection.matched.length,
+                        need: result.query,
+                    },
+                }),
+            }, barelyResult);
         }
         const resultType = collection.matched.length === 0 ? 'MATCHED_ZERO' : 'MATCHED';
         const zeroMatch = result.zeroMatch || min === 0 || resultType === 'MATCHED_ZERO';
@@ -129,27 +112,44 @@ function countPattern(pattern, elements, specs, options, depth) {
             unmatched: collection.unmatched,
             zeroMatch,
             query: result.query,
-            hint: result.hint,
+            hint: (0, utils_1.mergeHints)(result.hint, {
+                missing: {
+                    barelyMatchedElements: collection.matched.length,
+                    need: result.query,
+                },
+            }),
         };
         if (!prevResult && collection.unmatched.length) {
-            ptLog('continue checking');
             prevResult = matchedResult;
+            ptLog('continue⤴️ (add prev)');
             continue;
         }
-        ptLog('%s: %s', resultType, collection);
+        ptLog('%s:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', resultType, (0, utils_1.modelLog)(model, repeat), max, collection, matchedCount);
         if (result.type === 'MISSING_NODE_REQUIRED' ||
             result.type === 'MISSING_NODE_ONE_OR_MORE' ||
             result.type === 'TRANSPARENT_MODEL_DISALLOWS') {
-            return {
+            return compereResult({
                 type: result.type,
                 matched: collection.matched,
                 unmatched: collection.unmatched,
                 zeroMatch: result.zeroMatch,
                 query: result.query,
                 hint: result.hint,
-            };
+            }, barelyResult);
         }
-        return matchedResult;
+        return compereResult(matchedResult, barelyResult);
     }
 }
 exports.countPattern = countPattern;
+const cLog = debug_1.cmLog.extend('countCompereResult');
+function compereResult(a, b) {
+    cLog('current: %s %O\nbarely: %s %O', a.type, a.hint, b === null || b === void 0 ? void 0 : b.type, b === null || b === void 0 ? void 0 : b.hint);
+    if (b == null) {
+        return a;
+    }
+    if (a.type === 'MATCHED' || a.type === 'MATCHED_ZERO' || a.type === 'UNEXPECTED_EXTRA_NODE') {
+        return a;
+    }
+    const result = [a, b].sort((a, b) => { var _a, _b, _c, _d; return ((_b = (_a = b.hint.missing) === null || _a === void 0 ? void 0 : _a.barelyMatchedElements) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = a.hint.missing) === null || _c === void 0 ? void 0 : _c.barelyMatchedElements) !== null && _d !== void 0 ? _d : 0); })[0];
+    return result;
+}

package/lib/permitted-contents/matches-selector.js

@@ -103,9 +103,9 @@ function matchesSelector(query, node, specs, options, depth) {
                 unmatched: [node],
                 zeroMatch: true,
                 query,
-                hint: {
+                hint: (0, utils_1.cleanObject)({
                     not: result.not,
-                },
+                }),
             };
         }
         return {
@@ -114,9 +114,9 @@ function matchesSelector(query, node, specs, options, depth) {
             unmatched: [node],
             zeroMatch: false,
             query,
-            hint: {
+            hint: (0, utils_1.cleanObject)({
                 not: result.not,
-            },
+            }),
         };
     }
     return {

package/lib/permitted-contents/order.js

@@ -16,11 +16,12 @@ const utils_1 = require("./utils");
  * @returns
  */
 function order(contents, nodes, specs, options, depth) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const orderLog = debug_1.cmLog.extend(`order#${depth}`);
     const btLog = debug_1.cmLog.extend(`backtrack#${depth}`);
     const patterns = (0, helpers_1.deepCopy)(contents);
     const collection = new utils_1.Collection(nodes);
+    orderLog('Model:\n  RegEx: %s\n  Schema: %o', (0, utils_1.modelLog)(patterns, ''), patterns);
     orderLog('Starts: %s', collection);
     let result = undefined;
     let backtrackMode = false;
@@ -29,28 +30,34 @@ function order(contents, nodes, specs, options, depth) {
     while (patterns.length) {
         result = (0, complex_branch_1.complexBranch)(patterns[0], collection.unmatched, specs, options, depth);
         collection.addMatched(result.matched);
-        orderLog('stack: %s', collection);
         if (result.type !== 'UNEXPECTED_EXTRA_NODE' && result.type !== 'MATCHED' && result.type !== 'MATCHED_ZERO') {
             unmatchedResults.push(result);
             if (backtrackMode) {
                 collection.back();
-                btLog('🔙');
+                btLog('🔙◀BACK');
                 backtrackMode = false;
                 afterBacktrack = true;
                 continue;
             }
-            orderLog('conformed (%s): %s', result.type, collection.toString(true));
             const barelyMatchedResult = unmatchedResults.sort((a, b) => b.matched.length - a.matched.length)[0];
             if (!barelyMatchedResult) {
                 throw new Error('Unreachable code');
             }
+            orderLog('Result (%s): %s%s', result.type, collection.toString(true), ((_a = barelyMatchedResult.hint.missing) === null || _a === void 0 ? void 0 : _a.barelyMatchedElements)
+                ? `; But ${barelyMatchedResult.hint.missing.barelyMatchedElements} elements hit out of pattern`
+                : '');
             return {
                 type: barelyMatchedResult.type,
                 matched: collection.matched,
                 unmatched: collection.unmatched,
                 zeroMatch: barelyMatchedResult.zeroMatch,
                 query: barelyMatchedResult.query,
-                hint: barelyMatchedResult.hint,
+                hint: (0, utils_1.mergeHints)(barelyMatchedResult.hint, {
+                    missing: {
+                        barelyMatchedElements: collection.matched.length,
+                        need: barelyMatchedResult.query,
+                    },
+                }),
             };
         }
         if (afterBacktrack) {
@@ -66,24 +73,25 @@ function order(contents, nodes, specs, options, depth) {
         patterns.shift();
     }
     if (collection.unmatched.length) {
-        orderLog('Conformed (UNEXPECTED_EXTRA_NODE): %s', collection.toString(true));
+        orderLog('Result (UNEXPECTED_EXTRA_NODE): %s', collection.toString(true));
         return {
             type: 'UNEXPECTED_EXTRA_NODE',
             matched: collection.matched,
             unmatched: collection.unmatched,
             zeroMatch: false,
-            query: (_a = result === null || result === void 0 ? void 0 : result.query) !== null && _a !== void 0 ? _a : 'N/A',
-            hint: (_b = result === null || result === void 0 ? void 0 : result.hint) !== null && _b !== void 0 ? _b : {},
+            query: (_b = result === null || result === void 0 ? void 0 : result.query) !== null && _b !== void 0 ? _b : 'N/A',
+            hint: (_c = result === null || result === void 0 ? void 0 : result.hint) !== null && _c !== void 0 ? _c : {},
         };
     }
-    orderLog('Conformed: %s', collection);
+    const resultType = collection.matched.length ? 'MATCHED' : 'MATCHED_ZERO';
+    orderLog('Result (%s): %s', resultType, collection.toString(true));
     return {
-        type: collection.matched.length ? 'MATCHED' : 'MATCHED_ZERO',
+        type: resultType,
         matched: collection.matched,
         unmatched: collection.unmatched,
         zeroMatch: false,
-        query: (_c = result === null || result === void 0 ? void 0 : result.query) !== null && _c !== void 0 ? _c : 'N/A',
-        hint: (_d = result === null || result === void 0 ? void 0 : result.hint) !== null && _d !== void 0 ? _d : {},
+        query: (_d = result === null || result === void 0 ? void 0 : result.query) !== null && _d !== void 0 ? _d : 'N/A',
+        hint: (_e = result === null || result === void 0 ? void 0 : result.hint) !== null && _e !== void 0 ? _e : {},
     };
 }
 exports.order = order;

package/lib/permitted-contents/types.d.ts

@@ -24,15 +24,21 @@ export type Result<T extends string = MatchedReason> = {
     unmatched: ChildNode[];
     zeroMatch: boolean;
     query: string;
-    hint: {
-        max?: number;
-        not?: ChildNode;
-        transparent?: Element;
+    hint: Hints;
+};
+export type Hints = {
+    max?: number;
+    not?: ChildNode;
+    transparent?: Element;
+    missing?: {
+        barelyMatchedElements?: number;
+        need?: string;
     };
 };
 export type MatchedReason = 'MATCHED' | 'MATCHED_ZERO';
 export type UnmatchedReason = 'NOTHING' | 'UNEXPECTED_EXTRA_NODE' | 'TRANSPARENT_MODEL_DISALLOWS' | MissingNodeReason;
 export type MissingNodeReason = 'MISSING_NODE_REQUIRED' | 'MISSING_NODE_ONE_OR_MORE';
+export type RepeatSign = '' | '?' | '+' | '*' | `{${number},${number}}`;
 export type TransparentModel = {
     el: Element;
     additionalCondition: string;

package/lib/permitted-contents/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ChildNode, Element, Specs } from './types';
+import type { ChildNode, Element, Hints, MissingNodeReason, RepeatSign, Specs } from './types';
 import type { PermittedContentPattern, PermittedContentChoice, PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentTransparent, PermittedContentZeroOrMore, Model } from '@markuplint/ml-spec';
 export declare function getChildNodesWithoutWhitespaces(el: Element): ChildNode[];
 export declare function isModel(model: Model | PermittedContentPattern[]): model is Model;
@@ -15,6 +15,23 @@ export declare function isOneOrMore(content: PermittedContentPattern): content i
 export declare function isZeroOrMore(content: PermittedContentPattern): content is PermittedContentZeroOrMore;
 export declare function isChoice(content: PermittedContentPattern): content is PermittedContentChoice;
 export declare function isTransparent(content: PermittedContentPattern): content is PermittedContentTransparent;
+export declare function normalizeModel(pattern: PermittedContentRequire | PermittedContentOptional | PermittedContentOneOrMore | PermittedContentZeroOrMore): {
+    model: PermittedContentPattern[] | Model;
+    min: number;
+    max: number;
+    repeat: RepeatSign;
+    missingType: MissingNodeReason | undefined;
+};
+export declare function mergeHints(a: Hints, b: Hints): Partial<{
+    missing: Partial<{
+        barelyMatchedElements?: number | undefined;
+        need?: string | undefined;
+    }> | undefined;
+    max?: number | undefined;
+    not?: import("packages/@markuplint/ml-core/lib").DocumentType<import("./types").TagRule[], import("./types").Options> | import("packages/@markuplint/ml-core/lib/ml-dom/node/character-data").MLCharacterData<import("./types").TagRule[], import("./types").Options, import("packages/@markuplint/ml-ast/lib").MLASTAbstractNode> | import("packages/@markuplint/ml-core/lib").Element<import("./types").TagRule[], import("./types").Options> | import("packages/@markuplint/ml-core/lib").Block<import("./types").TagRule[], import("./types").Options> | undefined;
+    transparent?: Element | undefined;
+}>;
+export declare function cleanObject<T extends Object>(object: T): Partial<T>;
 export declare class Collection {
     #private;
     constructor(origin: readonly ChildNode[]);
@@ -30,3 +47,4 @@ export declare class Collection {
 }
 export declare class UnsupportedError extends Error {
 }
+export declare function modelLog(model: Model | PermittedContentPattern[], repeat: RepeatSign): string;

package/lib/permitted-contents/utils.js

@@ -1,7 +1,7 @@
 "use strict";
 var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_origin;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedError = exports.Collection = exports.isTransparent = exports.isChoice = exports.isZeroOrMore = exports.isOneOrMore = exports.isOptional = exports.isRequire = exports.matches = exports.isModel = exports.getChildNodesWithoutWhitespaces = void 0;
+exports.modelLog = exports.UnsupportedError = exports.Collection = exports.cleanObject = exports.mergeHints = exports.normalizeModel = exports.isTransparent = exports.isChoice = exports.isZeroOrMore = exports.isOneOrMore = exports.isOptional = exports.isRequire = exports.matches = exports.isModel = exports.getChildNodesWithoutWhitespaces = void 0;
 const tslib_1 = require("tslib");
 const selector_1 = require("@markuplint/selector");
 const debug_1 = require("./debug");
@@ -95,6 +95,81 @@ function isTransparent(content) {
     return 'transparent' in content;
 }
 exports.isTransparent = isTransparent;
+function normalizeModel(pattern) {
+    var _a, _b, _c, _d, _e;
+    let model;
+    let min;
+    let max;
+    let repeat;
+    let missingType;
+    if (isRequire(pattern)) {
+        model = pattern.require;
+        min = (_a = pattern.min) !== null && _a !== void 0 ? _a : 1;
+        max = Math.max((_b = pattern.max) !== null && _b !== void 0 ? _b : 1, min);
+        missingType = 'MISSING_NODE_REQUIRED';
+    }
+    else if (isOptional(pattern)) {
+        model = pattern.optional;
+        min = 0;
+        max = Math.max((_c = pattern.max) !== null && _c !== void 0 ? _c : 1, 1);
+    }
+    else if (isOneOrMore(pattern)) {
+        model = pattern.oneOrMore;
+        min = 1;
+        max = Math.max((_d = pattern.max) !== null && _d !== void 0 ? _d : Infinity, 1);
+        missingType = 'MISSING_NODE_ONE_OR_MORE';
+    }
+    else if (isZeroOrMore(pattern)) {
+        model = pattern.zeroOrMore;
+        min = 0;
+        max = Math.max((_e = pattern.max) !== null && _e !== void 0 ? _e : Infinity, 1);
+    }
+    else {
+        throw new Error('Unreachable code');
+    }
+    if (min === 0 && max === 1) {
+        repeat = '?';
+    }
+    else if (min === 0 && !Number.isFinite(max)) {
+        repeat = '*';
+    }
+    else if (min === 1 && max === 1) {
+        repeat = '';
+    }
+    else if (min === 1 && !Number.isFinite(max)) {
+        repeat = '+';
+    }
+    else {
+        repeat = `{${min},${max}}`;
+    }
+    return {
+        model,
+        min,
+        max,
+        repeat,
+        missingType,
+    };
+}
+exports.normalizeModel = normalizeModel;
+function mergeHints(a, b) {
+    const missing = [a.missing, b.missing].sort((a, b) => { var _a, _b; return ((_a = b === null || b === void 0 ? void 0 : b.barelyMatchedElements) !== null && _a !== void 0 ? _a : 0) - ((_b = a === null || a === void 0 ? void 0 : a.barelyMatchedElements) !== null && _b !== void 0 ? _b : 0); })[0];
+    return cleanObject({
+        ...a,
+        ...b,
+        missing: missing && cleanObject(missing),
+    });
+}
+exports.mergeHints = mergeHints;
+function cleanObject(object) {
+    const newObject = {};
+    Object.entries(object).forEach(([key, value]) => {
+        if (value !== undefined) {
+            newObject[key] = value;
+        }
+    });
+    return newObject;
+}
+exports.cleanObject = cleanObject;
 class Collection {
     constructor(origin) {
         _Collection_locked.set(this, new Set());
@@ -182,3 +257,32 @@ _Collection_locked = new WeakMap(), _Collection_matched = new WeakMap(), _Collec
 class UnsupportedError extends Error {
 }
 exports.UnsupportedError = UnsupportedError;
+function modelLog(model, repeat) {
+    if (!isModel(model)) {
+        return orderLog(model, repeat);
+    }
+    if (typeof model === 'string') {
+        return `<${model}>${repeat}`;
+    }
+    return `(<${model.join('>|<')}>)${repeat}`;
+}
+exports.modelLog = modelLog;
+function orderLog(order, repeat) {
+    return order.length === 1
+        ? markRepeat(patternLog(order[0]), repeat)
+        : markRepeat(order.map(pattern => patternLog(pattern)).join(''), repeat);
+}
+function patternLog(pattern) {
+    if (isTransparent(pattern)) {
+        // 適当
+        return `:transparent(${modelLog(pattern.transparent, '')})`;
+    }
+    if (isChoice(pattern)) {
+        return `(${pattern.choice.map(candidate => orderLog(candidate, '')).join('|')})`;
+    }
+    const { model, repeat } = normalizeModel(pattern);
+    return modelLog(model, repeat);
+}
+function markRepeat(pattern, repeat) {
+    return repeat ? `(${pattern})${repeat}` : pattern;
+}

package/lib/placeholder-label-option/index.d.ts

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

package/lib/placeholder-label-option/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    verify({ document, report, t }) {
+        document.querySelectorAll('select').forEach(select => {
+            const required = select.getAttributeNode('required');
+            if (!required) {
+                return;
+            }
+            if (!hasPlaceholderLabelOption(select)) {
+                report({
+                    scope: required,
+                    message: t('{0} if it has {1}', t('need {0}', t('the {0}', 'placeholder label option')), t('the "{0*}" {1}', 'required', 'attribute')),
+                });
+            }
+        });
+    },
+});
+function hasPlaceholderLabelOption(select) {
+    var _a;
+    // has a required attribute specified
+    if (!select.hasAttribute('required')) {
+        return false;
+    }
+    // does not have a multiple attribute specified
+    if (select.hasAttribute('multiple')) {
+        return false;
+    }
+    // has a display size of 1
+    const size = select.getAttribute('size') || '1';
+    if (size !== '1') {
+        return false;
+    }
+    // in the select element's list of options (if any) is the empty string
+    const firstOption = select.querySelector('option');
+    if (!firstOption) {
+        // if any
+        return true;
+    }
+    // that option element's parent node is the select element (and not an optgroup element)
+    if (((_a = firstOption.parentElement) === null || _a === void 0 ? void 0 : _a.localName) === 'optgroup') {
+        return false;
+    }
+    const value = firstOption.getAttribute('value');
+    return value === '' || value === null;
+}

package/lib/require-datetime/index.d.ts

@@ -0,0 +1,6 @@
+import type { Lang } from './types';
+type Options = {
+    langs?: Lang[];
+};
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
+export default _default;

package/lib/require-datetime/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+const types_1 = require("@markuplint/types");
+const utils_1 = require("./utils");
+exports.default = (0, ml_core_1.createRule)({
+    defaultOptions: {
+        langs: undefined,
+    },
+    verify({ document, report, t }) {
+        document.querySelectorAll('time:not([datetime])').forEach(time => {
+            if (time.hasMutableChildren()) {
+                return;
+            }
+            const content = time.textContent.trim();
+            const result = (0, types_1.check)(content, 'DateTime');
+            if (result.matched) {
+                return;
+            }
+            const candidate = (0, utils_1.getCandidateDatetimeString)(content, time.rule.options.langs);
+            if (candidate) {
+                report({
+                    scope: time,
+                    message: t('need {0*}', `datetime="${candidate}"`),
+                });
+                return;
+            }
+            report({
+                scope: time,
+                message: t('need {0}', t('the "{0*}" {1}', 'datetime', 'attribute')),
+            });
+        });
+    },
+});

package/lib/require-datetime/types.d.ts

@@ -0,0 +1,10 @@
+export type DateTimeKey = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'ms';
+export type DateTimeData = Partial<Record<DateTimeKey, number>>;
+export type DateTime = {
+    datetime: DateTimeData;
+    zone?: number;
+};
+/**
+ * @see https://github.com/wanasit/chrono#locales
+ */
+export type Lang = 'en' | 'ja' | 'fr' | 'nl' | 'ru' | 'de' | 'pt' | 'zh';

package/lib/require-datetime/types.js

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

package/lib/require-datetime/utils.d.ts

@@ -0,0 +1,11 @@
+import type { DateTime, Lang } from './types';
+/**
+ * Datetime-ish text to a datetime data
+ *
+ * @param content
+ * @param langs
+ * @param base Reference date for a test
+ * @returns
+ */
+export declare function parseADatetime(content: string, langs: Lang[], base?: Date): DateTime | null;
+export declare function getCandidateDatetimeString(content: string, langs?: Lang[]): string | null;

package/lib/require-datetime/utils.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCandidateDatetimeString = exports.parseADatetime = void 0;
+const tslib_1 = require("tslib");
+const chrono = tslib_1.__importStar(require("chrono-node"));
+const defaultLangs = ['en', 'ja', 'fr', 'nl', 'ru', 'de', 'pt', 'zh'];
+/**
+ * Datetime-ish text to a datetime data
+ *
+ * @param content
+ * @param langs
+ * @param base Reference date for a test
+ * @returns
+ */
+function parseADatetime(content, langs, base) {
+    const date = parseTryMultipleLangs(content, langs, base);
+    if (!date) {
+        return null;
+    }
+    const data = {};
+    if (date.isCertain('year')) {
+        data.year = date.get('year');
+    }
+    if (date.isCertain('month')) {
+        data.month = date.get('month');
+    }
+    if (date.isCertain('day')) {
+        data.day = date.get('day');
+    }
+    if (date.isCertain('hour')) {
+        data.hour = date.get('hour');
+    }
+    if (date.isCertain('hour')) {
+        data.minute = date.get('minute') || 0;
+    }
+    if (date.isCertain('second')) {
+        data.second = date.get('second');
+    }
+    if (date.isCertain('millisecond')) {
+        data.ms = date.get('millisecond');
+    }
+    const datetime = {
+        datetime: data,
+    };
+    if (date.isCertain('timezoneOffset')) {
+        datetime.zone = date.get('timezoneOffset');
+    }
+    return datetime;
+}
+exports.parseADatetime = parseADatetime;
+function getCandidateDatetimeString(content, langs = defaultLangs) {
+    const date = parseADatetime(content, langs);
+    if (!date) {
+        return null;
+    }
+    let datetimeStr = toDatetimeString(date.datetime);
+    if (!datetimeStr) {
+        return null;
+    }
+    if (date.zone) {
+        const plusMinus = date.zone < 0 ? '-' : '+';
+        const hour = Math.floor(Math.abs(date.zone) / 60);
+        const minute = Math.abs(date.zone) % 60;
+        datetimeStr += `${plusMinus}${f(hour, 2)}${f(minute, 2)}`;
+    }
+    return datetimeStr;
+}
+exports.getCandidateDatetimeString = getCandidateDatetimeString;
+function toDatetimeString(date) {
+    if (only(date, ['year', 'month'])) {
+        return `${f(date.year, 4)}-${f(date.month, 2)}`;
+    }
+    if (only(date, ['year', 'month', 'day'])) {
+        return `${f(date.year, 4)}-${f(date.month, 2)}-${f(date.day, 2)}`;
+    }
+    if (only(date, ['month', 'day'])) {
+        return `${f(date.month, 2)}-${f(date.day, 2)}`;
+    }
+    if (only(date, ['hour', 'minute'])) {
+        return `${f(date.hour, 2)}:${f(date.minute, 2)}`;
+    }
+    if (only(date, ['hour', 'minute', 'second'])) {
+        return `${f(date.hour, 2)}:${f(date.minute, 2)}:${f(date.second, 2)}`;
+    }
+    if (only(date, ['hour', 'minute', 'second', 'ms'])) {
+        return `${f(date.hour, 2)}:${f(date.minute, 2)}:${f(date.second, 2)}.${date.ms}`;
+    }
+    if (only(date, ['year', 'month', 'day', 'hour', 'minute'])) {
+        return `${f(date.year, 4)}-${f(date.month, 2)}-${f(date.day, 2)}T${f(date.hour, 2)}:${f(date.minute, 2)}`;
+    }
+    if (only(date, ['year', 'month', 'day', 'hour', 'minute', 'second'])) {
+        return `${f(date.year, 4)}-${f(date.month, 2)}-${f(date.day, 2)}T${f(date.hour, 2)}:${f(date.minute, 2)}:${f(date.second, 2)}`;
+    }
+    if (only(date, ['year', 'month', 'day', 'hour', 'minute', 'second', 'ms'])) {
+        return `${f(date.year, 4)}-${f(date.month, 2)}-${f(date.day, 2)}T${f(date.hour, 2)}:${f(date.minute, 2)}:${f(date.second, 2)}.${date.ms}`;
+    }
+    return null;
+}
+function parseTryMultipleLangs(content, langs, base) {
+    for (const lang of langs) {
+        // eslint-disable-next-line import/namespace
+        const results = chrono[lang].casual.parse(content, base);
+        // Is not multiple datetime contents
+        if (results.length < 1) {
+            continue;
+        }
+        const result = results[0];
+        // Is not a range or period
+        if (result.end) {
+            continue;
+        }
+        return result.start;
+    }
+    return null;
+}
+function only(date, keys) {
+    const list = Object.keys(date);
+    for (const exists of list) {
+        if (!keys.includes(exists)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Formatter
+ *
+ * @param n
+ * @param pad zero padding
+ * @returns
+ */
+function f(n, pad) {
+    return n.toString(10).padStart(pad, '0');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "3.0.0",
+	"version": "3.1.0",
 	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -20,11 +20,12 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "3.0.0",
-		"@markuplint/ml-core": "3.0.0",
-		"@markuplint/ml-spec": "3.0.0",
+		"@markuplint/html-spec": "3.1.0",
+		"@markuplint/ml-core": "3.1.0",
+		"@markuplint/ml-spec": "3.1.0",
 		"@markuplint/types": "3.0.0",
 		"@ungap/structured-clone": "^1.0.1",
+		"chrono-node": "^2.5.0",
 		"debug": "^4.3.4",
 		"html-entities": "^2.3.3",
 		"tslib": "^2.4.1"
@@ -32,5 +33,5 @@
 	"devDependencies": {
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "51af6a64bb8da54376a138f19e3f15a2f759a967"
+	"gitHead": "0e75df6944f453bc19d2a6e05ad264788a8dc149"
 }

package/schema.json

@@ -78,6 +78,9 @@
 				"require-accessible-name": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-accessible-name/schema.json"
 				},
+				"require-datetime": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-datetime/schema.json"
+				},
 				"required-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/required-attr/schema.json"
 				},