@markuplint/rules 4.12.0 → 5.0.0-alpha.0

package/lib/no-unsupported-features/index.js

@@ -0,0 +1,139 @@
+import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { checkAttributeSupport, checkElementSupport } from './compat-data.js';
+import meta from './meta.js';
+import { clearBrowserslistCache, resolveTargetBrowsers } from './resolve-browsers.js';
+/**
+ * Rule that warns when using HTML elements or attributes that are not
+ * supported by the project's target browsers (via browserslist),
+ * or that are experimental/non-standard.
+ */
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {
+        checkExperimental: false,
+        checkNonStandard: false,
+    },
+    async verify({ document, report, t }) {
+        const options = document.rule.options;
+        const targetBrowsers = resolveTargetBrowsers(document.filename, {
+            browserslist: options.browserslist,
+            browserslistConfig: options.browserslistConfig,
+            browserslistEnv: options.browserslistEnv,
+        });
+        const hasTargetBrowsers = targetBrowsers != null && targetBrowsers.length > 0;
+        const checkExperimental = options.checkExperimental ?? false;
+        const checkNonStandard = options.checkNonStandard ?? false;
+        // If no browserslist config and no experimental/nonStandard check, rule is no-op
+        if (!hasTargetBrowsers && !checkExperimental && !checkNonStandard) {
+            return;
+        }
+        const ignoreFeatures = new Set(options.ignoreFeatures);
+        await document.walkOn('Element', async (el) => {
+            // Only check HTML elements
+            if (el.namespaceURI !== 'http://www.w3.org/1999/xhtml' || el.elementType !== 'html') {
+                return;
+            }
+            const elName = el.localName;
+            const elOptions = el.rule.options;
+            const elIgnoreFeatures = new Set(elOptions.ignoreFeatures ?? ignoreFeatures);
+            // Check element itself
+            if (!elIgnoreFeatures.has(elName)) {
+                // Experimental check (spec-based, no BCD needed)
+                if (elOptions.checkExperimental ?? checkExperimental) {
+                    const spec = getSpec(el, document.specs.specs);
+                    if (spec?.experimental) {
+                        report({
+                            scope: el,
+                            message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'experimental'),
+                        });
+                    }
+                }
+                // NonStandard check (spec-based, no BCD needed)
+                if (elOptions.checkNonStandard ?? checkNonStandard) {
+                    const spec = getSpec(el, document.specs.specs);
+                    if (spec?.nonStandard) {
+                        report({
+                            scope: el,
+                            message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'non-standard'),
+                        });
+                    }
+                }
+                // Browser support check (BCD-based)
+                if (hasTargetBrowsers) {
+                    const unsupported = await checkElementSupport(elName, targetBrowsers);
+                    if (unsupported.length > 0) {
+                        report({
+                            scope: el,
+                            message: formatUnsupportedMessage(t, elName, 'element', unsupported),
+                        });
+                    }
+                }
+            }
+            // Check attributes
+            const attrSpecs = getAttrSpecs(el, document.specs);
+            for (const attr of el.attributes) {
+                if (attr.isDirective) {
+                    continue;
+                }
+                const attrName = attr.name;
+                const ignoreKey = `${elName}[${attrName}]`;
+                if (elIgnoreFeatures.has(ignoreKey)) {
+                    continue;
+                }
+                const attrSpec = attrSpecs?.find(s => s.name === attrName);
+                // Experimental attribute check
+                if ((elOptions.checkExperimental ?? checkExperimental) && attrSpec?.experimental) {
+                    report({
+                        scope: attr,
+                        line: attr.nameNode?.startLine,
+                        col: attr.nameNode?.startCol,
+                        raw: attr.nameNode?.raw,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'experimental'),
+                    });
+                }
+                // NonStandard attribute check
+                if ((elOptions.checkNonStandard ?? checkNonStandard) && attrSpec?.nonStandard) {
+                    report({
+                        scope: attr,
+                        line: attr.nameNode?.startLine,
+                        col: attr.nameNode?.startCol,
+                        raw: attr.nameNode?.raw,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'non-standard'),
+                    });
+                }
+                // Browser support attribute check
+                if (hasTargetBrowsers) {
+                    const unsupported = await checkAttributeSupport(elName, attrName, targetBrowsers);
+                    if (unsupported.length > 0) {
+                        report({
+                            scope: attr,
+                            line: attr.nameNode?.startLine,
+                            col: attr.nameNode?.startCol,
+                            raw: attr.nameNode?.raw,
+                            message: formatUnsupportedMessage(t, attrName, 'attribute', unsupported),
+                        });
+                    }
+                }
+            }
+        });
+        clearBrowserslistCache();
+    },
+});
+/**
+ * Format an unsupported feature message listing affected browsers.
+ */
+function formatUnsupportedMessage(t, featureName, featureType, unsupported) {
+    const browserDetails = unsupported
+        .map(u => {
+        if (u.addedVersion === false) {
+            if (u.removedVersion) {
+                return `${u.displayName} (removed in ${u.removedVersion})`;
+            }
+            return `${u.displayName} (not supported)`;
+        }
+        return `${u.displayName} (added in ${u.addedVersion}, target: ${u.targetVersion})`;
+    })
+        .join(', ');
+    return t('{0} is not supported in {1}', t('the "{0*}" {1}', featureName, featureType), browserDetails);
+}

package/lib/no-unsupported-features/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for `no-unsupported-features`: categorized as a validation rule. */
+declare const _default: {
+    readonly category: "validation";
+};
+export default _default;

package/lib/no-unsupported-features/meta.js

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

package/lib/no-unsupported-features/resolve-browsers.d.ts

@@ -0,0 +1,30 @@
+import type { TargetBrowser } from './compat-data.js';
+/**
+ * Options for resolving target browsers.
+ */
+export interface BrowserslistOptions {
+    readonly browserslist?: string | readonly string[];
+    readonly browserslistConfig?: string;
+    readonly browserslistEnv?: string;
+}
+/**
+ * Resolve target browsers from browserslist configuration.
+ *
+ * Priority:
+ * 1. `options.browserslist` (explicit query)
+ * 2. `options.browserslistConfig` (explicit config file path)
+ * 3. Auto-detect from `filename` path
+ *
+ * When no configuration is found, returns null (rule becomes no-op).
+ * For duplicate browsers, the minimum version is kept.
+ *
+ * @param filename - The document filename for auto-detection
+ * @param options - Browserslist resolution options
+ * @returns Array of target browsers, or null if no config found
+ */
+export declare function resolveTargetBrowsers(filename: string | undefined, options: BrowserslistOptions): readonly TargetBrowser[] | null;
+/**
+ * Clear the internal browserslist config cache.
+ * Useful for testing.
+ */
+export declare function clearBrowserslistCache(): void;

package/lib/no-unsupported-features/resolve-browsers.js

@@ -0,0 +1,125 @@
+import browserslist from 'browserslist';
+import { isVersionSatisfied, parseVersion, toBcdBrowserId } from './compat-data.js';
+/**
+ * Display names for BCD browser identifiers.
+ */
+const BROWSER_DISPLAY_NAMES = new Map([
+    ['chrome', 'Chrome'],
+    ['chrome_android', 'Chrome Android'],
+    ['edge', 'Edge'],
+    ['firefox', 'Firefox'],
+    ['firefox_android', 'Firefox Android'],
+    ['ie', 'Internet Explorer'],
+    ['opera', 'Opera'],
+    ['opera_android', 'Opera Android'],
+    ['safari', 'Safari'],
+    ['safari_ios', 'Safari iOS'],
+    ['samsunginternet_android', 'Samsung Internet'],
+    ['webview_android', 'WebView Android'],
+]);
+const configCache = new Map();
+/**
+ * Resolve target browsers from browserslist configuration.
+ *
+ * Priority:
+ * 1. `options.browserslist` (explicit query)
+ * 2. `options.browserslistConfig` (explicit config file path)
+ * 3. Auto-detect from `filename` path
+ *
+ * When no configuration is found, returns null (rule becomes no-op).
+ * For duplicate browsers, the minimum version is kept.
+ *
+ * @param filename - The document filename for auto-detection
+ * @param options - Browserslist resolution options
+ * @returns Array of target browsers, or null if no config found
+ */
+export function resolveTargetBrowsers(filename, options) {
+    if (options.browserslist != null) {
+        const queries = Array.isArray(options.browserslist) ? options.browserslist : [options.browserslist];
+        const cacheKey = `query:${queries.join(',')}`;
+        if (configCache.has(cacheKey)) {
+            return configCache.get(cacheKey) ?? null;
+        }
+        const result = parseBrowsersList(browserslist(queries));
+        configCache.set(cacheKey, result);
+        return result;
+    }
+    const configPath = options.browserslistConfig ?? filename;
+    if (!configPath) {
+        return null;
+    }
+    const env = options.browserslistEnv;
+    const cacheKey = `path:${configPath}:${env ?? ''}`;
+    if (configCache.has(cacheKey)) {
+        return configCache.get(cacheKey) ?? null;
+    }
+    const config = browserslist.loadConfig({
+        path: configPath,
+        env,
+        ...(options.browserslistConfig ? { config: options.browserslistConfig } : {}),
+    });
+    if (!config) {
+        configCache.set(cacheKey, null);
+        return null;
+    }
+    const result = parseBrowsersList(browserslist(config));
+    configCache.set(cacheKey, result);
+    return result;
+}
+/**
+ * Parse browserslist output into TargetBrowser array.
+ *
+ * For duplicate browsers, keeps the minimum version to ensure
+ * compatibility with the widest range of target browsers.
+ */
+function parseBrowsersList(browsers) {
+    const browserMap = new Map();
+    for (const entry of browsers) {
+        const parts = entry.split(' ');
+        if (parts.length < 2) {
+            continue;
+        }
+        const [name, rawVersion] = parts;
+        if (!name || !rawVersion) {
+            continue;
+        }
+        // Handle hyphenated version ranges (e.g., "16.3-16.4") by taking the minimum
+        const version = rawVersion.includes('-') ? rawVersion.split('-')[0] : rawVersion;
+        const bcdId = toBcdBrowserId(name);
+        if (!bcdId) {
+            continue;
+        }
+        const existing = browserMap.get(bcdId);
+        const displayName = BROWSER_DISPLAY_NAMES.get(bcdId) ?? name;
+        if (existing) {
+            // Keep minimum version — treat "preview" (NaN) as the highest possible version
+            const [newMajor] = parseVersion(version);
+            if (!Number.isNaN(newMajor)) {
+                // New version is concrete — replace if existing is "preview" or new < existing
+                const [existingMajor] = parseVersion(existing.version);
+                if (Number.isNaN(existingMajor) || !isVersionSatisfied(version, existing.version)) {
+                    browserMap.set(bcdId, { version, displayName });
+                }
+            }
+            // If new version is "preview", never replace (preview is the highest)
+        }
+        else {
+            browserMap.set(bcdId, { version, displayName });
+        }
+    }
+    if (browserMap.size === 0) {
+        return null;
+    }
+    const result = [];
+    for (const [browser, { version, displayName }] of browserMap) {
+        result.push({ browser, version, displayName });
+    }
+    return result;
+}
+/**
+ * Clear the internal browserslist config cache.
+ * Useful for testing.
+ */
+export function clearBrowserslistCache() {
+    configCache.clear();
+}

package/lib/permitted-contents/choice.js

@@ -51,7 +51,7 @@ childNodes, specs, options, depth) {
         indexes.set(result, i);
         i++;
     }
-    const barelyMatchedResult = unmatchedResults.sort((a, b) => {
+    const barelyMatchedResult = unmatchedResults.toSorted((a, b) => {
         if (a.type !== b.type) {
             if (a.type === 'UNEXPECTED_EXTRA_NODE') {
                 return -1;

package/lib/permitted-contents/count-pattern.js

@@ -167,6 +167,6 @@ b) {
     if (a.type === 'MATCHED' || a.type === 'MATCHED_ZERO' || a.type === 'UNEXPECTED_EXTRA_NODE') {
         return a;
     }
-    const result = [a, b].sort((a, b) => (b.hint.missing?.barelyMatchedElements ?? 0) - (a.hint.missing?.barelyMatchedElements ?? 0))[0] ?? a;
+    const result = [a, b].toSorted((a, b) => (b.hint.missing?.barelyMatchedElements ?? 0) - (a.hint.missing?.barelyMatchedElements ?? 0))[0] ?? a;
     return result;
 }

package/lib/permitted-contents/order.js

@@ -44,7 +44,7 @@ childNodes, specs, options, depth) {
                 afterBacktrack = true;
                 continue;
             }
-            const barelyMatchedResult = unmatchedResults.sort((a, b) => b.matched.length - a.matched.length)[0];
+            const barelyMatchedResult = unmatchedResults.toSorted((a, b) => b.matched.length - a.matched.length)[0];
             if (!barelyMatchedResult) {
                 throw new Error('Unreachable code');
             }

package/lib/permitted-contents/represent-transparent-nodes.d.ts

@@ -26,12 +26,37 @@ type TransparentNode = {
  * 3. Replaces the transparent element with its remaining (unmatched) children.
  * 4. Validates that each remaining child satisfies the transparent model's condition selector.
  * 5. Recursively resolves parent-level transparent nodes to propagate errors up the tree.
- * 6. Uses `branchesToPatterns` to handle branching when multiple resolutions are possible.
+ * 6. Builds patterns incrementally, capping cross-products to avoid exponential blowup.
+ *
+ * ### Algorithm — incremental pattern building
+ *
+ * Patterns are built incrementally as each child node is visited:
+ *
+ * - **Non-transparent child**: appended to every existing pattern.
+ *   Pattern count stays the same.
+ * - **Single-branch transparent child** (non-conditional, or
+ *   `evaluateConditionalChildNodes` disabled): all unmatched children
+ *   are spread into every pattern. Pattern count stays the same.
+ * - **Multi-branch transparent child** (conditional, e.g. `v-if`/`v-else`):
+ *   a cross-product of existing patterns × branch groups is computed,
+ *   capped at {@link MAX_PATTERNS}. If the cap would be exceeded, a
+ *   conservative fallback merges all branch children into every pattern.
+ *
+ * ### Complexity
+ *
+ * - **Previous algorithm** (`branchesToPatterns` Cartesian product):
+ *   O(K^N) time and space, where N = number of transparent elements,
+ *   K = average branch count per element. 12 elements with 2 children
+ *   each produced 4096 patterns and took 30+ seconds.
+ * - **Current algorithm**: O(N × K × min(|patterns|, MAX_PATTERNS))
+ *   time; O(MAX_PATTERNS × P) space where P = average pattern length.
+ *   The same 12-element case now produces 1 pattern in <100 ms.
  *
  * @param childNodes - The child nodes of the element being validated, some of which may be transparent.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @returns An array of possible transparent node resolutions, each with flattened nodes and accumulated errors.
+ * @see https://github.com/markuplint/markuplint/issues/3249
  */
 export declare function representTransparentNodes(childNodes: readonly ChildNode[], specs: Specs, options: Options): TransparentNode[];
 export {};

package/lib/permitted-contents/represent-transparent-nodes.js

@@ -1,5 +1,4 @@
 import { getContentModel } from '@markuplint/ml-spec';
-import { branchesToPatterns } from '@markuplint/shared';
 import { order } from './order.js';
 import { Collection, isTransparent, matches } from './utils.js';
 /**
@@ -8,6 +7,35 @@ import { Collection, isTransparent, matches } from './utils.js';
  * to enable special handling in error messages and debug output.
  */
 export const transparentMode = new Map();
+/**
+ * Maximum number of patterns to generate before falling back to a
+ * conservative all-children-merged approach. Prevents exponential
+ * blowup when many conditional transparent elements are siblings.
+ *
+ * ### Rationale
+ *
+ * When N transparent elements each have K conditional branches (e.g.,
+ * `v-if`/`v-else`), the exact cross-product yields K^N patterns.
+ * With K=2 and N=10, this is 2^10 = 1024 — still manageable.
+ * At N=11 (2^11 = 2048) the cap triggers, switching to a
+ * conservative fallback that merges all branch children into every
+ * pattern. This keeps runtime linear while covering most real-world
+ * conditional structures.
+ *
+ * ### Fallback precision
+ *
+ * When the cap is exceeded, the fallback produces an
+ * **over-approximation**: all children from all branches are included
+ * in every pattern. This may cause false negatives (valid violations
+ * go undetected because the merged pattern appears to satisfy the
+ * content model) but will never cause false positives (spurious
+ * violations are not introduced). In practice, HTML documents rarely
+ * exceed 10 conditional transparent siblings, so the cap is
+ * transparent to most users.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/3249
+ */
+const MAX_PATTERNS = 1024;
 /**
  * Resolves transparent content model elements by replacing them with their
  * children for validation purposes. In HTML, elements like `<a>`, `<ins>`, and `<del>`
@@ -20,12 +48,37 @@ export const transparentMode = new Map();
  * 3. Replaces the transparent element with its remaining (unmatched) children.
  * 4. Validates that each remaining child satisfies the transparent model's condition selector.
  * 5. Recursively resolves parent-level transparent nodes to propagate errors up the tree.
- * 6. Uses `branchesToPatterns` to handle branching when multiple resolutions are possible.
+ * 6. Builds patterns incrementally, capping cross-products to avoid exponential blowup.
+ *
+ * ### Algorithm — incremental pattern building
+ *
+ * Patterns are built incrementally as each child node is visited:
+ *
+ * - **Non-transparent child**: appended to every existing pattern.
+ *   Pattern count stays the same.
+ * - **Single-branch transparent child** (non-conditional, or
+ *   `evaluateConditionalChildNodes` disabled): all unmatched children
+ *   are spread into every pattern. Pattern count stays the same.
+ * - **Multi-branch transparent child** (conditional, e.g. `v-if`/`v-else`):
+ *   a cross-product of existing patterns × branch groups is computed,
+ *   capped at {@link MAX_PATTERNS}. If the cap would be exceeded, a
+ *   conservative fallback merges all branch children into every pattern.
+ *
+ * ### Complexity
+ *
+ * - **Previous algorithm** (`branchesToPatterns` Cartesian product):
+ *   O(K^N) time and space, where N = number of transparent elements,
+ *   K = average branch count per element. 12 elements with 2 children
+ *   each produced 4096 patterns and took 30+ seconds.
+ * - **Current algorithm**: O(N × K × min(|patterns|, MAX_PATTERNS))
+ *   time; O(MAX_PATTERNS × P) space where P = average pattern length.
+ *   The same 12-element case now produces 1 pattern in <100 ms.
  *
  * @param childNodes - The child nodes of the element being validated, some of which may be transparent.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @returns An array of possible transparent node resolutions, each with flattened nodes and accumulated errors.
+ * @see https://github.com/markuplint/markuplint/issues/3249
  */
 export function representTransparentNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -34,28 +87,34 @@ childNodes, specs, options) {
     const parentResults = parentElement
         ? representTransparentNodes([parentElement], specs, options)
         : [{ nodes: [], errors: [] }];
-    const branches = [];
+    let patterns = [[]];
     for (const childNode of childNodes) {
         if (!childNode.is(childNode.ELEMENT_NODE)) {
-            branches.push(childNode);
+            for (const p of patterns) {
+                p.push(childNode);
+            }
             continue;
         }
         const models = getContentModel(childNode, specs.specs);
         if (models == null || typeof models === 'boolean') {
-            branches.push(childNode);
+            for (const p of patterns) {
+                p.push(childNode);
+            }
             continue;
         }
         const noTransparentModels = models.filter(m => !isTransparent(m));
         if (noTransparentModels.length === models.length) {
-            branches.push(childNode);
+            for (const p of patterns) {
+                p.push(childNode);
+            }
             continue;
         }
         const childNodesPatterns = options.evaluateConditionalChildNodes
             ? childNode.conditionalChildNodes().map(childNodes => [...childNodes])
             : [[...childNode.childNodes].filter(child => !(child.is(child.TEXT_NODE) && child.isWhitespace()))];
-        const representPattern = [];
-        for (const childNodes of childNodesPatterns) {
-            const collection = new Collection([...childNodes]);
+        const branchGroups = [];
+        for (const branchChildNodes of childNodesPatterns) {
+            const collection = new Collection([...branchChildNodes]);
             let unmatched;
             if (noTransparentModels.length > 0) {
                 const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
@@ -68,6 +127,7 @@ childNodes, specs, options) {
             if (!transparent || !isTransparent(transparent)) {
                 throw new Error('Unreachable code');
             }
+            const branchChildren = [];
             for (const _child of unmatched) {
                 const child = _child;
                 if (transparentMode.has(child)) {
@@ -77,7 +137,7 @@ childNodes, specs, options) {
                 if (child.is(child.ELEMENT_NODE)) {
                     const transparentCondMatched = matches(transparent.transparent, child, specs);
                     if (!transparentCondMatched.matched) {
-                        representPattern.push({
+                        branchChildren.push({
                             type: 'TRANSPARENT_MODEL_DISALLOWS',
                             matched: [],
                             unmatched: [childNode],
@@ -91,12 +151,35 @@ childNodes, specs, options) {
                         continue;
                     }
                 }
-                representPattern.push(child);
+                branchChildren.push(child);
+            }
+            branchGroups.push(branchChildren);
+        }
+        if (branchGroups.every(g => g.length === 0)) {
+            continue;
+        }
+        if (branchGroups.length === 1) {
+            const singleGroup = branchGroups[0];
+            for (const p of patterns) {
+                p.push(...singleGroup);
+            }
+        }
+        else if (patterns.length * branchGroups.length <= MAX_PATTERNS) {
+            const newPatterns = [];
+            for (const p of patterns) {
+                for (const group of branchGroups) {
+                    newPatterns.push([...p, ...group]);
+                }
+            }
+            patterns = newPatterns;
+        }
+        else {
+            const allChildren = branchGroups.flat();
+            for (const p of patterns) {
+                p.push(...allChildren);
             }
         }
-        branches.push(representPattern);
     }
-    const patterns = branchesToPatterns(branches);
     const result = parentResults.flatMap(parentResult => {
         const patternResults = patterns.map(pattern => {
             const nodes = pattern.filter((node) => 'nodeName' in node);

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

@@ -85,7 +85,7 @@ export declare function isTransparent(content: ReadonlyDeep<PermittedContentPatt
  * @returns An object with `model`, `min`, `max`, `repeat` sign, and optional `missingType`.
  */
 export declare function normalizeModel(pattern: ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentZeroOrMore>): {
-    model: ReadonlyDeep<Model | PermittedContentPattern[]>;
+    model: ReadonlyDeep<PermittedContentPattern[] | Model>;
     min: number;
     max: number;
     repeat: RepeatSign;