@markuplint/rules 3.0.0-alpha.66 → 3.0.0-dev.176

package/lib/permitted-contents/utils.js

@@ -0,0 +1,302 @@
+"use strict";
+var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_origin;
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const represent_transparent_nodes_1 = require("./represent-transparent-nodes");
+const getChildNodesWithoutWhitespacesCaches = new Map();
+function getChildNodesWithoutWhitespaces(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    let nodes = getChildNodesWithoutWhitespacesCaches.get(el);
+    if (nodes) {
+        return nodes;
+    }
+    nodes = Array.from(el.childNodes).filter(node => {
+        return !(node.is(node.TEXT_NODE) && node.isWhitespace());
+    });
+    getChildNodesWithoutWhitespacesCaches.set(el, nodes);
+    return nodes;
+}
+exports.getChildNodesWithoutWhitespaces = getChildNodesWithoutWhitespaces;
+function isModel(model) {
+    if (typeof model === 'string') {
+        return true;
+    }
+    let modelMode = false;
+    for (const m of model) {
+        if (typeof m === 'string') {
+            modelMode = true;
+            continue;
+        }
+        if (modelMode) {
+            throw new TypeError(`Invalid schema: ${JSON.stringify(model)}`);
+        }
+    }
+    return modelMode;
+}
+exports.isModel = isModel;
+function matches(selector, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node, specs) {
+    const selectorResult = (0, selector_1.createSelector)(selector, specs).search(node);
+    const matched = selectorResult.filter((r) => r.matched);
+    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 : []); })
+        .flat()
+        .map(descendants)
+        .flat()
+        .shift();
+    return {
+        matched: false,
+        not,
+    };
+}
+exports.matches = matches;
+function descendants(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+selectorResult) {
+    let nodes = selectorResult.nodes.slice();
+    while (selectorResult.has.length > 0) {
+        for (const dep of selectorResult.has) {
+            if (dep.has.length === 0) {
+                nodes = dep.nodes;
+                continue;
+            }
+            selectorResult = dep;
+            continue;
+        }
+        break;
+    }
+    return nodes;
+}
+function isRequire(content) {
+    return 'require' in content;
+}
+exports.isRequire = isRequire;
+function isOptional(content) {
+    return 'optional' in content;
+}
+exports.isOptional = isOptional;
+function isOneOrMore(content) {
+    return 'oneOrMore' in content;
+}
+exports.isOneOrMore = isOneOrMore;
+function isZeroOrMore(content) {
+    return 'zeroOrMore' in content;
+}
+exports.isZeroOrMore = isZeroOrMore;
+function isChoice(content) {
+    return 'choice' in content;
+}
+exports.isChoice = isChoice;
+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(
+// 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) => { 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(
+    // 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");
+    }
+    get matched() {
+        return Array.from(tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f"));
+    }
+    get matchedCount() {
+        return tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+    }
+    get nodes() {
+        return tslib_1.__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));
+    }
+    addMatched(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    nodes) {
+        const i = tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+        for (const node of nodes) {
+            if (!tslib_1.__classPrivateFieldGet(this, _Collection_nodes, "f").has(node)) {
+                throw new ReferenceError(`External Node: ${node.nodeName}`);
+            }
+            tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").add(node);
+        }
+        return i < tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").size;
+    }
+    back() {
+        tslib_1.__classPrivateFieldSet(this, _Collection_matched, new Set(tslib_1.__classPrivateFieldGet(this, _Collection_locked, "f")), "f");
+    }
+    lock() {
+        tslib_1.__classPrivateFieldSet(this, _Collection_locked, new Set(tslib_1.__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));
+    }
+    toString(highlightExtraNodes = false) {
+        const out = [];
+        for (const n of tslib_1.__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));
+                }
+                else {
+                    out.push(debug_1.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));
+                }
+                else {
+                    out.push(debug_1.green.bold(raw));
+                }
+                continue;
+            }
+            if (highlightExtraNodes) {
+                if (represent_transparent_nodes_1.transparentMode.has(n)) {
+                    out.push(debug_1.bgMagenta.bold(raw));
+                }
+                else {
+                    out.push(debug_1.bgRed.bold(raw));
+                }
+                continue;
+            }
+            if (represent_transparent_nodes_1.transparentMode.has(n)) {
+                out.push((0, debug_1.cyan)(raw));
+            }
+            else {
+                out.push(raw);
+            }
+        }
+        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 {
+}
+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 && 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;
+}

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,88 @@
+"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 => {
+            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) {
+    var _a;
+    const hasRequired = select.hasAttribute('required');
+    if (!hasRequired) {
+        return false;
+    }
+    const hasMultiple = select.hasAttribute('multiple');
+    if (hasMultiple) {
+        return false;
+    }
+    const size = (_a = select.getAttribute('size')) !== null && _a !== void 0 ? _a : '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) {
+    var _a, _b;
+    // > 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 = (_a = select.getAttribute('size')) !== null && _a !== void 0 ? _a : '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 (((_b = firstOption.parentElement) === null || _b === void 0 ? void 0 : _b.localName) === 'optgroup') {
+        return false;
+    }
+    const value = firstOption.getAttribute('value');
+    return value === '' || value === null;
+}

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

@@ -1,6 +1,6 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
-declare type Option = {
-    ariaVersion: ARIAVersion;
+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,25 +1,33 @@
 "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)({
     defaultOptions: {
-        ariaVersion: '1.2',
+        ariaVersion: ml_spec_1.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') {
+                return;
+            }
             if ((0, helpers_1.accnameMayBeMutable)(el, document)) {
                 return;
             }
-            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.option.ariaVersion);
+            if (!(0, ml_spec_1.isExposed)(el, document.specs, el.rule.options.ariaVersion)) {
+                return;
+            }
+            const computed = (0, ml_core_1.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.option.ariaVersion);
+            const roleSpec = (0, ml_core_1.getRoleSpec)(document.specs, computed.role.name, el.namespaceURI, el.rule.options.ariaVersion);
             if (!roleSpec || !roleSpec.accessibleNameRequired) {
                 return;
             }
-            const hasAccessibleName = !!el.getAccessibleName().trim();
+            const hasAccessibleName = !!el.getAccessibleName(el.rule.options.ariaVersion).trim();
             if (!hasAccessibleName) {
                 report({ scope: el, message: t('Require {0}', 'accessible name') });
             }

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

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

package/lib/require-datetime/utils.js

@@ -0,0 +1,137 @@
+"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) {
+    var _a;
+    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 = (_a = date.get('minute')) !== null && _a !== void 0 ? _a : 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 != null) {
+        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) {
+        const results = chrono[lang].casual.parse(content, base);
+        // Is not multiple datetime contents
+        if (results.length < 1) {
+            continue;
+        }
+        const result = results[0];
+        if (!result) {
+            continue;
+        }
+        // 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/lib/required-attr/index.d.ts

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