@markuplint/rules 4.6.0 → 4.7.0

package/lib/index.d.ts

@@ -16,38 +16,38 @@ declare const rules: {
     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>>;
     readonly 'invalid-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
-        allowAttrs?: (string | {
+        allowAttrs?: Record<string, {
+            enum: [string, ...string[]];
+        } | {
+            pattern: string;
+        } | {
+            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
+        }> | (string | {
             name: string;
-            value: ({
+            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
                 enum: [string, ...string[]];
             } | {
                 pattern: string;
             } | {
                 type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-            }) | import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        })[] | Record<string, {
+            });
+        })[] | undefined;
+        disallowAttrs?: Record<string, {
             enum: [string, ...string[]];
         } | {
             pattern: string;
         } | {
             type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }> | undefined;
-        disallowAttrs?: (string | {
+        }> | (string | {
             name: string;
-            value: ({
+            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
                 enum: [string, ...string[]];
             } | {
                 pattern: string;
             } | {
                 type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-            }) | import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        })[] | Record<string, {
-            enum: [string, ...string[]];
-        } | {
-            pattern: string;
-        } | {
-            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }> | undefined;
+            });
+        })[] | undefined;
         ignoreAttrNamePrefix?: string | string[] | undefined;
         allowToAddPropertiesForPretender?: boolean | undefined;
         attrs?: Record<string, ({

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

@@ -1,4 +1,4 @@
 import type { ChildNode, Options, Result, Specs } from './types.js';
 import type { PermittedContentChoice } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function choice(pattern: ReadonlyDeep<PermittedContentChoice>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function choice(pattern: ReadonlyDeep<PermittedContentChoice>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/choice.js

@@ -4,9 +4,9 @@ import { Collection, modelLog } from './utils.js';
 const indexes = new WeakMap();
 export function choice(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     const choiceLog = cmLog.extend(`choice#${depth}`);
-    const collection = new Collection(elements);
+    const collection = new Collection(childNodes);
     const unmatchedResults = [];
     let i = 0;
     for (const some of pattern.choice) {

package/lib/permitted-contents/complex-branch.d.ts

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check content condition
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function complexBranch(pattern: ReadonlyDeep<PermittedContentPattern>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function complexBranch(pattern: ReadonlyDeep<PermittedContentPattern>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/complex-branch.js

@@ -6,7 +6,7 @@ import { isChoice, isTransparent } from './utils.js';
  * Check content condition
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,12 +14,12 @@ import { isChoice, isTransparent } from './utils.js';
  */
 export function complexBranch(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     if (isChoice(pattern)) {
-        return choice(pattern, elements, specs, options, depth);
+        return choice(pattern, childNodes, specs, options, depth);
     }
     if (isTransparent(pattern)) {
-        return transparent(elements);
+        return transparent(childNodes);
     }
-    return countPattern(pattern, elements, specs, options, depth);
+    return countPattern(pattern, childNodes, specs, options, depth);
 }

package/lib/permitted-contents/count-pattern.d.ts

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check count
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

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

@@ -6,7 +6,7 @@ const cLog = cmLog.extend('countCompereResult');
  * Check count
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,9 +14,9 @@ const cLog = cmLog.extend('countCompereResult');
  */
 export function countPattern(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     const ptLog = cmLog.extend(`countPattern#${depth}`);
-    const collection = new Collection(elements);
+    const collection = new Collection(childNodes);
     const { model, min, max, repeat, missingType } = normalizeModel(pattern);
     ptLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(model, repeat), pattern);
     let prevResult = null;

package/lib/permitted-contents/index.js

@@ -7,12 +7,10 @@ export default createRule({
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableChildren: true,
+        evaluateConditionalChildNodes: false,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
-            if (el.rule.options.ignoreHasMutableChildren && el.hasMutableChildren()) {
-                return;
-            }
             const results = contentModel(el, el.rule.value, el.rule.options);
             for (const { type, scope, query, hint } of results) {
                 let message = '';
@@ -28,6 +26,10 @@ export default createRule({
                         break;
                     }
                     case 'MISSING_NODE_ONE_OR_MORE': {
+                        if (scope.rule.options.ignoreHasMutableChildren &&
+                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                            break;
+                        }
                         message =
                             message ||
                                 t('Require {0}', t('one or more elements')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
@@ -38,6 +40,10 @@ export default createRule({
                         break;
                     }
                     case 'MISSING_NODE_REQUIRED': {
+                        if (scope.rule.options.ignoreHasMutableChildren &&
+                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                            break;
+                        }
                         message =
                             message ||
                                 t('Require {0}', t('an {0}', 'element')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';

package/lib/permitted-contents/matches-selector.d.ts

@@ -1,3 +1,3 @@
 import type { ChildNode, Result, Specs } from './types.js';
 export type SelectorResult = Result<'UNMATCHED_SELECTOR_BUT_MAY_EMPTY' | 'MISSING_NODE' | 'UNMATCHED_SELECTORS'>;
-export declare function matchesSelector(query: string, node: ChildNode | undefined, specs: Specs, depth: number): SelectorResult;
+export declare function matchesSelector(query: string, childNode: ChildNode | undefined, specs: Specs, depth: number): SelectorResult;

package/lib/permitted-contents/matches-selector.js

@@ -3,10 +3,10 @@ import { cmLog } from './debug.js';
 import { cleanObject, matches } from './utils.js';
 export function matchesSelector(query, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, specs, depth) {
+childNode, specs, depth) {
     const nodeLog = cmLog.extend(`node#${depth}`);
     const { selector, hasText, hasCustom } = optCondition(query, specs);
-    if (node == null) {
+    if (childNode == null) {
         if (hasText) {
             nodeLog('<#text>.matches(%s) => ""', query);
             return {
@@ -27,23 +27,23 @@ node, specs, depth) {
             hint: {},
         };
     }
-    if (node.is(node.TEXT_NODE)) {
+    if (childNode.is(childNode.TEXT_NODE)) {
         if (hasText) {
-            nodeLog('<#text>.matches(%s) => "%s"', query, node.raw.trim());
+            nodeLog('<#text>.matches(%s) => "%s"', query, childNode.raw.trim());
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: true,
                 query,
                 hint: {},
             };
         }
-        if (node.isWhitespace()) {
+        if (childNode.isWhitespace()) {
             nodeLog('<#text>.matches(%s) => WHITESPACE', query);
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: true,
                 query,
@@ -54,41 +54,41 @@ node, specs, depth) {
         return {
             type: 'UNEXPECTED_EXTRA_NODE',
             matched: [],
-            unmatched: [node],
+            unmatched: [childNode],
             zeroMatch: false,
             query,
             hint: {},
         };
     }
-    if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
-        nodeLog('%s.matches(%s) => PBlock', node.raw, query);
+    if (childNode.is(childNode.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+        nodeLog('%s.matches(%s) => PBlock', childNode.raw, query);
         return {
             type: 'MATCHED',
-            matched: [node],
+            matched: [childNode],
             unmatched: [],
             zeroMatch: !!hasText,
             query,
             hint: {},
         };
     }
-    if (node.is(node.ELEMENT_NODE)) {
-        if (node.elementType !== 'html' && hasCustom) {
-            nodeLog('%s.matches(%s) => CustomElement', node.raw, query);
+    if (childNode.is(childNode.ELEMENT_NODE)) {
+        if (childNode.elementType !== 'html' && hasCustom) {
+            nodeLog('%s.matches(%s) => CustomElement', childNode.raw, query);
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: !!hasText,
                 query,
                 hint: {},
             };
         }
-        const result = matches(selector, node, specs);
-        nodeLog('%s.matches(%s) => %s', node.raw, query, result.matched);
+        const result = matches(selector, childNode, specs);
+        nodeLog('%s.matches(%s) => %s', childNode.raw, query, result.matched);
         if (result.matched) {
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: !!hasText,
                 query,
@@ -99,7 +99,7 @@ node, specs, depth) {
             return {
                 type: 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY',
                 matched: [],
-                unmatched: [node],
+                unmatched: [childNode],
                 zeroMatch: true,
                 query,
                 hint: cleanObject({
@@ -110,7 +110,7 @@ node, specs, depth) {
         return {
             type: 'UNMATCHED_SELECTORS',
             matched: [],
-            unmatched: [node],
+            unmatched: [childNode],
             zeroMatch: false,
             query,
             hint: cleanObject({
@@ -120,7 +120,7 @@ node, specs, depth) {
     }
     return {
         type: 'MATCHED',
-        matched: [node],
+        matched: [childNode],
         unmatched: [],
         zeroMatch: !!hasText,
         query,

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

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check ordered array
  *
  * @param contents
- * @param nodes
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, nodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/order.js

@@ -6,7 +6,7 @@ import { Collection, mergeHints, modelLog } from './utils.js';
  * Check ordered array
  *
  * @param contents
- * @param nodes
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,11 +14,11 @@ import { Collection, mergeHints, modelLog } from './utils.js';
  */
 export function order(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options, depth) {
+childNodes, specs, options, depth) {
     const orderLog = cmLog.extend(`order#${depth}`);
     const btLog = cmLog.extend(`backtrack#${depth}`);
     const patterns = deepCopy(contents);
-    const collection = new Collection(nodes);
+    const collection = new Collection(childNodes);
     orderLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(patterns, ''), patterns);
     orderLog('Starts: %s', collection);
     let result = undefined;

package/lib/permitted-contents/recursive-branch.d.ts

@@ -2,4 +2,4 @@ import type { SelectorResult } from './matches-selector.js';
 import type { ChildNode, Options, Specs } from './types.js';
 import type { PermittedContentPattern, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, nodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;
+export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;

package/lib/permitted-contents/recursive-branch.js

@@ -3,14 +3,14 @@ import { order } from './order.js';
 import { Collection, isModel } from './utils.js';
 export function recursiveBranch(model, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options, depth) {
+childNodes, specs, options, depth) {
     if (!isModel(model)) {
-        return order(model, nodes, specs, options, depth + 1);
+        return order(model, childNodes, specs, options, depth + 1);
     }
     if (typeof model === 'string') {
-        return matchesSelector(model, nodes[0], specs, depth);
+        return matchesSelector(model, childNodes[0], specs, depth);
     }
-    const collection = new Collection(nodes);
+    const collection = new Collection(childNodes);
     let lastUnmatched = null;
     for (const query of model) {
         const result = matchesSelector(query, collection.unmatched[0], specs, depth);

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

@@ -1,6 +1,8 @@
 import type { ChildNode, Options, Result, Specs } from './types.js';
 export declare const transparentMode: Map<ChildNode, true>;
-export declare function representTransparentNodes(nodes: ChildNode[], specs: Specs, options: Options): {
+type TransparentNode = {
     nodes: ChildNode[];
     errors: Result[];
 };
+export declare function representTransparentNodes(childNodes: readonly ChildNode[], specs: Specs, options: Options): TransparentNode[];
+export {};

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

@@ -1,73 +1,94 @@
 import { getContentModel } from '@markuplint/ml-spec';
+import { branchesToPatterns } from '@markuplint/shared';
 import { order } from './order.js';
-import { Collection, getChildNodesWithoutWhitespaces, isTransparent, matches } from './utils.js';
+import { Collection, isTransparent, matches } from './utils.js';
 export const transparentMode = new Map();
 export function representTransparentNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options) {
-    const result = [];
-    const errors = [];
-    const parent = nodes[0]?.parentElement;
-    if (parent) {
-        const { errors: parentErrors } = representTransparentNodes([parent], specs, options);
-        errors.push(...parentErrors);
-    }
-    for (const node of nodes) {
-        if (!node.is(node.ELEMENT_NODE)) {
-            result.push(node);
+childNodes, specs, options) {
+    const parentElement = childNodes[0]?.parentElement;
+    const parentResults = parentElement
+        ? representTransparentNodes([parentElement], specs, options)
+        : [{ nodes: [], errors: [] }];
+    const branches = [];
+    for (const childNode of childNodes) {
+        if (!childNode.is(childNode.ELEMENT_NODE)) {
+            branches.push(childNode);
             continue;
         }
-        const models = getContentModel(node, specs.specs);
+        const models = getContentModel(childNode, specs.specs);
         if (models == null || typeof models === 'boolean') {
-            result.push(node);
+            branches.push(childNode);
             continue;
         }
         const noTransparentModels = models.filter(m => !isTransparent(m));
         if (noTransparentModels.length === models.length) {
-            result.push(node);
+            branches.push(childNode);
             continue;
         }
-        const collection = new Collection(getChildNodesWithoutWhitespaces(node));
-        let unmatched;
-        if (noTransparentModels.length > 0) {
-            const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
-            unmatched = result.unmatched;
-        }
-        else {
-            unmatched = collection.unmatched;
-        }
-        const transparent = models.find(m => isTransparent(m));
-        if (!transparent || !isTransparent(transparent)) {
-            throw new Error('Unreachable code');
-        }
-        for (const _child of unmatched) {
-            const child = _child;
-            if (transparentMode.has(child)) {
-                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]);
+            let unmatched;
+            if (noTransparentModels.length > 0) {
+                const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
+                unmatched = result.unmatched;
             }
-            transparentMode.set(child, true);
-            if (child.is(child.ELEMENT_NODE)) {
-                const transparentCondMatched = matches(transparent.transparent, child, specs);
-                if (!transparentCondMatched.matched) {
-                    errors.push({
-                        type: 'TRANSPARENT_MODEL_DISALLOWS',
-                        matched: [],
-                        unmatched: [node],
-                        zeroMatch: false,
-                        query: transparent.transparent,
-                        hint: {
-                            not: transparentCondMatched.not,
-                            transparent: node,
-                        },
-                    });
+            else {
+                unmatched = collection.unmatched;
+            }
+            const transparent = models.find(m => isTransparent(m));
+            if (!transparent || !isTransparent(transparent)) {
+                throw new Error('Unreachable code');
+            }
+            for (const _child of unmatched) {
+                const child = _child;
+                if (transparentMode.has(child)) {
                     continue;
                 }
+                transparentMode.set(child, true);
+                if (child.is(child.ELEMENT_NODE)) {
+                    const transparentCondMatched = matches(transparent.transparent, child, specs);
+                    if (!transparentCondMatched.matched) {
+                        representPattern.push({
+                            type: 'TRANSPARENT_MODEL_DISALLOWS',
+                            matched: [],
+                            unmatched: [childNode],
+                            zeroMatch: false,
+                            query: transparent.transparent,
+                            hint: {
+                                not: transparentCondMatched.not,
+                                transparent: childNode,
+                            },
+                        });
+                        continue;
+                    }
+                }
+                representPattern.push(child);
             }
-            result.push(child);
         }
+        branches.push(representPattern);
     }
-    return {
-        nodes: result,
-        errors,
-    };
+    const patterns = branchesToPatterns(branches);
+    const result = parentResults.flatMap(parentResult => {
+        const patternResults = patterns.map(pattern => {
+            const nodes = pattern.filter((node) => 'nodeName' in node);
+            const errors = pattern.filter((node) => 'type' in node);
+            return {
+                nodes,
+                errors: [...parentResult.errors, ...errors],
+            };
+        });
+        if (patternResults.length === 0) {
+            return {
+                nodes: [],
+                errors: parentResult.errors,
+            };
+        }
+        return patternResults;
+    });
+    return result;
 }

package/lib/permitted-contents/start.js

@@ -1,6 +1,5 @@
 import { order } from './order.js';
 import { representTransparentNodes } from './represent-transparent-nodes.js';
-import { getChildNodesWithoutWhitespaces } from './utils.js';
 /**
  * Check start
  *
@@ -13,53 +12,60 @@ import { getChildNodesWithoutWhitespaces } from './utils.js';
 export function start(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, specs, options) {
-    if (contents === false) {
-        if (el.childNodes.length > 0) {
+    const childNodesPatterns = options.evaluateConditionalChildNodes
+        ? el.conditionalChildNodes().map(childNodes => [...childNodes])
+        : [[...el.childNodes].filter(child => !(child.is(child.TEXT_NODE) && child.isWhitespace()))];
+    return childNodesPatterns.flatMap(childNodes => {
+        if (contents === false) {
+            if (childNodes.length > 0) {
+                return [
+                    {
+                        type: 'NOTHING',
+                        scope: el,
+                        query: ':not(*)',
+                        hint: {},
+                    },
+                ];
+            }
             return [
                 {
-                    type: 'NOTHING',
+                    type: 'MATCHED',
                     scope: el,
-                    query: ':not(*)',
+                    query: '*',
                     hint: {},
                 },
             ];
         }
-        return [
-            {
-                type: 'MATCHED',
-                scope: el,
-                query: '*',
-                hint: {},
-            },
-        ];
-    }
-    if (contents === true) {
-        // Allows all elements
-        return [
-            {
-                type: 'MATCHED',
-                scope: el,
-                query: '*',
-                hint: {},
-            },
-        ];
-    }
-    const { nodes, errors } = representTransparentNodes(getChildNodesWithoutWhitespaces(el), specs, options);
-    const result = order(contents, nodes, specs, options, 0);
-    return [
-        {
-            type: result.type,
-            scope: result.type === 'MISSING_NODE_REQUIRED' || result.type === 'MISSING_NODE_ONE_OR_MORE'
-                ? el
-                : result.unmatched[0] ?? el,
-            query: result.query,
-            hint: result.hint,
-        },
-        ...errors.map(error => ({
-            type: error.type,
-            scope: error.unmatched[0] ?? el,
-            query: error.query,
-            hint: error.hint,
-        })),
-    ];
+        if (contents === true) {
+            // Allows all elements
+            return [
+                {
+                    type: 'MATCHED',
+                    scope: el,
+                    query: '*',
+                    hint: {},
+                },
+            ];
+        }
+        const patterns = representTransparentNodes(childNodes, specs, options);
+        return patterns.flatMap(({ nodes, errors }) => {
+            const result = order(contents, nodes, specs, options, 0);
+            return [
+                {
+                    type: result.type,
+                    scope: result.type === 'MISSING_NODE_REQUIRED' || result.type === 'MISSING_NODE_ONE_OR_MORE'
+                        ? el
+                        : result.unmatched[0] ?? el,
+                    query: result.query,
+                    hint: result.hint,
+                },
+                ...errors.map(error => ({
+                    type: error.type,
+                    scope: error.unmatched[0] ?? el,
+                    query: error.query,
+                    hint: error.hint,
+                })),
+            ];
+        });
+    });
 }

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

@@ -1,2 +1,2 @@
 import type { ChildNode, Result } from './types.js';
-export declare function transparent(nodes: readonly ChildNode[]): Result;
+export declare function transparent(childNodes: readonly ChildNode[]): Result;

package/lib/permitted-contents/transparent.js

@@ -2,14 +2,14 @@ import { cmLog } from './debug.js';
 const transparentLog = cmLog.extend('transparent');
 export function transparent(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes) {
-    if (nodes.length === 0 || nodes[0]?.parentElement?.parentElement) {
+childNodes) {
+    if (childNodes.length === 0 || childNodes[0]?.parentElement?.parentElement) {
         transparentLog('Skipped');
         return {
-            type: nodes.length === 0 ? 'MATCHED_ZERO' : 'MATCHED',
-            matched: [...nodes],
+            type: childNodes.length === 0 ? 'MATCHED_ZERO' : 'MATCHED',
+            matched: [...childNodes],
             unmatched: [],
-            zeroMatch: nodes.length === 0,
+            zeroMatch: childNodes.length === 0,
             query: 'transparent',
             hint: {},
         };
@@ -17,7 +17,7 @@ nodes) {
     transparentLog('Transparent model element is component root');
     return {
         type: 'MATCHED',
-        matched: [...nodes],
+        matched: [...childNodes],
         unmatched: [],
         zeroMatch: false,
         query: 'transparent',

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

@@ -49,4 +49,8 @@ export type TagRule = {
 } & ReadonlyDeep<ContentModel>;
 export type Options = {
     readonly ignoreHasMutableChildren: boolean;
+    /**
+     * @experimental
+     */
+    readonly evaluateConditionalChildNodes: boolean;
 };

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

@@ -1,7 +1,6 @@
-import type { ChildNode, Element, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
+import type { ChildNode, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
 import type { PermittedContentPattern, PermittedContentChoice, PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentTransparent, PermittedContentZeroOrMore, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function getChildNodesWithoutWhitespaces(el: Element): ChildNode[];
 export declare function isModel(model: ReadonlyDeep<Model | PermittedContentPattern[]>): model is ReadonlyDeep<Model>;
 export declare function matches(selector: string, node: ChildNode, specs: Specs): {
     matched: boolean;
@@ -30,7 +29,7 @@ export declare function mergeHints(a: Readonly<Hints>, b: Readonly<Hints>): Part
     }> | undefined;
     max?: number | undefined;
     not?: ChildNode | undefined;
-    transparent?: Element | undefined;
+    transparent?: import("./types.js").Element | undefined;
 }>;
 export declare function cleanObject<T extends Object>(object: T): Partial<T>;
 export declare class Collection {

package/lib/permitted-contents/utils.js

@@ -13,20 +13,6 @@ var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_orig
 import { createSelector } from '@markuplint/selector';
 import { bgGreen, green, bgRed, bgBlue, blue, bgMagenta, cyan } from './debug.js';
 import { transparentMode } from './represent-transparent-nodes.js';
-const getChildNodesWithoutWhitespacesCaches = new Map();
-export function getChildNodesWithoutWhitespaces(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el) {
-    let nodes = getChildNodesWithoutWhitespacesCaches.get(el);
-    if (nodes) {
-        return nodes;
-    }
-    nodes = [...el.childNodes].filter(node => {
-        return !(node.is(node.TEXT_NODE) && node.isWhitespace());
-    });
-    getChildNodesWithoutWhitespacesCaches.set(el, nodes);
-    return nodes;
-}
 export function isModel(model) {
     if (typeof model === 'string') {
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "4.6.0",
+	"version": "4.7.0",
 	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -25,18 +25,18 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "4.6.0",
-		"@markuplint/ml-core": "4.6.0",
-		"@markuplint/ml-spec": "4.4.0",
-		"@markuplint/selector": "4.5.0",
-		"@markuplint/shared": "4.2.0",
-		"@markuplint/types": "4.3.0",
+		"@markuplint/html-spec": "4.7.0",
+		"@markuplint/ml-core": "4.7.0",
+		"@markuplint/ml-spec": "4.5.0",
+		"@markuplint/selector": "4.6.0",
+		"@markuplint/shared": "4.3.0",
+		"@markuplint/types": "4.4.0",
 		"@types/debug": "4.1.12",
 		"@ungap/structured-clone": "1.2.0",
 		"ansi-colors": "4.1.3",
 		"chrono-node": "2.7.5",
 		"debug": "4.3.4",
-		"type-fest": "4.15.0"
+		"type-fest": "4.18.1"
 	},
-	"gitHead": "d5c8786b0dbbd82cdd89018dd57941d62bbe8d06"
+	"gitHead": "b8d7bae9bdcdad63ff79abe21b88be12abde3633"
 }