@markuplint/rules 4.11.2 → 5.0.0-alpha.0

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,33 @@
 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';
-export declare function createMessageValueExpected(t: Translator, baseTarget: string, type: ReadonlyDeep<AttributeType>, matches: UnmatchedResult): string;
+/**
+ * Builds a human-readable error message explaining why an attribute value
+ * does not match its expected type. Handles both plain types and list types
+ * (space-separated or comma-separated).
+ *
+ * @param t - The i18n translator for generating localized messages
+ * @param baseTarget - A human-readable description of the attribute being validated
+ *   (e.g. `'the "href" attribute'`)
+ * @param type - The attribute type definition that the value was validated against
+ * @param matches - The result object from a failed type check, containing
+ *   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 | Type>, matches: UnmatchedResult): string;
+/**
+ * Assembles the detailed portion of a value-expected error message by
+ * inspecting the mismatch reason and composing reason, expectation,
+ * candidate suggestion, and fallback parts into a single string.
+ *
+ * This is an internal helper exposed for testing and advanced use.
+ * The double-underscore prefix indicates it is not part of the stable public API.
+ *
+ * @param t - The i18n translator for generating localized messages
+ * @param baseTarget - A human-readable description of the validation target
+ * @param expected - A description of the expected value(s), or `null` if unknown
+ * @param matches - Partial match result containing reason, candidate, and other details
+ * @returns A localized error message string
+ */
 export declare function __createMessageValueExpected(t: Translator, baseTarget: string, expected: string | null, matches: Pick<UnmatchedResult, 'partName' | 'reason' | 'raw' | 'candidate' | 'ref' | 'extra' | 'fallbackTo'>): string;

package/lib/create-message.js

@@ -1,4 +1,17 @@
-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
+ * (space-separated or comma-separated).
+ *
+ * @param t - The i18n translator for generating localized messages
+ * @param baseTarget - A human-readable description of the attribute being validated
+ *   (e.g. `'the "href" attribute'`)
+ * @param type - The attribute type definition that the value was validated against
+ * @param matches - The result object from a failed type check, containing
+ *   details about the mismatch (reason, candidate, part name, etc.)
+ * @returns A localized error message describing the expected value
+ */
 export function createMessageValueExpected(t, baseTarget, type, matches) {
     let target = baseTarget;
     let listDescriptionPart;
@@ -17,6 +30,20 @@ export function createMessageValueExpected(t, baseTarget, type, matches) {
         .join(t('. '));
     return message;
 }
+/**
+ * Assembles the detailed portion of a value-expected error message by
+ * inspecting the mismatch reason and composing reason, expectation,
+ * candidate suggestion, and fallback parts into a single string.
+ *
+ * This is an internal helper exposed for testing and advanced use.
+ * The double-underscore prefix indicates it is not part of the stable public API.
+ *
+ * @param t - The i18n translator for generating localized messages
+ * @param baseTarget - A human-readable description of the validation target
+ * @param expected - A description of the expected value(s), or `null` if unknown
+ * @param matches - Partial match result containing reason, candidate, and other details
+ * @returns A localized error message string
+ */
 export function __createMessageValueExpected(t, baseTarget, expected, matches) {
     let target = baseTarget;
     let reasonPart;
@@ -132,7 +159,7 @@ export function __createMessageValueExpected(t, baseTarget, expected, matches) {
                 switch (matches.reason.type) {
                     case 'out-of-range-length-digit': {
                         const { gte, lte } = matches.reason;
-                        let expectedDigits = null;
+                        let expectedDigits;
                         if (lte != null && gte === lte) {
                             expectedDigits = t('{0} digits', gte);
                         }
@@ -199,6 +226,17 @@ export function __createMessageValueExpected(t, baseTarget, expected, matches) {
     }
     return message;
 }
+/**
+ * Derives a human-readable description of the expected value from an attribute
+ * type definition and the unmatched result. Inspects keywords, enums, numbers,
+ * directives, and explicit `expects` entries from the match result.
+ *
+ * @param type - The attribute type (excluding list wrappers)
+ * @param matches - The unmatched result containing optional `expects` hints
+ * @param t - The i18n translator
+ * @returns A localized string describing the expected value(s), or `null` if
+ *   no expectation can be determined
+ */
 function createExpectedObject(type, matches, t) {
     const expectedObject = [];
     if (matches.expects && matches.expects.length > 0) {
@@ -220,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
@@ -227,6 +268,14 @@ function createExpectedObject(type, matches, t) {
             : (expectedObject[0] ?? null);
     return expects;
 }
+/**
+ * Converts a single `Expect` descriptor into a human-readable word or phrase.
+ *
+ * @param t - The i18n translator
+ * @param expect - The expectation descriptor from a type-check result
+ * @param type - The attribute type context for determining phrasing (e.g. CSS syntax)
+ * @returns A localized word or phrase describing the expected value
+ */
 function expectValueToWord(t, expect, type) {
     switch (expect.type) {
         case 'common': {
@@ -249,6 +298,15 @@ function expectValueToWord(t, expect, type) {
         }
     }
 }
+/**
+ * Builds a human-readable description of an expected numeric range
+ * from a `Number` type definition (e.g. "integer greater than or equal to 0").
+ *
+ * @param t - The i18n translator
+ * @param type - The number type definition containing range constraints
+ *   (`gt`, `gte`, `lt`, `lte`) and the numeric type label
+ * @returns A localized description of the expected numeric range
+ */
 function createExpectedNumber(t, type) {
     if (type.gt != null) {
         if (type.lt != null) {

package/lib/debug.d.ts

@@ -1,3 +1,12 @@
 import debug from 'debug';
+/**
+ * Type alias for the debug logger function provided by the `debug` package.
+ * Used throughout the rules package for conditional diagnostic logging.
+ */
 export type Log = debug.Debugger;
+/**
+ * Shared debug logger instance for the `@markuplint/rules` package.
+ * Enable by setting the `DEBUG` environment variable to include `ml-rules`
+ * (e.g. `DEBUG=ml-rules`).
+ */
 export declare const log: debug.Debugger;

package/lib/debug.js

@@ -1,2 +1,7 @@
 import debug from 'debug';
+/**
+ * Shared debug logger instance for the `@markuplint/rules` package.
+ * Enable by setting the `DEBUG` environment variable to include `ml-rules`
+ * (e.g. `DEBUG=ml-rules`).
+ */
 export const log = debug('ml-rules');

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

@@ -1,2 +1,8 @@
+/**
+ * Rule that reports the use of deprecated or obsolete HTML attributes.
+ *
+ * Checks each attribute against the HTML spec and reports any that are
+ * marked as deprecated or obsolete.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/deprecated-attr/index.js

@@ -1,5 +1,11 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that reports the use of deprecated or obsolete HTML attributes.
+ *
+ * Checks each attribute against the HTML spec and reports any that are
+ * marked as deprecated or obsolete.
+ */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {

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

@@ -1,3 +1,4 @@
+/** Rule metadata for `deprecated-attr`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/deprecated-attr/meta.js

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

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

@@ -1,2 +1,8 @@
+/**
+ * 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 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,5 +1,11 @@
 import { createRule, getSpec } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * 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 or obsolete in the HTML specification.
+ */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {
@@ -10,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/deprecated-element/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for `deprecated-element`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/deprecated-element/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for `deprecated-element`: categorized as a validation rule. */
 export default {
     category: 'validation',
 };

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

@@ -1,2 +1,9 @@
+/**
+ * Rule that disallows elements matching the configured CSS selectors.
+ *
+ * Accepts an array of selector strings as its value. Queries the document
+ * (and per-element overrides) for matching elements and reports each one
+ * as disallowed.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<string[], undefined>>;
 export default _default;

package/lib/disallowed-element/index.js

@@ -1,5 +1,12 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that disallows elements matching the configured CSS selectors.
+ *
+ * Accepts an array of selector strings as its value. Queries the document
+ * (and per-element overrides) for matching elements and reports each one
+ * as disallowed.
+ */
 export default createRule({
     meta: meta,
     defaultValue: [],

package/lib/disallowed-element/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for `disallowed-element`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/disallowed-element/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for `disallowed-element`: categorized as a validation rule. */
 export default {
     category: 'validation',
 };

package/lib/doctype/index.d.ts

@@ -1,5 +1,15 @@
+/** Configuration options for the doctype rule. */
 type Option = {
+    /** Whether to report obsolete doctypes that include a public or system identifier. */
     denyObsoleteType: boolean;
 };
+/**
+ * Rule that validates the presence and correctness of the document's DOCTYPE
+ * declaration.
+ *
+ * Reports an error when no DOCTYPE is found (skipped for document fragments)
+ * and when an obsolete DOCTYPE (one with a public or system identifier) is
+ * declared.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<"always", Option>>;
 export default _default;

package/lib/doctype/index.js

@@ -1,5 +1,13 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that validates the presence and correctness of the document's DOCTYPE
+ * declaration.
+ *
+ * Reports an error when no DOCTYPE is found (skipped for document fragments)
+ * and when an obsolete DOCTYPE (one with a public or system identifier) is
+ * declared.
+ */
 export default createRule({
     meta: meta,
     defaultValue: 'always',

package/lib/doctype/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for `doctype`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/doctype/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for `doctype`: categorized as a validation rule. */
 export default {
     category: 'validation',
 };

package/lib/end-tag/index.d.ts

@@ -1,2 +1,9 @@
+/**
+ * Rule that checks for missing end tags on non-void HTML elements.
+ *
+ * Reports elements that are neither void nor self-closing and have no
+ * closing tag. Omitted elements and elements in documents configured
+ * with `endTag: 'never'` are excluded.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
 export default _default;

package/lib/end-tag/index.js

@@ -1,6 +1,13 @@
 import { createRule } from '@markuplint/ml-core';
 import { isVoidElement } from '@markuplint/ml-spec';
 import meta from './meta.js';
+/**
+ * Rule that checks for missing end tags on non-void HTML elements.
+ *
+ * Reports elements that are neither void nor self-closing and have no
+ * closing tag. Omitted elements and elements in documents configured
+ * with `endTag: 'never'` are excluded.
+ */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',
@@ -18,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/end-tag/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for `end-tag`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
 };

package/lib/end-tag/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for `end-tag`: categorized as a style rule. */
 export default {
     category: 'style',
 };

package/lib/heading-levels/index.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Rule that validates heading levels (h1-h6) are not skipped.
+ *
+ * Ensures that heading elements appear in a sequential order without
+ * gaps (e.g., an h4 must not follow an h2 directly without an h3 in between).
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
 export default _default;