@markuplint/rules 3.15.0 → 4.0.0-alpha.10

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

@@ -4,49 +4,49 @@ import type { ReadonlyDeep } from 'type-fest';
 export type Element = _Element<TagRule[], Options>;
 export type ChildNode = _ChildNode<TagRule[], Options>;
 export type Specs = {
-	readonly cites: MLMLSpec['cites'];
-	readonly def: MLMLSpec['def'];
-	readonly specs: readonly {
-		readonly name: string;
-		readonly contentModel: {
-			readonly 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'];
+        };
+    }[];
 };
 export type ContentModelResult = {
-	type: MatchedReason | UnmatchedReason;
-	scope: ChildNode;
-	query: Result['query'];
-	hint: Result['hint'];
+    type: MatchedReason | UnmatchedReason;
+    scope: ChildNode;
+    query: Result['query'];
+    hint: Result['hint'];
 };
 export type Result<T extends string = MatchedReason> = {
-	type: MatchedReason | UnmatchedReason | T;
-	matched: ChildNode[];
-	unmatched: ChildNode[];
-	zeroMatch: boolean;
-	query: string;
-	hint: Hints;
+    type: MatchedReason | UnmatchedReason | T;
+    matched: ChildNode[];
+    unmatched: ChildNode[];
+    zeroMatch: boolean;
+    query: string;
+    hint: Hints;
 };
 export type Hints = {
-	max?: number;
-	not?: ChildNode;
-	transparent?: Element;
-	missing?: {
-		barelyMatchedElements?: number;
-		need?: string;
-	};
+    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;
+    el: Element;
+    additionalCondition: string;
 };
 export type TagRule = {
-	readonly tag: string;
+    readonly tag: string;
 } & ReadonlyDeep<ContentModel>;
 export type Options = {
-	readonly 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,88 +1,51 @@
-import type { ChildNode, Element, Hints, MissingNodeReason, RepeatSign, Specs } from './types';
-import type {
-	PermittedContentPattern,
-	PermittedContentChoice,
-	PermittedContentOneOrMore,
-	PermittedContentOptional,
-	PermittedContentRequire,
-	PermittedContentTransparent,
-	PermittedContentZeroOrMore,
-	Model,
-} from '@markuplint/ml-spec';
+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: ReadonlyDeep<Model | PermittedContentPattern[]>): model is ReadonlyDeep<Model>;
-export declare function matches(
-	selector: string,
-	node: ChildNode,
-	specs: Specs,
-):
-	| {
-			matched: boolean;
-			not?: undefined;
-	  }
-	| {
-			matched: boolean;
-			not: ChildNode | undefined;
-	  };
-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 matches(selector: string, node: ChildNode, specs: Specs): {
+    matched: boolean;
+    not?: undefined;
+} | {
+    matched: boolean;
+    not: ChildNode | 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 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[]);
-	get matched(): ChildNode[];
-	get matchedCount(): number;
-	get nodes(): ChildNode[];
-	get unmatched(): ChildNode[];
-	addMatched(nodes: ChildNode[]): boolean;
-	back(): void;
-	lock(): void;
-	max(max: number): void;
-	toString(highlightExtraNodes?: boolean): string;
+    #private;
+    constructor(origin: readonly ChildNode[]);
+    get matched(): ChildNode[];
+    get matchedCount(): number;
+    get nodes(): ChildNode[];
+    get unmatched(): ChildNode[];
+    addMatched(nodes: ChildNode[]): boolean;
+    back(): void;
+    lock(): void;
+    max(max: number): void;
+    toString(highlightExtraNodes?: boolean): string;
+}
+export declare class UnsupportedError extends Error {
 }
-export declare class UnsupportedError extends Error {}
 export declare function modelLog(model: ReadonlyDeep<Model | PermittedContentPattern[]>, repeat: RepeatSign): string;

package/lib/permitted-contents/utils.js

@@ -1,27 +1,33 @@
-"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 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");
+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(
+export 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 => {
+    nodes = [...el.childNodes].filter(node => {
         return !(node.is(node.TEXT_NODE) && node.isWhitespace());
     });
     getChildNodesWithoutWhitespacesCaches.set(el, nodes);
     return nodes;
 }
-exports.getChildNodesWithoutWhitespaces = getChildNodesWithoutWhitespaces;
-function isModel(model) {
+export function isModel(model) {
     if (typeof model === 'string') {
         return true;
     }
@@ -37,11 +43,10 @@ function isModel(model) {
     }
     return modelMode;
 }
-exports.isModel = isModel;
-function matches(selector, 
+export 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 selectorResult = createSelector(selector, specs).search(node);
     const matched = selectorResult.filter((r) => r.matched);
     if (matched.length > 0) {
         return {
@@ -49,21 +54,18 @@ node, specs) {
         };
     }
     const not = selectorResult
-        .map(r => { var _a; return (r.matched ? [] : (_a = r.not) !== null && _a !== void 0 ? _a : []); })
-        .flat()
-        .map(descendants)
-        .flat()
+        .flatMap(r => (r.matched ? [] : r.not ?? []))
+        .flatMap(descendants)
         .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();
+    let nodes = [...selectorResult.nodes];
     while (selectorResult.has.length > 0) {
         for (const dep of selectorResult.has) {
             if (dep.has.length === 0) {
@@ -77,32 +79,25 @@ 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;
-function normalizeModel(pattern) {
-    var _a, _b, _c, _d, _e;
+export function normalizeModel(pattern) {
     let model;
     let min;
     let max;
@@ -110,25 +105,25 @@ function normalizeModel(pattern) {
     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);
+        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((_c = pattern.max) !== null && _c !== void 0 ? _c : 1, 1);
+        max = Math.max(pattern.max ?? 1, 1);
     }
     else if (isOneOrMore(pattern)) {
         model = pattern.oneOrMore;
         min = 1;
-        max = Math.max((_d = pattern.max) !== null && _d !== void 0 ? _d : Infinity, 1);
+        max = Math.max(pattern.max ?? Number.POSITIVE_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);
+        max = Math.max(pattern.max ?? Number.POSITIVE_INFINITY, 1);
     }
     else {
         throw new Error('Unreachable code');
@@ -156,31 +151,28 @@ function normalizeModel(pattern) {
         missingType,
     };
 }
-exports.normalizeModel = normalizeModel;
-function mergeHints(
+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) => { 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];
+    const missing = [a.missing, b.missing].sort((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
     return cleanObject({
         ...a,
         ...b,
         missing: missing && cleanObject(missing),
     });
 }
-exports.mergeHints = mergeHints;
-function cleanObject(object) {
+export function cleanObject(object) {
     const newObject = {};
-    Object.entries(object).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(object)) {
         if (value !== undefined) {
             newObject[key] = value;
         }
-    });
+    }
     return newObject;
 }
-exports.cleanObject = cleanObject;
-class Collection {
+export class Collection {
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     origin) {
@@ -188,76 +180,77 @@ class Collection {
         _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], "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 [...__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")];
     }
     get unmatched() {
-        return Array.from(tslib_1.__classPrivateFieldGet(this, _Collection_nodes, "f")).filter(n => !tslib_1.__classPrivateFieldGet(this, _Collection_matched, "f").has(n));
+        return [...__classPrivateFieldGet(this, _Collection_nodes, "f")].filter(n => !__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;
+        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 = [...__classPrivateFieldGet(this, _Collection_matched, "f")].slice(max);
+        for (const n of sliced)
+            __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));
+        for (const n of __classPrivateFieldGet(this, _Collection_origin, "f")) {
+            const raw = n.is(n.TEXT_NODE) ? `:text(${n.raw.replaceAll('\n', '\\n')})` : n.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);
@@ -266,12 +259,10 @@ 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 {
 }
-exports.UnsupportedError = UnsupportedError;
-function modelLog(model, repeat) {
+export function modelLog(model, repeat) {
     if (!isModel(model)) {
         return orderLog(model, repeat);
     }
@@ -280,7 +271,6 @@ function modelLog(model, repeat) {
     }
     return `(<${model.join('>|<')}>)${repeat}`;
 }
-exports.modelLog = modelLog;
 function orderLog(order, repeat) {
     return order.length === 1 && order[0]
         ? markRepeat(patternLog(order[0]), repeat)

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

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

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

@@ -1,20 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ml_core_1 = require("@markuplint/ml-core");
-exports.default = (0, ml_core_1.createRule)({
+import { createRule } from '@markuplint/ml-core';
+export default createRule({
+    meta: {
+        category: 'validation',
+    },
     verify({ document, report, t }) {
-        document.querySelectorAll('select').forEach(select => {
+        for (const select of document.querySelectorAll('select')) {
             if (hasPlaceholderLabelOption(select)) {
-                return;
+                continue;
             }
             if (!needPlaceholderLabelOption(select)) {
-                return;
+                continue;
             }
             report({
                 scope: select,
                 message: t('need {0}', t('the {0}', 'placeholder label option')),
             });
-        });
+        }
     },
 });
 /**
@@ -29,7 +30,6 @@ exports.default = (0, ml_core_1.createRule)({
 function needPlaceholderLabelOption(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 select) {
-    var _a;
     const hasRequired = select.hasAttribute('required');
     if (!hasRequired) {
         return false;
@@ -38,7 +38,7 @@ select) {
     if (hasMultiple) {
         return false;
     }
-    const size = (_a = select.getAttribute('size')) !== null && _a !== void 0 ? _a : '1';
+    const size = select.getAttribute('size') ?? '1';
     if (size !== '1') {
         return false;
     }
@@ -59,7 +59,6 @@ select) {
 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;
@@ -69,7 +68,7 @@ select) {
         return false;
     }
     // > has a display size of 1
-    const size = (_a = select.getAttribute('size')) !== null && _a !== void 0 ? _a : '1';
+    const size = select.getAttribute('size') ?? '1';
     if (size !== '1') {
         return false;
     }
@@ -80,7 +79,7 @@ select) {
         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') {
+    if (firstOption.parentElement?.localName === 'optgroup') {
         return false;
     }
     const value = firstOption.getAttribute('value');

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

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