@markuplint/rules 3.0.0-dev.24 → 3.0.0-dev.290

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

@@ -1,14 +1,15 @@
 import type { Element as _Element, ChildNode as _ChildNode } from '@markuplint/ml-core';
 import type { ContentModel, MLMLSpec } from '@markuplint/ml-spec';
+import type { ReadonlyDeep } from 'type-fest';
 export type Element = _Element<TagRule[], Options>;
 export type ChildNode = _ChildNode<TagRule[], Options>;
 export type Specs = {
-    cites: MLMLSpec['cites'];
-    def: MLMLSpec['def'];
-    specs: {
-        name: string;
-        contentModel: {
-            contents: MLMLSpec['specs'][0]['contentModel']['contents'];
+    readonly cites: MLMLSpec['cites'];
+    readonly def: MLMLSpec['def'];
+    readonly specs: readonly {
+        readonly name: string;
+        readonly contentModel: {
+            readonly contents: MLMLSpec['specs'][0]['contentModel']['contents'];
         };
     }[];
 };
@@ -24,22 +25,28 @@ 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;
 };
 export type TagRule = {
-    tag: string;
-} & ContentModel;
+    readonly tag: string;
+} & ReadonlyDeep<ContentModel>;
 export type Options = {
-    ignoreHasMutableChildren: boolean;
+    readonly ignoreHasMutableChildren: boolean;
 };

package/lib/permitted-contents/types.js

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

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

@@ -1,7 +1,8 @@
-import type { ChildNode, Element, Specs } from './types';
+import type { ChildNode, Element, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
 import type { PermittedContentPattern, PermittedContentChoice, PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentTransparent, PermittedContentZeroOrMore, Model } from '@markuplint/ml-spec';
+import type { ReadonlyDeep } from 'type-fest';
 export declare function getChildNodesWithoutWhitespaces(el: Element): ChildNode[];
-export declare function isModel(model: Model | PermittedContentPattern[]): model is Model;
+export declare function isModel(model: ReadonlyDeep<Model | PermittedContentPattern[]>): model is ReadonlyDeep<Model>;
 export declare function matches(selector: string, node: ChildNode, specs: Specs): {
     matched: boolean;
     not?: undefined;
@@ -9,12 +10,29 @@ export declare function matches(selector: string, node: ChildNode, specs: Specs)
     matched: boolean;
     not: ChildNode | undefined;
 };
-export declare function isRequire(content: PermittedContentPattern): content is PermittedContentRequire;
-export declare function isOptional(content: PermittedContentPattern): content is PermittedContentOptional;
-export declare function isOneOrMore(content: PermittedContentPattern): content is PermittedContentOneOrMore;
-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 isRequire(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentRequire>;
+export declare function isOptional(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentOptional>;
+export declare function isOneOrMore(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentOneOrMore>;
+export declare function isZeroOrMore(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentZeroOrMore>;
+export declare function isChoice(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentChoice>;
+export declare function isTransparent(content: ReadonlyDeep<PermittedContentPattern>): content is ReadonlyDeep<PermittedContentTransparent>;
+export declare function normalizeModel(pattern: ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentZeroOrMore>): {
+    model: ReadonlyDeep<PermittedContentPattern[] | Model>;
+    min: number;
+    max: number;
+    repeat: RepeatSign;
+    missingType: MissingNodeReason | undefined;
+};
+export declare function mergeHints(a: Readonly<Hints>, b: Readonly<Hints>): Partial<{
+    missing: Partial<{
+        barelyMatchedElements?: number | undefined;
+        need?: string | undefined;
+    }> | undefined;
+    max?: number | undefined;
+    not?: ChildNode | 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 +48,4 @@ export declare class Collection {
 }
 export declare class UnsupportedError extends Error {
 }
+export declare function modelLog(model: ReadonlyDeep<Model | PermittedContentPattern[]>, repeat: RepeatSign): string;

package/lib/permitted-contents/utils.js

@@ -1,13 +1,12 @@
-"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;
-const tslib_1 = require("tslib");
-const selector_1 = require("@markuplint/selector");
-const debug_1 = require("./debug");
-const represent_transparent_nodes_1 = require("./represent-transparent-nodes");
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { createSelector } from '@markuplint/selector';
+import { bgGreen, green, bgRed, bgBlue, blue, bgMagenta, cyan } from './debug.js';
+import { transparentMode } from './represent-transparent-nodes.js';
 const getChildNodesWithoutWhitespacesCaches = new Map();
-function getChildNodesWithoutWhitespaces(el) {
+export function getChildNodesWithoutWhitespaces(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
     let nodes = getChildNodesWithoutWhitespacesCaches.get(el);
     if (nodes) {
         return nodes;
@@ -18,8 +17,7 @@ function getChildNodesWithoutWhitespaces(el) {
     getChildNodesWithoutWhitespacesCaches.set(el, nodes);
     return nodes;
 }
-exports.getChildNodesWithoutWhitespaces = getChildNodesWithoutWhitespaces;
-function isModel(model) {
+export function isModel(model) {
     if (typeof model === 'string') {
         return true;
     }
@@ -35,17 +33,18 @@ function isModel(model) {
     }
     return modelMode;
 }
-exports.isModel = isModel;
-function matches(selector, node, specs) {
-    const selectorResult = (0, selector_1.createSelector)(selector, specs).search(node);
+export function matches(selector, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node, specs) {
+    const selectorResult = createSelector(selector, specs).search(node);
     const matched = selectorResult.filter((r) => r.matched);
-    if (matched.length) {
+    if (matched.length > 0) {
         return {
             matched: true,
         };
     }
     const not = selectorResult
-        .map(r => { var _a; return (r.matched ? [] : (_a = r.not) !== null && _a !== void 0 ? _a : []); })
+        .map(r => (r.matched ? [] : r.not ?? []))
         .flat()
         .map(descendants)
         .flat()
@@ -55,12 +54,13 @@ function matches(selector, node, specs) {
         not,
     };
 }
-exports.matches = matches;
-function descendants(selectorResult) {
+function descendants(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+selectorResult) {
     let nodes = selectorResult.nodes.slice();
-    while (selectorResult.has.length) {
+    while (selectorResult.has.length > 0) {
         for (const dep of selectorResult.has) {
-            if (!dep.has.length) {
+            if (dep.has.length === 0) {
                 nodes = dep.nodes;
                 continue;
             }
@@ -71,104 +71,177 @@ function descendants(selectorResult) {
     }
     return nodes;
 }
-function isRequire(content) {
+export function isRequire(content) {
     return 'require' in content;
 }
-exports.isRequire = isRequire;
-function isOptional(content) {
+export function isOptional(content) {
     return 'optional' in content;
 }
-exports.isOptional = isOptional;
-function isOneOrMore(content) {
+export function isOneOrMore(content) {
     return 'oneOrMore' in content;
 }
-exports.isOneOrMore = isOneOrMore;
-function isZeroOrMore(content) {
+export function isZeroOrMore(content) {
     return 'zeroOrMore' in content;
 }
-exports.isZeroOrMore = isZeroOrMore;
-function isChoice(content) {
+export function isChoice(content) {
     return 'choice' in content;
 }
-exports.isChoice = isChoice;
-function isTransparent(content) {
+export function isTransparent(content) {
     return 'transparent' in content;
 }
-exports.isTransparent = isTransparent;
-class Collection {
-    constructor(origin) {
+export function normalizeModel(pattern) {
+    let model;
+    let min;
+    let max;
+    let repeat;
+    let missingType;
+    if (isRequire(pattern)) {
+        model = pattern.require;
+        min = pattern.min ?? 1;
+        max = Math.max(pattern.max ?? 1, min);
+        missingType = 'MISSING_NODE_REQUIRED';
+    }
+    else if (isOptional(pattern)) {
+        model = pattern.optional;
+        min = 0;
+        max = Math.max(pattern.max ?? 1, 1);
+    }
+    else if (isOneOrMore(pattern)) {
+        model = pattern.oneOrMore;
+        min = 1;
+        max = Math.max(pattern.max ?? Infinity, 1);
+        missingType = 'MISSING_NODE_ONE_OR_MORE';
+    }
+    else if (isZeroOrMore(pattern)) {
+        model = pattern.zeroOrMore;
+        min = 0;
+        max = Math.max(pattern.max ?? 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,
+    };
+}
+export function mergeHints(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+a, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+b) {
+    const missing = [a.missing, b.missing].sort((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
+    return cleanObject({
+        ...a,
+        ...b,
+        missing: missing && cleanObject(missing),
+    });
+}
+export function cleanObject(object) {
+    const newObject = {};
+    Object.entries(object).forEach(([key, value]) => {
+        if (value !== undefined) {
+            newObject[key] = value;
+        }
+    });
+    return newObject;
+}
+export class Collection {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    origin) {
         _Collection_locked.set(this, new Set());
         _Collection_matched.set(this, new Set());
         _Collection_nodes.set(this, void 0);
         _Collection_origin.set(this, void 0);
-        tslib_1.__classPrivateFieldSet(this, _Collection_origin, origin.slice(), "f");
-        tslib_1.__classPrivateFieldSet(this, _Collection_nodes, new Set(tslib_1.__classPrivateFieldGet(this, _Collection_origin, "f")), "f");
+        __classPrivateFieldSet(this, _Collection_origin, origin.slice(), "f");
+        __classPrivateFieldSet(this, _Collection_nodes, new Set(__classPrivateFieldGet(this, _Collection_origin, "f")), "f");
     }
     get matched() {
-        return Array.from(tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f"));
+        return Array.from(__classPrivateFieldGet(this, _Collection_matched, "f"));
     }
     get matchedCount() {
-        return tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return __classPrivateFieldGet(this, _Collection_matched, "f").size;
     }
     get nodes() {
-        return tslib_1.__classPrivateFieldGet(this, _Collection_origin, "f").slice();
+        return __classPrivateFieldGet(this, _Collection_origin, "f").slice();
     }
     get unmatched() {
-        return Array.from(tslib_1.__classPrivateFieldGet(this, _Collection_nodes, "f")).filter(n => !tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").has(n));
+        return Array.from(__classPrivateFieldGet(this, _Collection_nodes, "f")).filter(n => !__classPrivateFieldGet(this, _Collection_matched, "f").has(n));
     }
-    addMatched(nodes) {
-        const i = tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+    addMatched(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    nodes) {
+        const i = __classPrivateFieldGet(this, _Collection_matched, "f").size;
         for (const node of nodes) {
-            if (!tslib_1.__classPrivateFieldGet(this, _Collection_nodes, "f").has(node)) {
+            if (!__classPrivateFieldGet(this, _Collection_nodes, "f").has(node)) {
                 throw new ReferenceError(`External Node: ${node.nodeName}`);
             }
-            tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").add(node);
+            __classPrivateFieldGet(this, _Collection_matched, "f").add(node);
         }
-        return i < tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return i < __classPrivateFieldGet(this, _Collection_matched, "f").size;
     }
     back() {
-        tslib_1.__classPrivateFieldSet(this, _Collection_matched, new Set(tslib_1.__classPrivateFieldGet(this, _Collection_locked, "f")), "f");
+        __classPrivateFieldSet(this, _Collection_matched, new Set(__classPrivateFieldGet(this, _Collection_locked, "f")), "f");
     }
     lock() {
-        tslib_1.__classPrivateFieldSet(this, _Collection_locked, new Set(tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f")), "f");
+        __classPrivateFieldSet(this, _Collection_locked, new Set(__classPrivateFieldGet(this, _Collection_matched, "f")), "f");
     }
     max(max) {
-        const sliced = Array.from(tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f")).slice(max);
-        sliced.forEach(n => tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").delete(n));
+        const sliced = Array.from(__classPrivateFieldGet(this, _Collection_matched, "f")).slice(max);
+        sliced.forEach(n => __classPrivateFieldGet(this, _Collection_matched, "f").delete(n));
     }
     toString(highlightExtraNodes = false) {
         const out = [];
-        for (const n of tslib_1.__classPrivateFieldGet(this, _Collection_origin, "f")) {
+        for (const n of __classPrivateFieldGet(this, _Collection_origin, "f")) {
             const raw = n.is(n.TEXT_NODE) ? `:text(${n.raw.replace(/\n/g, '\\n')})` : n.raw;
-            if (tslib_1.__classPrivateFieldGet(this, _Collection_locked, "f").has(n)) {
-                if (represent_transparent_nodes_1.transparentMode.has(n)) {
-                    out.push(debug_1.bgBlue.bold(raw));
+            if (__classPrivateFieldGet(this, _Collection_locked, "f").has(n)) {
+                if (transparentMode.has(n)) {
+                    out.push(bgBlue.bold(raw));
                 }
                 else {
-                    out.push(debug_1.bgGreen.bold(raw));
+                    out.push(bgGreen.bold(raw));
                 }
                 continue;
             }
-            if (tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").has(n)) {
-                if (represent_transparent_nodes_1.transparentMode.has(n)) {
-                    out.push(debug_1.blue.bold(raw));
+            if (__classPrivateFieldGet(this, _Collection_matched, "f").has(n)) {
+                if (transparentMode.has(n)) {
+                    out.push(blue.bold(raw));
                 }
                 else {
-                    out.push(debug_1.green.bold(raw));
+                    out.push(green.bold(raw));
                 }
                 continue;
             }
             if (highlightExtraNodes) {
-                if (represent_transparent_nodes_1.transparentMode.has(n)) {
-                    out.push(debug_1.bgMagenta.bold(raw));
+                if (transparentMode.has(n)) {
+                    out.push(bgMagenta.bold(raw));
                 }
                 else {
-                    out.push(debug_1.bgRed.bold(raw));
+                    out.push(bgRed.bold(raw));
                 }
                 continue;
             }
-            if (represent_transparent_nodes_1.transparentMode.has(n)) {
-                out.push((0, debug_1.cyan)(raw));
+            if (transparentMode.has(n)) {
+                out.push(cyan(raw));
             }
             else {
                 out.push(raw);
@@ -177,8 +250,34 @@ class Collection {
         return `[ ${out.join(', ')} ]`;
     }
 }
-exports.Collection = Collection;
 _Collection_locked = new WeakMap(), _Collection_matched = new WeakMap(), _Collection_nodes = new WeakMap(), _Collection_origin = new WeakMap();
-class UnsupportedError extends Error {
+export class UnsupportedError extends Error {
+}
+export function modelLog(model, repeat) {
+    if (!isModel(model)) {
+        return orderLog(model, repeat);
+    }
+    if (typeof model === 'string') {
+        return `<${model}>${repeat}`;
+    }
+    return `(<${model.join('>|<')}>)${repeat}`;
+}
+function orderLog(order, repeat) {
+    return order.length === 1 && order[0]
+        ? 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;
 }
-exports.UnsupportedError = UnsupportedError;

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

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

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

@@ -0,0 +1,84 @@
+import { createRule } from '@markuplint/ml-core';
+export default createRule({
+    verify({ document, report, t }) {
+        document.querySelectorAll('select').forEach(select => {
+            if (hasPlaceholderLabelOption(select)) {
+                return;
+            }
+            if (!needPlaceholderLabelOption(select)) {
+                return;
+            }
+            report({
+                scope: select,
+                message: t('need {0}', t('the {0}', 'placeholder label option')),
+            });
+        });
+    },
+});
+/**
+ * > If a select element has a required attribute specified,
+ * > does not have a multiple attribute specified,
+ * > and has a display size of 1,
+ * > then the select element must have a placeholder label option.
+ *
+ * @param select
+ * @returns
+ */
+function needPlaceholderLabelOption(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+select) {
+    const hasRequired = select.hasAttribute('required');
+    if (!hasRequired) {
+        return false;
+    }
+    const hasMultiple = select.hasAttribute('multiple');
+    if (hasMultiple) {
+        return false;
+    }
+    const size = select.getAttribute('size') ?? '1';
+    if (size !== '1') {
+        return false;
+    }
+    return true;
+}
+/**
+ * > If a select element has a required attribute specified,
+ * > does not have a multiple attribute specified,
+ * > and has a display size of 1;
+ * > and if the value of the first option element
+ * > in the select element's list of options (if any) is the empty string,
+ * > and that option element's parent node is the select element (and not an optgroup element),
+ * > then that option is the select element's **placeholder label option**.
+ *
+ * @param select
+ * @returns
+ */
+function hasPlaceholderLabelOption(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+select) {
+    // > 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 (firstOption.parentElement?.localName === 'optgroup') {
+        return false;
+    }
+    const value = firstOption.getAttribute('value');
+    return value === '' || value === null;
+}

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

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

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

@@ -1,29 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ml_core_1 = require("@markuplint/ml-core");
-const ml_spec_1 = require("@markuplint/ml-spec");
-const helpers_1 = require("../helpers");
-exports.default = (0, ml_core_1.createRule)({
+import { createRule, getRoleSpec, getComputedRole } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION, isExposed } from '@markuplint/ml-spec';
+import { accnameMayBeMutable } from '../helpers.js';
+export default createRule({
     defaultOptions: {
-        ariaVersion: '1.2',
+        ariaVersion: ARIA_RECOMMENDED_VERSION,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
-            var _a;
-            if (((_a = el.pretenderContext) === null || _a === void 0 ? void 0 : _a.type) === 'pretender') {
+            if (el.pretenderContext?.type === 'pretender') {
                 return;
             }
-            if ((0, helpers_1.accnameMayBeMutable)(el, document)) {
+            if (accnameMayBeMutable(el, document)) {
                 return;
             }
-            if (!(0, ml_spec_1.isExposed)(el, document.specs, el.rule.options.ariaVersion)) {
+            if (!isExposed(el, document.specs, el.rule.options.ariaVersion)) {
                 return;
             }
-            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.options.ariaVersion);
+            const computed = getComputedRole(document.specs, el, el.rule.options.ariaVersion);
             if (!computed.role) {
                 return;
             }
-            const roleSpec = (0, ml_core_1.getRoleSpec)(document.specs, computed.role.name, el.namespaceURI, el.rule.options.ariaVersion);
+            const roleSpec = getRoleSpec(document.specs, computed.role.name, el.namespaceURI, el.rule.options.ariaVersion);
             if (!roleSpec || !roleSpec.accessibleNameRequired) {
                 return;
             }

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

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

package/lib/require-datetime/index.js

@@ -0,0 +1,32 @@
+import { createRule } from '@markuplint/ml-core';
+import { check } from '@markuplint/types';
+import { getCandidateDatetimeString } from './utils.js';
+export default 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 = check(content, 'DateTime');
+            if (result.matched) {
+                return;
+            }
+            const candidate = 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 @@
+export {};

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

@@ -0,0 +1,11 @@
+import type { DateTime, Lang } from './types.js';
+/**
+ * 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: readonly Lang[], base?: Readonly<Date>): DateTime | null;
+export declare function getCandidateDatetimeString(content: string, langs?: Lang[]): string | null;