@markuplint/rules 4.12.0 → 5.0.0-alpha.1

package/CHANGELOG.md

@@ -3,6 +3,76 @@
 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.1](https://github.com/markuplint/markuplint/compare/v5.0.0-alpha.0...v5.0.0-alpha.1) (2026-02-22)
+
+- fix(rules)!: remove complementary from top-level landmark check ([4643651](https://github.com/markuplint/markuplint/commit/4643651d256276ae0473d4756e72277d59398e3d))
+
+### BREAKING CHANGES
+
+- The landmark-roles rule no longer checks that
+  complementary landmarks are top-level. This aligns with axe-core's
+  deprecation of landmark-complementary-is-top-level.
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+
+# [5.0.0-alpha.0](https://github.com/markuplint/markuplint/compare/v4.14.1...v5.0.0-alpha.0) (2026-02-20)
+
+### Bug Fixes
+
+- **rules:** address review feedback for require-dialog-autofocus ([6fcadb2](https://github.com/markuplint/markuplint/commit/6fcadb2ab0e6a974e8ba6f644eff914a7840b8ef))
+- treat orphaned end tags as bogus instead of plain text ([#1575](https://github.com/markuplint/markuplint/issues/1575)) ([557199a](https://github.com/markuplint/markuplint/commit/557199a6960ab35573a544f9a33c00e98eb9967e))
+
+- feat(rules)!: simplify invalid-attr options and remove attrs ([3ced12d](https://github.com/markuplint/markuplint/commit/3ced12d200f12ba4c9e177c9aaca25e7e24a9151))
+- feat(rules)!: add no-unsupported-features rule for browser support checks ([8525a96](https://github.com/markuplint/markuplint/commit/8525a96fb04f634820362a9a73d6541284b53686))
+- feat(rules)!: change ignoreOmittedElements default to true ([5ec04a7](https://github.com/markuplint/markuplint/commit/5ec04a7d63cbf19846b42124c22653197f603a59)), closes [#3136](https://github.com/markuplint/markuplint/issues/3136)
+- refactor(rules)!: replace selfClosingSolidus with tagCloseChar ([f9cd9d8](https://github.com/markuplint/markuplint/commit/f9cd9d81bfb0ba49c2578eace7b04a9a1ebdd12a))
+
+### Features
+
+- **html-spec:** require href or imagesrcset on link element ([e6a2631](https://github.com/markuplint/markuplint/commit/e6a26318ed8e4be9ba4e81884eb0b879a816efb5)), closes [#717](https://github.com/markuplint/markuplint/issues/717)
+- **ml-spec,rules:** adopt ARIA 1.3 property names with 1.2 compat ([4f7e54d](https://github.com/markuplint/markuplint/commit/4f7e54d21593495d36e48fbe8ad27f8be85ab5ef))
+- **rules:** add correct-aspect-ratio rule ([4068582](https://github.com/markuplint/markuplint/commit/40685828da697dfa8565288438a5d027dd0fae45))
+- **rules:** add ignoreAttrs option to required-attr rule ([#690](https://github.com/markuplint/markuplint/issues/690)) ([fe4ce5e](https://github.com/markuplint/markuplint/commit/fe4ce5e283bc9e5284d209322dc0bbe3cbe07d55))
+- **rules:** add link-types rule for rel attribute validation ([95d22a5](https://github.com/markuplint/markuplint/commit/95d22a596c1f786c385b7e99c3b818434995f4b5))
+- **rules:** add redundant-accessible-name rule for detecting overridden accessible name sources ([63b89d4](https://github.com/markuplint/markuplint/commit/63b89d47bf5056f823d5b27cda4fda2b96419bb3))
+- **rules:** add require-dialog-autofocus rule ([2d8d650](https://github.com/markuplint/markuplint/commit/2d8d650f8bc82e706687d292b27c310f3552b418)), closes [#689](https://github.com/markuplint/markuplint/issues/689)
+- **rules:** add required context role check to wai-aria rule ([#970](https://github.com/markuplint/markuplint/issues/970)) ([1433a5a](https://github.com/markuplint/markuplint/commit/1433a5ae429aca4e7dc0a1a7f514a184eb423c03))
+- **rules:** add srcset-sizes-constraint rule ([#1051](https://github.com/markuplint/markuplint/issues/1051)) ([bcc624a](https://github.com/markuplint/markuplint/commit/bcc624a3c6535ef85ad155b05d7571198983277a))
+- **rules:** recognize DPub ARIA roles in wai-aria rule ([3dd32ff](https://github.com/markuplint/markuplint/commit/3dd32ffa7e5e706bad33bf9b9ff1785de8c8e630))
+- **rules:** suggest similar attribute names for typos in invalid-attr rule ([337c7c5](https://github.com/markuplint/markuplint/commit/337c7c56b792cf7bc72baa3a2528f0c93892d550)), closes [#1487](https://github.com/markuplint/markuplint/issues/1487)
+- **rules:** support ARIA 1.3 generic transparency in owned elements check ([c1d6991](https://github.com/markuplint/markuplint/commit/c1d6991cb197d511c5751bba183fde1208001590))
+- **rules:** support source elements inside picture in correct-aspect-ratio ([3cd3dc9](https://github.com/markuplint/markuplint/commit/3cd3dc9981a04f4ff5b78b97c28cc7852d31886e))
+- **rules:** use ruleCommonSettings.ariaVersion fallback in ARIA rules ([07ccd8a](https://github.com/markuplint/markuplint/commit/07ccd8acd8b9db11ccf473b419a3d01cc782e15c))
+
+### Performance Improvements
+
+- **rules:** fix exponential slowdown in transparent element resolution ([f657e6a](https://github.com/markuplint/markuplint/commit/f657e6a0156933c3acafb8e3975fbc31488b7cca)), closes [#3249](https://github.com/markuplint/markuplint/issues/3249)
+
+### BREAKING CHANGES
+
+- Remove the deprecated `attrs` option and the
+  `{ type: X }` value wrapper from `invalid-attr` rule options.
+
+* Remove `attrs` option (deprecated since v3.7.0)
+* Remove `{ type: X }` wrapper; specify type strings directly
+* Deprecate object format for `allowAttrs`/`disallowAttrs`
+* Unify value type validation via the types API
+
+- non-standard element/attribute detection moved from
+  deprecated-element to no-unsupported-features with checkNonStandard option.
+  Users of recommended preset are unaffected (auto-enabled via compat preset).
+- The `ignoreOmittedElements` option in the
+  `required-element` rule now defaults to `true` instead of `false`.
+  Ghost (omitted) elements implicitly created by the HTML parser
+  are no longer counted as satisfying the requirement by default.
+  Users who relied on the previous behavior should explicitly set
+  `ignoreOmittedElements: false`.
+- The end-tag rule now checks tagCloseChar for
+  self-closing detection instead of the removed selfClosingSolidus
+  property.
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+
 # [4.12.0](https://github.com/markuplint/markuplint/compare/@markuplint/rules@4.11.2...@markuplint/rules@4.12.0) (2026-02-10)
 
 ### Features

package/lib/attr-check.d.ts

@@ -1,5 +1,6 @@
 import type { Translator } from '@markuplint/i18n';
 import type { Attribute as AttrSpec, AttributeType } from '@markuplint/ml-spec';
+import type { Type } from '@markuplint/types';
 import type { ReadonlyDeep } from 'type-fest';
 /**
  * Discriminated union tag representing the kind of attribute invalidity.
@@ -40,10 +41,12 @@ type Loc = {
  * @param value - The attribute value to validate
  * @param isCustomRule - When `true`, skips the built-in bypass for `data-*`, `aria-*`, and `adapt-*` attributes
  * @param spec - The attribute specification to validate against; if absent, the attribute is considered non-existent
+ * @param allAttrNames - Optional list of all valid attribute names for the element;
+ *   used to suggest a similar attribute name via Levenshtein distance when the attribute is non-existent
  * @returns `false` if the attribute is valid, a single `Invalid` object for existence/disallowed errors,
  *   or an array of `Invalid<'invalid-value'>` objects for value validation failures
  */
-export declare function attrCheck(t: Translator, name: string, value: string, isCustomRule: boolean, spec?: AttrSpec): Invalid | Invalid<'invalid-value'>[] | false;
+export declare function attrCheck(t: Translator, name: string, value: string, isCustomRule: boolean, spec?: AttrSpec, allAttrNames?: readonly string[]): Invalid | Invalid<'invalid-value'>[] | false;
 /**
  * Validates an attribute value against a single attribute type definition.
  * Returns `false` if the value is valid, or a tuple of `[message, location]`
@@ -57,5 +60,5 @@ export declare function attrCheck(t: Translator, name: string, value: string, is
  * @param type - The attribute type definition to validate against
  * @returns `false` if the value is valid, or a `[message, location]` tuple on failure
  */
-export declare function valueCheck(t: Translator, name: string, value: string, type: ReadonlyDeep<AttributeType>): [string, Loc] | false;
+export declare function valueCheck(t: Translator, name: string, value: string, type: ReadonlyDeep<AttributeType | Type>): [string, Loc] | false;
 export {};

package/lib/attr-check.js

@@ -1,5 +1,5 @@
 import { toNonNullableArrayFromItemOrArray } from '@markuplint/shared';
-import { check } from '@markuplint/types';
+import { check, getCandidate } from '@markuplint/types';
 import { createMessageValueExpected } from './create-message.js';
 import { log } from './debug.js';
 /**
@@ -18,10 +18,12 @@ import { log } from './debug.js';
  * @param value - The attribute value to validate
  * @param isCustomRule - When `true`, skips the built-in bypass for `data-*`, `aria-*`, and `adapt-*` attributes
  * @param spec - The attribute specification to validate against; if absent, the attribute is considered non-existent
+ * @param allAttrNames - Optional list of all valid attribute names for the element;
+ *   used to suggest a similar attribute name via Levenshtein distance when the attribute is non-existent
  * @returns `false` if the attribute is valid, a single `Invalid` object for existence/disallowed errors,
  *   or an array of `Invalid<'invalid-value'>` objects for value validation failures
  */
-export function attrCheck(t, name, value, isCustomRule, spec) {
+export function attrCheck(t, name, value, isCustomRule, spec, allAttrNames) {
     if (!isCustomRule) {
         if (/^data-.+$/.test(name)) {
             // Ignore checking because "data-*" attribute is any type
@@ -41,9 +43,17 @@ export function attrCheck(t, name, value, isCustomRule, spec) {
     // Existence
     if (!spec) {
         log('The "%s" attribute DOES\'NT EXIST in the spec', name);
+        const baseMessage = t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed');
+        const candidate = allAttrNames ? getCandidate(name, allAttrNames) : undefined;
+        if (candidate) {
+            return {
+                invalidType: 'non-existent',
+                message: baseMessage + t('. ') + t('Did you mean "{0*}"?', candidate),
+            };
+        }
         return {
             invalidType: 'non-existent',
-            message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed'),
+            message: baseMessage,
         };
     }
     const nameCaseSensitive = /[A-Z]/.test(spec.name);

package/lib/character-reference/index.d.ts

@@ -5,7 +5,8 @@ import type { RuleConfigValue } from '@markuplint/ml-config';
  *
  * Scans text nodes and attribute values for the characters `"`, `&`, `<`,
  * and `>` that are not already part of a valid character reference. Text
- * inside `<script>` and `<style>` elements is excluded.
+ * inside `<script>` and `<style>` elements is excluded, as are bogus
+ * text nodes (e.g., orphaned end tags).
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RuleConfigValue, undefined>>;
 export default _default;

package/lib/character-reference/index.js

@@ -16,13 +16,17 @@ const ignoreParentElement = new Set(['script', 'style']);
  *
  * Scans text nodes and attribute values for the characters `"`, `&`, `<`,
  * and `>` that are not already part of a valid character reference. Text
- * inside `<script>` and `<style>` elements is excluded.
+ * inside `<script>` and `<style>` elements is excluded, as are bogus
+ * text nodes (e.g., orphaned end tags).
  */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {
         const targetNodes = [];
         await document.walkOn('Text', node => {
+            if (node.isBogus) {
+                return;
+            }
             if (node.parentNode && ignoreParentElement.has(node.parentNode.nodeName.toLowerCase())) {
                 return;
             }

package/lib/correct-aspect-ratio/index.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    readonly documentRoot?: string;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/correct-aspect-ratio/index.js

@@ -0,0 +1,80 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+import { getImageDimensions } from './resolve-image-size.js';
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {},
+    async verify({ document, report }) {
+        await document.walkOn('Element', async (el) => {
+            const localName = el.localName;
+            // Only check img and source (inside picture) elements
+            if (localName !== 'img' && localName !== 'source') {
+                return;
+            }
+            // source is only relevant inside <picture>
+            if (localName === 'source' && el.parentElement?.localName !== 'picture') {
+                return;
+            }
+            if (el.hasSpreadAttr) {
+                return;
+            }
+            const widthAttr = el.getAttributeNode('width');
+            const heightAttr = el.getAttributeNode('height');
+            if (!widthAttr || !heightAttr) {
+                return;
+            }
+            if (widthAttr.isDynamicValue || heightAttr.isDynamicValue) {
+                return;
+            }
+            // Resolve the image URL from src (img) or srcset (source)
+            let src;
+            if (localName === 'img') {
+                const srcAttr = el.getAttributeNode('src');
+                if (!srcAttr || srcAttr.isDynamicValue) {
+                    return;
+                }
+                src = srcAttr.value;
+            }
+            else {
+                const srcsetAttr = el.getAttributeNode('srcset');
+                if (!srcsetAttr || srcsetAttr.isDynamicValue) {
+                    return;
+                }
+                const extracted = extractFirstSrcsetUrl(srcsetAttr.value);
+                if (!extracted) {
+                    return;
+                }
+                src = extracted;
+            }
+            const widthStr = widthAttr.value;
+            const heightStr = heightAttr.value;
+            // Parse width/height as integers; skip if non-numeric
+            const attrWidth = Number.parseInt(widthStr, 10);
+            const attrHeight = Number.parseInt(heightStr, 10);
+            if (!Number.isFinite(attrWidth) || !Number.isFinite(attrHeight) || attrWidth <= 0 || attrHeight <= 0) {
+                return;
+            }
+            const documentRoot = el.rule.options?.documentRoot;
+            const dimensions = await getImageDimensions(src, documentRoot, document.filename);
+            if (!dimensions) {
+                return;
+            }
+            const { width: actualWidth, height: actualHeight } = dimensions;
+            // Cross-multiplication comparison to avoid floating-point errors
+            if (attrWidth * actualHeight !== attrHeight * actualWidth) {
+                report({
+                    scope: el,
+                    message: `The aspect ratio of the image (${actualWidth}:${actualHeight}) does not match the width/height attributes (${widthStr}:${heightStr})`,
+                });
+            }
+        });
+    },
+});
+function extractFirstSrcsetUrl(srcset) {
+    const first = srcset.trim().split(',')[0]?.trim();
+    if (!first) {
+        return null;
+    }
+    return first.split(/\s+/)[0] ?? null;
+}

package/lib/correct-aspect-ratio/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "validation";
+};
+export default _default;

package/lib/correct-aspect-ratio/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'validation',
+};

package/lib/correct-aspect-ratio/resolve-image-size.d.ts

@@ -0,0 +1,24 @@
+interface ImageDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Reset module-level caches. **Only for testing.**
+ */
+export declare function _resetCacheForTesting(): void;
+/**
+ * Get the dimensions of an image file, using a cache keyed by absolute path,
+ * file size, and the original `src` value.
+ *
+ * Query strings and fragments in `src` are stripped when resolving the file
+ * path, but the original `src` is kept in the cache key so that different
+ * cache-busting suffixes produce separate cache entries (mirroring browser
+ * cache-busting semantics).
+ *
+ * @param src - The `src` attribute value
+ * @param documentRoot - Root directory for absolute paths
+ * @param documentFilename - The filename of the document being linted
+ * @returns The image dimensions, or `null` if the image cannot be resolved or read
+ */
+export declare function getImageDimensions(src: string, documentRoot: string | undefined, documentFilename: string | undefined): Promise<ImageDimensions | null>;
+export {};

package/lib/correct-aspect-ratio/resolve-image-size.js

@@ -0,0 +1,165 @@
+import { readFile, stat, mkdir, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { imageSize } from 'image-size';
+// In-memory cache: key = "absolutePath:fileSize:src"
+const memoryCache = new Map();
+let cacheLoaded = false;
+let _cacheDir;
+function getCacheDir() {
+    if (_cacheDir != null) {
+        return _cacheDir;
+    }
+    const req = createRequire(import.meta.url);
+    const { version } = req('../../package.json');
+    _cacheDir = path.join(tmpdir(), `markuplint-v${version}`);
+    return _cacheDir;
+}
+/**
+ * Reset module-level caches. **Only for testing.**
+ */
+export function _resetCacheForTesting() {
+    memoryCache.clear();
+    cacheLoaded = false;
+    _cacheDir = undefined;
+}
+function getCacheFilePath() {
+    return path.join(getCacheDir(), 'image-size-cache.json');
+}
+async function loadCacheFromDisk() {
+    if (cacheLoaded) {
+        return;
+    }
+    cacheLoaded = true;
+    let raw;
+    try {
+        raw = await readFile(getCacheFilePath(), 'utf8');
+    }
+    catch {
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    for (const [key, value] of Object.entries(data)) {
+        memoryCache.set(key, value);
+    }
+}
+async function saveCacheToDisk() {
+    const dir = getCacheDir();
+    try {
+        await mkdir(dir, { recursive: true });
+    }
+    catch {
+        return;
+    }
+    const obj = {};
+    for (const [key, value] of memoryCache) {
+        obj[key] = value;
+    }
+    try {
+        await writeFile(getCacheFilePath(), JSON.stringify(obj));
+    }
+    catch {
+        // Ignore write failures
+    }
+}
+function stripQueryAndFragment(src) {
+    const qIndex = src.indexOf('?');
+    const hIndex = src.indexOf('#');
+    let end = src.length;
+    if (qIndex !== -1)
+        end = Math.min(end, qIndex);
+    if (hIndex !== -1)
+        end = Math.min(end, hIndex);
+    return src.slice(0, end);
+}
+/**
+ * Resolve the absolute path of an image from its `src` attribute value.
+ *
+ * Query strings (`?...`) and fragments (`#...`) are stripped before resolving
+ * the file path so that cache-busting suffixes do not prevent file lookup.
+ *
+ * @param src - The `src` attribute value
+ * @param documentRoot - Root directory for absolute paths (defaults to cwd)
+ * @param documentFilename - The filename of the document being linted
+ * @returns The absolute path, or `null` if the path cannot be resolved (remote URLs, data URIs)
+ */
+function resolveImagePath(src, documentRoot, documentFilename) {
+    // Skip remote URLs and data URIs
+    if (/^https?:\/\//i.test(src) || /^data:/i.test(src)) {
+        return null;
+    }
+    const cleanSrc = stripQueryAndFragment(src);
+    // Absolute path (starts with /)
+    if (cleanSrc.startsWith('/')) {
+        return path.join(documentRoot ?? process.cwd(), cleanSrc);
+    }
+    // Relative path
+    if (documentFilename) {
+        return path.resolve(path.dirname(documentFilename), cleanSrc);
+    }
+    return path.join(documentRoot ?? process.cwd(), cleanSrc);
+}
+/**
+ * Get the dimensions of an image file, using a cache keyed by absolute path,
+ * file size, and the original `src` value.
+ *
+ * Query strings and fragments in `src` are stripped when resolving the file
+ * path, but the original `src` is kept in the cache key so that different
+ * cache-busting suffixes produce separate cache entries (mirroring browser
+ * cache-busting semantics).
+ *
+ * @param src - The `src` attribute value
+ * @param documentRoot - Root directory for absolute paths
+ * @param documentFilename - The filename of the document being linted
+ * @returns The image dimensions, or `null` if the image cannot be resolved or read
+ */
+export async function getImageDimensions(src, documentRoot, documentFilename) {
+    const absolutePath = resolveImagePath(src, documentRoot, documentFilename);
+    if (absolutePath == null) {
+        return null;
+    }
+    await loadCacheFromDisk();
+    // Get file size for cache key
+    let fileSize;
+    try {
+        const fileStat = await stat(absolutePath);
+        fileSize = fileStat.size;
+    }
+    catch {
+        return null;
+    }
+    const cacheKey = `${absolutePath}:${fileSize}:${src}`;
+    const cached = memoryCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    // Read and measure the image
+    let buffer;
+    try {
+        buffer = await readFile(absolutePath);
+    }
+    catch {
+        return null;
+    }
+    let result;
+    try {
+        result = imageSize(buffer);
+    }
+    catch {
+        return null;
+    }
+    if (result.width == null || result.height == null) {
+        return null;
+    }
+    const dimensions = { width: result.width, height: result.height };
+    memoryCache.set(cacheKey, dimensions);
+    await saveCacheToDisk();
+    return dimensions;
+}

package/lib/create-message.d.ts

@@ -1,6 +1,6 @@
 import type { Translator } from '@markuplint/i18n';
 import type { AttributeType } from '@markuplint/ml-spec';
-import type { UnmatchedResult } from '@markuplint/types';
+import type { UnmatchedResult, Type } from '@markuplint/types';
 import type { ReadonlyDeep } from 'type-fest';
 /**
  * Builds a human-readable error message explaining why an attribute value
@@ -15,7 +15,7 @@ import type { ReadonlyDeep } from 'type-fest';
  *   details about the mismatch (reason, candidate, part name, etc.)
  * @returns A localized error message describing the expected value
  */
-export declare function createMessageValueExpected(t: Translator, baseTarget: string, type: ReadonlyDeep<AttributeType>, matches: UnmatchedResult): string;
+export declare function createMessageValueExpected(t: Translator, baseTarget: string, type: ReadonlyDeep<AttributeType | Type>, matches: UnmatchedResult): string;
 /**
  * Assembles the detailed portion of a value-expected error message by
  * inspecting the mismatch reason and composing reason, expectation,

package/lib/create-message.js

@@ -1,4 +1,4 @@
-import { isList, isKeyword, isEnum, isNumber, isDirective } from '@markuplint/types';
+import { isList, isKeyword, isEnum, isNumber, isDirective, isPattern } from '@markuplint/types';
 /**
  * Builds a human-readable error message explaining why an attribute value
  * does not match its expected type. Handles both plain types and list types
@@ -258,6 +258,9 @@ function createExpectedObject(type, matches, t) {
     else if (isDirective(type)) {
         expectedObject.push(t('a {0}', 'directive'));
     }
+    else if (isPattern(type)) {
+        expectedObject.push(t('{0} ({1})', 'regular expression', type.pattern));
+    }
     const expects = expectedObject.length === 0
         ? null
         : 1 < expectedObject.length

package/lib/deprecated-element/index.d.ts

@@ -1,10 +1,8 @@
 /**
- * Rule that reports the use of deprecated, obsolete, or non-standard HTML
- * elements.
+ * Rule that reports the use of deprecated or obsolete HTML elements.
  *
  * Walks HTML and SVG elements and checks their spec status. Reports any
- * element that is marked as deprecated, obsolete, or non-standard in the
- * HTML specification.
+ * element that is marked as deprecated or obsolete in the HTML specification.
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/deprecated-element/index.js

@@ -1,12 +1,10 @@
 import { createRule, getSpec } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Rule that reports the use of deprecated, obsolete, or non-standard HTML
- * elements.
+ * Rule that reports the use of deprecated or obsolete HTML elements.
  *
  * Walks HTML and SVG elements and checks their spec status. Reports any
- * element that is marked as deprecated, obsolete, or non-standard in the
- * HTML specification.
+ * element that is marked as deprecated or obsolete in the HTML specification.
  */
 export default createRule({
     meta: meta,
@@ -18,8 +16,8 @@ export default createRule({
                 return;
             }
             const spec = getSpec(el, document.specs.specs);
-            if (spec && (spec.obsolete != null || spec.deprecated || spec.nonStandard)) {
-                const message = t('{0} is {1:c}', t('the "{0*}" {1}', el.localName, 'element'), spec.deprecated ? 'deprecated' : spec.obsolete == null ? 'non-standard' : 'obsolete');
+            if (spec && (spec.obsolete != null || spec.deprecated)) {
+                const message = t('{0} is {1:c}', t('the "{0*}" {1}', el.localName, 'element'), spec.deprecated ? 'deprecated' : 'obsolete');
                 report({
                     scope: el,
                     message,

package/lib/end-tag/index.js

@@ -25,7 +25,7 @@ export default createRule({
             if (el.closeTag != null) {
                 return;
             }
-            if ((document.endTag === 'xml' || el.isForeignElement) && el.selfClosingSolidus?.raw) {
+            if ((document.endTag === 'xml' || el.isForeignElement) && el.tagCloseChar.startsWith('/')) {
                 return;
             }
             report({

package/lib/heading-levels/index.js

@@ -8,7 +8,6 @@ import meta from './meta.js';
  */
 export default createRule({
     meta: meta,
-    defaultValue: true,
     defaultOptions: null,
     verify({ document, report, t }) {
         const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');

package/lib/helpers.d.ts

@@ -96,6 +96,7 @@ export declare function toNormalizedValue(value: string, spec: Attribute): strin
  * @returns `true` if the accessible name could change dynamically, `false` otherwise
  */
 export declare function accnameMayBeMutable(el: Element<any, any>, document: Document<any, any>): boolean;
+export declare const labelable: string[];
 /**
  * Finds the `<label>` element associated with a labelable form element.
  * First checks for an ancestor `<label>`, then looks for a `<label>` whose

package/lib/helpers.js

@@ -1,11 +1,3 @@
-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_items;
-// @ts-ignore
-import structuredClone from '@ungap/structured-clone';
 import { attrCheck } from './attr-check.js';
 /**
  * Tests whether an element matches the condition specified in an attribute spec.
@@ -103,7 +95,8 @@ node, attrSpecs,
 log) {
     const spec = attrSpecs.find(s => s.name.toLowerCase() === name.toLowerCase());
     log?.('Spec of the %s attr: %o', name, spec);
-    let invalid = attrCheck(t, name, value, false, spec);
+    const allAttrNames = attrSpecs.map(s => s.name);
+    let invalid = attrCheck(t, name, value, false, spec, allAttrNames);
     if (invalid === false &&
         spec &&
         spec.condition != null &&
@@ -180,7 +173,7 @@ document) {
     }
     return false;
 }
-const labelable = ['button', 'input:not([type=hidden])', 'meter', 'output', 'progress', 'select', 'textarea'];
+export const labelable = ['button', 'input:not([type=hidden])', 'meter', 'output', 'progress', 'select', 'textarea'];
 /**
  * Finds the `<label>` element associated with a labelable form element.
  * First checks for an ancestor `<label>`, then looks for a `<label>` whose
@@ -218,6 +211,7 @@ document) {
  * @template T - The type of items stored in the collection
  */
 export class Collection {
+    #items = new Set();
     /**
      * Creates a new collection, optionally pre-populated with the given items.
      * Any `null` or `undefined` values are silently ignored.
@@ -225,7 +219,6 @@ export class Collection {
      * @param items - Initial items to add to the collection
      */
     constructor(...items) {
-        _Collection_items.set(this, new Set());
         this.add(...items);
     }
     /**
@@ -233,8 +226,8 @@ export class Collection {
      *
      * @returns An iterator that yields each item in insertion order
      */
-    [(_Collection_items = new WeakMap(), Symbol.iterator)]() {
-        return __classPrivateFieldGet(this, _Collection_items, "f").values();
+    [Symbol.iterator]() {
+        return this.#items.values();
     }
     /**
      * Adds one or more items to the collection.
@@ -247,7 +240,7 @@ export class Collection {
             if (item == null) {
                 continue;
             }
-            __classPrivateFieldGet(this, _Collection_items, "f").add(item);
+            this.#items.add(item);
         }
     }
     /**
@@ -256,7 +249,7 @@ export class Collection {
      * @returns A read-only array containing all items in insertion order
      */
     toArray() {
-        return Object.freeze([...__classPrivateFieldGet(this, _Collection_items, "f")]);
+        return Object.freeze([...this.#items]);
     }
 }
 /**