@markuplint/rules 5.0.0-alpha.2 → 5.0.0-dev.5

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-alpha.3](https://github.com/markuplint/markuplint/compare/v5.0.0-alpha.2...v5.0.0-alpha.3) (2026-02-26)
+
+### Bug Fixes
+
+- **rules:** remove redundant untranslated message from non-existent-role ([6c002bb](https://github.com/markuplint/markuplint/commit/6c002bb03d44c9a5561c4a40840820e1ada31025))
+
+### Features
+
+- **rules:** add attr-order rule for attribute sorting ([993c0a5](https://github.com/markuplint/markuplint/commit/993c0a53823206dfa24ba699bffc27e25b11ab00))
+- **rules:** add fix callbacks to 6 rules and extract shared helpers ([a3bf3c6](https://github.com/markuplint/markuplint/commit/a3bf3c69c028917548c2cc762e1562e8d99dbd9b))
+- **rules:** add fixable flag to rule metadata ([10e3f26](https://github.com/markuplint/markuplint/commit/10e3f266a3431a0cae9eb402f02f00031421ac7b))
+- **rules:** add head-element-order rule for head element sorting ([4f72f35](https://github.com/markuplint/markuplint/commit/4f72f350fe2fceafbb811e3538e771834fb87854))
+- **rules:** support event name array for no-use-event-handler-attr ([5e854b2](https://github.com/markuplint/markuplint/commit/5e854b2198aff43b83fd5b8a8f93f840c50536ea))
+
 # [5.0.0-alpha.2](https://github.com/markuplint/markuplint/compare/v5.0.0-alpha.1...v5.0.0-alpha.2) (2026-02-23)
 
 ### Features

package/lib/attr-duplication/index.js

@@ -1,4 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
+import { removeAttr } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Rule that checks for duplicate attributes on the same element.
@@ -29,6 +30,7 @@ export default createRule({
                             raw: scope.raw,
                         },
                         message,
+                        fix: fixer => removeAttr(fixer, attr),
                     });
                 }
                 else {

package/lib/attr-duplication/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `attr-duplication`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
+    readonly fixable: true;
 };
 export default _default;

package/lib/attr-duplication/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `attr-duplication`: categorized as a validation rule. */
 export default {
     category: 'validation',
+    fixable: true,
 };

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

@@ -0,0 +1,14 @@
+type PredefinedGroup = 'global' | 'event' | 'aria' | 'data' | 'spread';
+type SortOrder = 'alphabetical' | 'source-order' | string[];
+type OrderEntry = string | {
+    name?: string;
+    pattern?: string;
+    group?: PredefinedGroup;
+    order?: SortOrder;
+};
+type Value = OrderEntry[];
+type Options = {
+    alphabetical?: boolean;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<Value, Options>>;
+export default _default;

package/lib/attr-order/index.js

@@ -0,0 +1,292 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+function compareStrings(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function buildAttrContent(attr) {
+    const parts = [
+        attr.nameNode,
+        attr.spacesBeforeEqual,
+        attr.equal,
+        attr.spacesAfterEqual,
+        attr.startQuote,
+        attr.valueNode,
+        attr.endQuote,
+    ];
+    return parts.map(p => p?.raw ?? '').join('');
+}
+function getAttrRange(attrs) {
+    if (attrs.length === 0) {
+        return null;
+    }
+    const first = attrs[0];
+    const last = attrs.at(-1);
+    const firstToken = first.tokens.spacesBeforeName ?? first.tokens.nameNode;
+    const lastAttr = last.tokens;
+    const lastTokens = [
+        lastAttr.endQuote,
+        lastAttr.valueNode,
+        lastAttr.startQuote,
+        lastAttr.spacesAfterEqual,
+        lastAttr.equal,
+        lastAttr.spacesBeforeEqual,
+        lastAttr.nameNode,
+        lastAttr.spacesBeforeName,
+    ];
+    const lastToken = lastTokens.find(t => t != null && t.raw.length > 0);
+    if (!firstToken || !lastToken) {
+        return null;
+    }
+    return [firstToken.startOffset, lastToken.startOffset + lastToken.raw.length];
+}
+function compileEntries(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+entries, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+globalAttrs, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+eventAttrs) {
+    return entries.map((entry, entryIndex) => {
+        if (typeof entry === 'string') {
+            return {
+                entryIndex,
+                order: 'alphabetical',
+                match: (name) => name === entry,
+            };
+        }
+        const order = entry.order ?? 'alphabetical';
+        if (entry.name != null) {
+            return {
+                entryIndex,
+                order,
+                match: (name) => name === entry.name,
+            };
+        }
+        if (entry.pattern != null) {
+            let re;
+            try {
+                re = new RegExp(entry.pattern);
+            }
+            catch {
+                // Invalid regex pattern — skip this entry
+                return {
+                    entryIndex,
+                    order,
+                    match: () => false,
+                };
+            }
+            return {
+                entryIndex,
+                order,
+                match: (name) => re.test(name),
+            };
+        }
+        if (entry.group != null) {
+            const group = entry.group;
+            const groupOrder = group === 'spread' && entry.order == null ? 'source-order' : order;
+            switch (group) {
+                case 'global': {
+                    return {
+                        entryIndex,
+                        order: groupOrder,
+                        match: (name) => globalAttrs.has(name),
+                    };
+                }
+                case 'event': {
+                    return {
+                        entryIndex,
+                        order: groupOrder,
+                        match: (name) => eventAttrs.has(name),
+                    };
+                }
+                case 'aria': {
+                    return {
+                        entryIndex,
+                        order: groupOrder,
+                        match: (name) => /^aria-.+$/.test(name),
+                    };
+                }
+                case 'data': {
+                    return {
+                        entryIndex,
+                        order: groupOrder,
+                        match: (name) => /^data-.+$/.test(name),
+                    };
+                }
+                case 'spread': {
+                    return {
+                        entryIndex,
+                        order: groupOrder,
+                        match: (_name, isSpread) => isSpread,
+                    };
+                }
+            }
+        }
+        return {
+            entryIndex,
+            order,
+            match: () => false,
+        };
+    });
+}
+function matchEntry(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+compiledEntries, name, isSpread, fallbackIndex) {
+    for (const entry of compiledEntries) {
+        if (entry.match(name, isSpread)) {
+            return { entryIndex: entry.entryIndex, order: entry.order };
+        }
+    }
+    return { entryIndex: fallbackIndex, order: 'alphabetical' };
+}
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+function compareWithinGroup(a, b, order) {
+    if (order === 'alphabetical') {
+        return compareStrings(a.name, b.name);
+    }
+    if (order === 'source-order') {
+        return a.index - b.index;
+    }
+    if (Array.isArray(order)) {
+        const ai = order.indexOf(a.name);
+        const bi = order.indexOf(b.name);
+        const aIdx = ai === -1 ? order.length : ai;
+        const bIdx = bi === -1 ? order.length : bi;
+        if (aIdx !== bIdx) {
+            return aIdx - bIdx;
+        }
+        if (ai === -1 && bi === -1) {
+            return compareStrings(a.name, b.name);
+        }
+        return 0;
+    }
+    return 0;
+}
+function sortAttrs(attrInfos, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+compiledEntries, alphabetical) {
+    const fallbackIndex = compiledEntries.length;
+    const tagged = attrInfos.map(info => {
+        const { entryIndex, order } = matchEntry(compiledEntries, info.name, info.isSpread, fallbackIndex);
+        return { info, entryIndex, order };
+    });
+    return tagged
+        .toSorted((a, b) => {
+        if (a.entryIndex !== b.entryIndex) {
+            return a.entryIndex - b.entryIndex;
+        }
+        const isFallback = a.entryIndex === fallbackIndex;
+        if (isFallback) {
+            return alphabetical ? compareStrings(a.info.name, b.info.name) : a.info.index - b.info.index;
+        }
+        return compareWithinGroup(a.info, b.info, a.order);
+    })
+        .map(t => t.info);
+}
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultValue: [],
+    defaultOptions: {
+        alphabetical: true,
+    },
+    async verify({ document, report, t }) {
+        const globalAttrs = new Set();
+        const eventAttrs = new Set();
+        const defs = document.specs.def?.['#globalAttrs'];
+        if (defs != null) {
+            const htmlGlobal = defs['#HTMLGlobalAttrs'];
+            if (htmlGlobal) {
+                for (const name of Object.keys(htmlGlobal)) {
+                    globalAttrs.add(name);
+                }
+            }
+            const eventGlobal = defs['#GlobalEventAttrs'];
+            if (eventGlobal) {
+                for (const name of Object.keys(eventGlobal)) {
+                    eventAttrs.add(name);
+                }
+            }
+        }
+        let cachedValue;
+        let cachedCompiled;
+        await document.walkOn('Element', node => {
+            const attrs = node.getAttributeTokens();
+            if (attrs.length <= 1) {
+                return;
+            }
+            const value = node.rule.value;
+            const options = node.rule.options;
+            const alphabetical = options.alphabetical ?? true;
+            const ms = node.rule.severity === 'error' ? 'must' : 'should';
+            const entries = value.length > 0 ? value : [];
+            const isAlphabeticalOnly = entries.length === 0;
+            let compiledEntries;
+            if (cachedValue === value) {
+                compiledEntries = cachedCompiled;
+            }
+            else {
+                compiledEntries = compileEntries(entries, globalAttrs, eventAttrs);
+                cachedValue = value;
+                cachedCompiled = compiledEntries;
+            }
+            const attrInfos = attrs.map((attr, i) => {
+                const nameNode = attr.nameNode;
+                return {
+                    name: attr.name,
+                    index: i,
+                    isSpread: nameNode == null,
+                    spacing: attr.spacesBeforeName?.raw ?? '',
+                    content: buildAttrContent(attr),
+                    tokens: attr,
+                    scopeNode: nameNode ?? attr.spacesBeforeName,
+                };
+            });
+            const sorted = isAlphabeticalOnly
+                ? alphabetical
+                    ? [...attrInfos].toSorted((a, b) => compareStrings(a.name, b.name))
+                    : attrInfos
+                : sortAttrs(attrInfos, compiledEntries, alphabetical);
+            // Find first violation
+            for (let i = 0; i < attrInfos.length; i++) {
+                if (attrInfos[i] !== sorted[i]) {
+                    const actual = attrInfos[i];
+                    const expected = sorted[i];
+                    const scope = expected.scopeNode;
+                    if (!scope) {
+                        continue;
+                    }
+                    report({
+                        scope: {
+                            rule: node.rule,
+                            startLine: scope.startLine,
+                            startCol: scope.startCol,
+                            raw: scope.raw,
+                        },
+                        message: t(`{0} ${ms} be before {1}`, `"${expected.name || '(spread)'}"`, `"${actual.name || '(spread)'}"`),
+                        fix: fixer => {
+                            const range = getAttrRange(attrInfos);
+                            if (!range) {
+                                return [];
+                            }
+                            const newText = sorted
+                                .map((info, j) => {
+                                const spacing = attrInfos[j].spacing;
+                                return spacing + info.content;
+                            })
+                                .join('');
+                            return fixer.replaceRange(range, newText);
+                        },
+                    });
+                    break;
+                }
+            }
+        });
+    },
+});

package/lib/attr-order/meta.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    readonly category: "style";
+    readonly fixable: true;
+};
+export default _default;

package/lib/attr-order/meta.js

@@ -0,0 +1,4 @@
+export default {
+    category: 'style',
+    fixable: true,
+};

package/lib/attr-value-quotes/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `attr-value-quotes`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

package/lib/attr-value-quotes/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `attr-value-quotes`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

package/lib/case-sensitive-attr-name/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `case-sensitive-attr-name`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

package/lib/case-sensitive-attr-name/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `case-sensitive-attr-name`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

package/lib/case-sensitive-tag-name/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `case-sensitive-tag-name`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

package/lib/case-sensitive-tag-name/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `case-sensitive-tag-name`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

package/lib/head-element-order/index.d.ts

@@ -0,0 +1,8 @@
+type OrderEntry = {
+    readonly selector: string;
+    readonly order?: 'source-order' | 'alphabetical';
+    readonly attr?: string;
+};
+export type Value = readonly (string | OrderEntry)[];
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<Value, undefined>>;
+export default _default;

package/lib/head-element-order/index.js

@@ -0,0 +1,147 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+const DEFAULT_VALUE = [
+    'meta[charset]',
+    'meta[http-equiv]',
+    'meta[name="viewport"]',
+    'title',
+    { selector: 'meta', order: 'alphabetical', attr: 'name' },
+    'link',
+    'style',
+    'script',
+];
+function normalizeEntries(value) {
+    return value.map(entry => {
+        if (typeof entry === 'string') {
+            return { selector: entry, order: 'source-order' };
+        }
+        return { selector: entry.selector, order: entry.order ?? 'source-order', attr: entry.attr };
+    });
+}
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultValue: DEFAULT_VALUE,
+    verify({ document, report, t }) {
+        const head = document.querySelector('head');
+        if (!head) {
+            return;
+        }
+        const children = [...head.children];
+        if (children.length <= 1) {
+            return;
+        }
+        const value = head.rule.value ?? DEFAULT_VALUE;
+        const entries = normalizeEntries(value);
+        // Use entries.length as the unmatched group index instead of Infinity
+        // to avoid potential Infinity arithmetic issues (e.g. Infinity - Infinity = NaN).
+        const unmatchedGroupIndex = entries.length;
+        // Use offset-based text extraction instead of AST traversal because
+        // raw text elements (script, style) have empty childNodes in the AST.
+        const docString = document.toString();
+        const blocks = children.map((el, sourceIndex) => {
+            let groupIndex = unmatchedGroupIndex;
+            for (const [i, entry_] of entries.entries()) {
+                if (el.matches(entry_.selector)) {
+                    groupIndex = i;
+                    break;
+                }
+            }
+            const entry = groupIndex < entries.length ? entries[groupIndex] : undefined;
+            let subKey;
+            if (entry && entry.order === 'alphabetical' && entry.attr) {
+                subKey = el.getAttribute(entry.attr) ?? '';
+            }
+            else {
+                subKey = sourceIndex;
+            }
+            const endOffset = getElementEndOffset(el);
+            const elementText = docString.slice(el.startOffset, endOffset);
+            return {
+                startOffset: el.startOffset,
+                groupIndex,
+                subKey,
+                sourceIndex,
+                elementText,
+                localName: el.localName,
+            };
+        });
+        const sorted = blocks.toSorted((a, b) => {
+            if (a.groupIndex !== b.groupIndex) {
+                return a.groupIndex - b.groupIndex;
+            }
+            if (typeof a.subKey === 'string' && typeof b.subKey === 'string') {
+                // Use simple comparison operators instead of localeCompare to ensure
+                // consistent ordering across different environments and locales.
+                if (a.subKey < b.subKey) {
+                    return -1;
+                }
+                if (a.subKey > b.subKey) {
+                    return 1;
+                }
+            }
+            return a.sourceIndex - b.sourceIndex;
+        });
+        // Only the first violation carries a fix because it replaces
+        // the entire <head> content at once to reorder all elements.
+        const ms = head.rule.severity === 'error' ? 'must' : 'should';
+        let firstViolation = true;
+        for (let i = 0; i < blocks.length; i++) {
+            if (blocks[i].sourceIndex !== sorted[i].sourceIndex) {
+                const currentEl = children[i];
+                const expectedInfo = sorted[i];
+                const currentInfo = blocks[i];
+                report({
+                    scope: currentEl,
+                    message: t(`{0} ${ms} be before {1}`, t('the "{0*}" {1}', expectedInfo.localName, 'element'), t('the "{0*}" {1}', currentInfo.localName, 'element')),
+                    fix: firstViolation
+                        ? fixer => {
+                            const headOpenEnd = head.startOffset + head.raw.length;
+                            const lastChild = children.at(-1);
+                            const headCloseStart = head.closeTag
+                                ? head.closeTag.startOffset
+                                : getElementEndOffset(lastChild);
+                            const originalContent = docString.slice(headOpenEnd, headCloseStart);
+                            const newContent = buildFixedContent(originalContent, headOpenEnd, blocks, sorted);
+                            return fixer.replaceRange([headOpenEnd, headCloseStart], newContent);
+                        }
+                        : undefined,
+                });
+                firstViolation = false;
+            }
+        }
+    },
+});
+function getElementEndOffset(el) {
+    if (el.closeTag) {
+        return el.closeTag.startOffset + el.closeTag.raw.length;
+    }
+    return el.startOffset + el.raw.length;
+}
+function buildFixedContent(originalContent, headOpenEnd, blocks, sorted) {
+    const prefixes = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const elStart = block.startOffset - headOpenEnd;
+        let prefixStart;
+        if (i === 0) {
+            prefixStart = 0;
+        }
+        else {
+            const prevBlock = blocks[i - 1];
+            const prevEnd = prevBlock.startOffset - headOpenEnd + prevBlock.elementText.length;
+            prefixStart = prevEnd;
+        }
+        prefixes.push(originalContent.slice(prefixStart, elStart));
+    }
+    const lastBlock = blocks.at(-1);
+    const trailStart = lastBlock.startOffset - headOpenEnd + lastBlock.elementText.length;
+    const trailing = originalContent.slice(trailStart);
+    let result = '';
+    for (const [i, element] of sorted.entries()) {
+        result += prefixes[i];
+        result += element.elementText;
+    }
+    result += trailing;
+    return result;
+}

package/lib/head-element-order/meta.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    readonly category: "style";
+    readonly fixable: true;
+};
+export default _default;

package/lib/head-element-order/meta.js

@@ -0,0 +1,4 @@
+export default {
+    category: 'style',
+    fixable: true,
+};

package/lib/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { Log } from './debug.js';
 import type { Translator } from '@markuplint/i18n';
-import type { PlainData } from '@markuplint/ml-config';
+import type { FixToken, IRuleFixer, PlainData, TextEdit } from '@markuplint/ml-config';
 import type { Element, RuleConfigValue, Document } from '@markuplint/ml-core';
 import type { Attribute } from '@markuplint/ml-spec';
 import type { WritableDeep } from 'type-fest';
@@ -155,3 +155,38 @@ export declare class Collection<T> {
  * @returns A mutable deep clone of the input value
  */
 export declare function deepCopy<T>(value: T): WritableDeep<T>;
+/**
+ * Creates a fix that removes an entire attribute (name + value + surrounding whitespace).
+ * Used by rules that need to remove a whole attribute from an element.
+ *
+ * @param fixer - The rule fixer instance for building TextEdits
+ * @param attr - The attribute token parts to remove (from `spacesBeforeName` through `endQuote`)
+ * @returns A TextEdit (or empty array if no valid tokens exist) that removes the attribute
+ */
+export declare function removeAttr(fixer: IRuleFixer, attr: {
+    readonly spacesBeforeName: FixToken | null;
+    readonly nameNode: FixToken | null;
+    readonly spacesBeforeEqual: FixToken | null;
+    readonly equal: FixToken | null;
+    readonly spacesAfterEqual: FixToken | null;
+    readonly startQuote: FixToken | null;
+    readonly valueNode: FixToken | null;
+    readonly endQuote: FixToken | null;
+}): TextEdit | TextEdit[];
+/**
+ * Creates a fix that removes only the value portion of an attribute
+ * (equals sign, quotes, and value), keeping the attribute name.
+ * Used by `no-boolean-attr-value` to convert `disabled="disabled"` to `disabled`.
+ *
+ * @param fixer - The rule fixer instance for building TextEdits
+ * @param attr - The attribute token parts to remove (from `spacesBeforeEqual` through `endQuote`)
+ * @returns A TextEdit (or empty array if no valid tokens exist) that removes the value portion
+ */
+export declare function removeAttrValue(fixer: IRuleFixer, attr: {
+    readonly spacesBeforeEqual: FixToken | null;
+    readonly equal: FixToken | null;
+    readonly spacesAfterEqual: FixToken | null;
+    readonly startQuote: FixToken | null;
+    readonly valueNode: FixToken | null;
+    readonly endQuote: FixToken | null;
+}): TextEdit | TextEdit[];

package/lib/helpers.js

@@ -263,3 +263,71 @@ export class Collection {
 export function deepCopy(value) {
     return structuredClone(value);
 }
+/**
+ * Computes a removal range from a list of nullable tokens.
+ * Filters out null/undefined tokens and tokens with empty `raw`,
+ * then returns the range spanning from the first to the last token.
+ *
+ * @param tokens - An array of nullable tokens to compute the range from
+ * @returns `[start, end]` tuple, or `null` if no valid tokens
+ */
+function tokenRange(tokens) {
+    const valid = tokens.filter((t) => t != null && t.raw.length > 0);
+    const first = valid[0];
+    const last = valid.at(-1);
+    if (!first || !last) {
+        return null;
+    }
+    return [first.startOffset, last.startOffset + last.raw.length];
+}
+/**
+ * Creates a fix that removes an entire attribute (name + value + surrounding whitespace).
+ * Used by rules that need to remove a whole attribute from an element.
+ *
+ * @param fixer - The rule fixer instance for building TextEdits
+ * @param attr - The attribute token parts to remove (from `spacesBeforeName` through `endQuote`)
+ * @returns A TextEdit (or empty array if no valid tokens exist) that removes the attribute
+ */
+export function removeAttr(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+fixer, attr) {
+    const range = tokenRange([
+        attr.spacesBeforeName,
+        attr.nameNode,
+        attr.spacesBeforeEqual,
+        attr.equal,
+        attr.spacesAfterEqual,
+        attr.startQuote,
+        attr.valueNode,
+        attr.endQuote,
+    ]);
+    if (!range) {
+        return [];
+    }
+    return fixer.removeRange(range);
+}
+/**
+ * Creates a fix that removes only the value portion of an attribute
+ * (equals sign, quotes, and value), keeping the attribute name.
+ * Used by `no-boolean-attr-value` to convert `disabled="disabled"` to `disabled`.
+ *
+ * @param fixer - The rule fixer instance for building TextEdits
+ * @param attr - The attribute token parts to remove (from `spacesBeforeEqual` through `endQuote`)
+ * @returns A TextEdit (or empty array if no valid tokens exist) that removes the value portion
+ */
+export function removeAttrValue(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+fixer, attr) {
+    const range = tokenRange([
+        attr.spacesBeforeEqual,
+        attr.equal,
+        attr.spacesAfterEqual,
+        attr.startQuote,
+        attr.valueNode,
+        attr.endQuote,
+    ]);
+    if (!range) {
+        return [];
+    }
+    return fixer.removeRange(range);
+}

package/lib/index.d.ts

@@ -12,6 +12,14 @@
  */
 declare const rules: {
     readonly 'attr-duplication': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+    readonly 'attr-order': Readonly<import("@markuplint/ml-core").RuleSeed<(string | {
+        name?: string;
+        pattern?: string;
+        group?: "global" | "event" | "aria" | "data" | "spread";
+        order?: "alphabetical" | string[] | "source-order";
+    })[], {
+        alphabetical?: boolean;
+    }>>;
     readonly 'attr-value-quotes': Readonly<import("@markuplint/ml-core").RuleSeed<import("./attr-value-quotes/index.js").Type, undefined>>;
     readonly 'case-sensitive-attr-name': Readonly<import("@markuplint/ml-core").RuleSeed<import("./case-sensitive-attr-name/index.js").Value, undefined>>;
     readonly 'case-sensitive-tag-name': Readonly<import("@markuplint/ml-core").RuleSeed<import("./case-sensitive-tag-name/index.js").Value, undefined>>;
@@ -27,6 +35,7 @@ declare const rules: {
         denyObsoleteType: boolean;
     }>>;
     readonly 'end-tag': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+    readonly 'head-element-order': Readonly<import("@markuplint/ml-core").RuleSeed<import("./head-element-order/index.js").Value, undefined>>;
     readonly 'heading-levels': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
     readonly 'id-duplication': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'ineffective-attr': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
@@ -74,7 +83,7 @@ declare const rules: {
         readonly checkExperimental?: boolean;
         readonly checkNonStandard?: boolean;
     }>>;
-    readonly 'no-use-event-handler-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
+    readonly 'no-use-event-handler-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean | readonly string[], {
         ignore?: string | string[];
     }>>;
     readonly 'permitted-contents': Readonly<import("@markuplint/ml-core").RuleSeed<import("./permitted-contents/types.js").TagRule[], import("./permitted-contents/types.js").Options>>;

package/lib/index.js

@@ -7,6 +7,7 @@
  * areas such as accessibility, HTML validity, naming conventions, and coding style.
  */
 import AttrDuplication from './attr-duplication/index.js';
+import AttrOrder from './attr-order/index.js';
 import AttrValueQuotes from './attr-value-quotes/index.js';
 import CaseSensitiveAttrName from './case-sensitive-attr-name/index.js';
 import CaseSensitiveTagName from './case-sensitive-tag-name/index.js';
@@ -18,6 +19,7 @@ import DeprecatedElement from './deprecated-element/index.js';
 import DisallowedElement from './disallowed-element/index.js';
 import Doctype from './doctype/index.js';
 import EndTag from './end-tag/index.js';
+import HeadElementOrder from './head-element-order/index.js';
 import HeadingLevels from './heading-levels/index.js';
 import IdDuplication from './id-duplication/index.js';
 import IneffectiveAttr from './ineffective-attr/index.js';
@@ -56,6 +58,7 @@ import WaiAria from './wai-aria/index.js';
  */
 const rules = {
     'attr-duplication': AttrDuplication,
+    'attr-order': AttrOrder,
     'attr-value-quotes': AttrValueQuotes,
     'case-sensitive-attr-name': CaseSensitiveAttrName,
     'case-sensitive-tag-name': CaseSensitiveTagName,
@@ -67,6 +70,7 @@ const rules = {
     'disallowed-element': DisallowedElement,
     doctype: Doctype,
     'end-tag': EndTag,
+    'head-element-order': HeadElementOrder,
     'heading-levels': HeadingLevels,
     'id-duplication': IdDuplication,
     'ineffective-attr': IneffectiveAttr,

package/lib/ineffective-attr/index.js

@@ -1,5 +1,6 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { toNoEmptyStringArrayFromStringOrArray } from '@markuplint/shared';
+import { removeAttr } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Rule that detects attributes that have no effect on their owner element.
@@ -29,6 +30,7 @@ export default createRule({
                     message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'ineffective') +
                         t('. ') +
                         t("It doesn't need {0}", t('the {0}', 'attribute')),
+                    fix: fixer => removeAttr(fixer, attr),
                 });
             }
         });

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

@@ -1,5 +1,6 @@
 /** Rule metadata for `ineffective-attr`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

package/lib/ineffective-attr/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `ineffective-attr`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

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

@@ -1,4 +1,5 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
+import { removeAttrValue } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Rule that disallows explicit values on boolean attributes.
@@ -45,6 +46,7 @@ export default createRule({
                     message: t('{0} is {1}', t('the "{0*}" {1}', name, 'attribute'), t('a {0}', 'boolean attribute')) +
                         t('. ') +
                         t("It doesn't need {0}", t('the {0}', 'value')),
+                    fix: fixer => removeAttrValue(fixer, attr),
                 });
             }
         });

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

@@ -1,5 +1,6 @@
 /** Rule metadata for `no-boolean-attr-value`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

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

@@ -1,4 +1,5 @@
 /** Rule metadata for `no-boolean-attr-value`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

package/lib/no-consecutive-br/index.js

@@ -19,9 +19,11 @@ export default createRule({
                 next = next.nextSibling;
             }
             if (next && next.nodeName === 'BR') {
+                const target = next;
                 report({
-                    scope: next,
+                    scope: target,
                     message: t('{0} detected', t('Consecutive {0}', t('"{0*}" {1}', 'br', 'elements'))),
+                    fix: fixer => fixer.remove({ startOffset: target.startOffset, raw: target.raw }),
                 });
             }
         }

package/lib/no-consecutive-br/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `no-consecutive-br`: categorized as an accessibility rule. */
 declare const _default: {
     readonly category: "a11y";
+    readonly fixable: true;
 };
 export default _default;

package/lib/no-consecutive-br/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `no-consecutive-br`: categorized as an accessibility rule. */
 export default {
     category: 'a11y',
+    fixable: true,
 };

package/lib/no-default-value/index.js

@@ -1,5 +1,5 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
-import { toNormalizedValue } from '../helpers.js';
+import { removeAttr, toNormalizedValue } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Rule that disallows explicitly setting an attribute to its default value.
@@ -33,6 +33,7 @@ export default createRule({
                     col: attr.valueNode?.startCol,
                     raw: attr.valueNode?.raw,
                     message: t('It is {0}', t('the {0}', 'default value')),
+                    fix: fixer => removeAttr(fixer, attr),
                 });
             }
         });

package/lib/no-default-value/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `no-default-value`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
+    readonly fixable: true;
 };
 export default _default;

package/lib/no-default-value/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `no-default-value`: categorized as a style rule. */
 export default {
     category: 'style',
+    fixable: true,
 };

package/lib/no-duplicate-dt/index.js

@@ -14,7 +14,8 @@ export default createRule({
             const dtList = [...dl.querySelectorAll(':scope > dt, :scope > div > dt')];
             const names = new Set();
             for (const dt of dtList) {
-                // TODO: Supoort for alternative text for images and accessible names for contained elements.
+                // Support for alternative text for images and accessible names for contained elements
+                // is not yet implemented; currently only textContent is used for comparison.
                 const name = dt.textContent?.trim();
                 if (!name) {
                     continue;

package/lib/no-orphaned-end-tag/index.js

@@ -15,6 +15,7 @@ export default createRule({
                 report({
                     scope: text,
                     message: t('{0} detected', t('Orphaned end tag')),
+                    fix: fixer => fixer.remove({ startOffset: text.startOffset, raw: text.raw }),
                 });
             }
         });

package/lib/no-orphaned-end-tag/meta.d.ts

@@ -1,5 +1,6 @@
 /** Rule metadata for `no-orphaned-end-tag`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
+    readonly fixable: true;
 };
 export default _default;

package/lib/no-orphaned-end-tag/meta.js

@@ -1,4 +1,5 @@
 /** Rule metadata for `no-orphaned-end-tag`: categorized as a validation rule. */
 export default {
     category: 'validation',
+    fixable: true,
 };

package/lib/no-unsupported-features/compat-data.js

@@ -24,12 +24,24 @@ let bcdPromise;
  * at startup, even when this rule is disabled. Dynamic import defers the
  * cost until the rule actually runs.
  *
+ * Uses `forLegacyNode` to avoid `ERR_IMPORT_ATTRIBUTE_MISSING` on Node.js >= 22.
+ * The main entry (`@mdn/browser-compat-data`) points directly to `data.json`,
+ * which requires `import ... with { type: "json" }` on Node.js >= 22.
+ * The `forLegacyNode` wrapper uses `fs.readFileSync` instead, compatible
+ * with all Node.js versions.
+ *
+ * NOTE: If `forLegacyNode` is removed in a future BCD version, migrate to:
+ *   `import('...', { with: { type: 'json' } })`
+ * once the minimum supported Node.js version supports import attributes.
+ *
  * Uses a Promise-based cache to prevent race conditions when multiple
  * concurrent calls trigger the import simultaneously.
  */
 function loadBcd() {
     if (!bcdPromise) {
-        bcdPromise = import('@mdn/browser-compat-data').then(mod => mod.default ?? mod);
+        // `?? mod` is a defensive fallback for CJS interop environments
+        // where `default` may not be set on the module namespace object.
+        bcdPromise = import('@mdn/browser-compat-data/forLegacyNode').then(mod => mod.default ?? mod);
     }
     return bcdPromise;
 }

package/lib/no-use-event-handler-attr/index.d.ts

@@ -10,6 +10,9 @@ type Options = {
  * Reports any attribute on an HTML element whose name starts with `on`,
  * indicating an inline event handler. An `ignore` option allows specific
  * attribute names or patterns to be excluded from the check.
+ *
+ * The value can be `true` (disallow all event handlers) or a `string[]`
+ * of event names (without the `on` prefix) to selectively disallow.
  */
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean | readonly string[], Options>>;
 export default _default;

package/lib/no-use-event-handler-attr/index.js

@@ -1,6 +1,25 @@
 import { createRule } from '@markuplint/ml-core';
 import { match } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Extracts the event name from an attribute name by stripping the `on` prefix
+ * and lowercasing. Returns `null` if the attribute is not an event handler.
+ */
+function extractEventName(attrName) {
+    const m = /^on(.+)/i.exec(attrName);
+    return m?.[1] ? m[1].toLowerCase() : null;
+}
+/**
+ * Tests whether an event name matches a pattern. The pattern is either a plain
+ * string (compared case-insensitively) or a regex literal (`/pattern/flags`).
+ */
+function matchEventName(eventName, pattern) {
+    const regexMatch = /^\/(.*)\/([gim])*$/.exec(pattern);
+    if (regexMatch?.[1]) {
+        return new RegExp(regexMatch[1], regexMatch[2]).test(eventName);
+    }
+    return eventName === pattern.toLowerCase();
+}
 /**
  * Rule that disallows inline event handler attributes (e.g., `onclick`,
  * `onchange`).
@@ -8,6 +27,9 @@ import meta from './meta.js';
  * Reports any attribute on an HTML element whose name starts with `on`,
  * indicating an inline event handler. An `ignore` option allows specific
  * attribute names or patterns to be excluded from the check.
+ *
+ * The value can be `true` (disallow all event handlers) or a `string[]`
+ * of event names (without the `on` prefix) to selectively disallow.
  */
 export default createRule({
     meta: meta,
@@ -29,7 +51,12 @@ export default createRule({
                     return;
                 }
             }
-            if (/^on/i.test(name)) {
+            const eventName = extractEventName(name);
+            if (eventName == null) {
+                return;
+            }
+            const { value } = attr.rule;
+            if (value === true) {
                 report({
                     scope: attr,
                     raw: attr.raw,
@@ -37,6 +64,21 @@ export default createRule({
                     col: attr.startCol,
                     message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
                 });
+                return;
+            }
+            if (Array.isArray(value)) {
+                for (const pattern of value) {
+                    if (matchEventName(eventName, pattern)) {
+                        report({
+                            scope: attr,
+                            raw: attr.raw,
+                            line: attr.startLine,
+                            col: attr.startCol,
+                            message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
+                        });
+                        return;
+                    }
+                }
             }
         });
     },

package/lib/wai-aria/checkings/non-existent-role.js

@@ -30,10 +30,7 @@ export const checkingNonExistentRole = ({ attr }) => t => {
         if (!role) {
             return {
                 scope: token,
-                message: t('{0} according to {1}', t('{0} does not exist', t('the "{0*}" {1}', token.raw, 'role')), 'the WAI-ARIA specification') +
-                    t('.') +
-                    // TODO: Translate
-                    ` This "${token.raw}" role does not exist in WAI-ARIA.`,
+                message: t('{0} according to {1}', t('{0} does not exist', t('the "{0*}" {1}', token.raw, 'role')), 'the WAI-ARIA specification') + t('.'),
             };
         }
     }

package/lib/wai-aria/checkings/required-owned-elements.js

@@ -33,7 +33,9 @@ export const checkingRequiredOwnedElements = ({ el, role }) => t => {
     if (el.matches('[aria-busy="true" i]')) {
         return;
     }
-    // TODO: Needs to resolve `aria-own`
+    // TODO: Needs to resolve `aria-owns` references to include virtually owned elements.
+    // Currently, only DOM-tree children are checked. Elements referenced via `aria-owns`
+    // should also be considered as owned elements per the ARIA specification.
     const ariaVersion = el.rule.options?.version ?? el.ownerMLDocument.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
     const children = classifyChildren(el, role, ariaVersion);
     if (children.some(([, type]) => type === 'BUSY')) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "5.0.0-alpha.2",
+	"version": "5.0.0-dev.5+e96392f56",
 	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -27,12 +27,12 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "5.0.0-alpha.2",
-		"@markuplint/ml-core": "5.0.0-alpha.2",
-		"@markuplint/ml-spec": "5.0.0-alpha.2",
-		"@markuplint/selector": "5.0.0-alpha.2",
-		"@markuplint/shared": "5.0.0-alpha.2",
-		"@markuplint/types": "5.0.0-alpha.2",
+		"@markuplint/html-spec": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-core": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-spec": "5.0.0-dev.5+e96392f56",
+		"@markuplint/selector": "5.0.0-dev.5+e96392f56",
+		"@markuplint/shared": "5.0.0-dev.5+e96392f56",
+		"@markuplint/types": "5.0.0-dev.5+e96392f56",
 		"@mdn/browser-compat-data": "^7.3.2",
 		"@types/debug": "4.1.12",
 		"ansi-colors": "4.1.3",
@@ -42,5 +42,5 @@
 		"image-size": "^2.0.2",
 		"type-fest": "5.4.4"
 	},
-	"gitHead": "31ccf1e81443ea3f93597d287595211f1823ddcf"
+	"gitHead": "e96392f56e4bc8165ba59622b41c822703a96372"
 }

package/schema.json

@@ -9,6 +9,9 @@
 				"attr-duplication": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-duplication/schema.json"
 				},
+				"attr-order": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-order/schema.json"
+				},
 				"attr-value-quotes": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-value-quotes/schema.json"
 				},
@@ -42,6 +45,9 @@
 				"end-tag": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/end-tag/schema.json"
 				},
+				"head-element-order": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/head-element-order/schema.json"
+				},
 				"heading-levels": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/heading-levels/schema.json"
 				},