@markuplint/rules 5.1.1 → 5.3.0

package/lib/permitted-contents/content-model.js

@@ -81,30 +81,77 @@ export function resolveContentModel(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, rules, specs, mode) {
     if (mode === 'origin' && el.pretenderContext?.type === 'pretender') {
-        const userRule = rules.find(r => r.tag === el.rawName);
-        return userRule?.contents ?? null;
+        const userRule = rules.find(r => hasTagRule(el, r));
+        return userRule ? contentsOfTagRule(el, userRule) : null;
     }
-    return getContentModel(el, specs.specs);
+    const model = getContentModel(el, specs.specs);
+    if (model != null || el.pretenderContext?.type === 'pretender') {
+        return model;
+    }
+    // A rule written for a component under another spelling of its name (`FooBar` for `<foo-bar>`):
+    // the lookup of the spec is by the name as written, which the element does not have.
+    const userRule = rules.find(r => el.matchesTagNameVariant(r.tag));
+    if (!userRule) {
+        return null;
+    }
+    return contentsOfTagRule(el, userRule);
+}
+/**
+ * The contents of a user's tag rule for the element: those of the first `conditional` entry whose
+ * condition the element meets, or else the rule's own, as `getContentModel` of `@markuplint/ml-spec`
+ * reads a spec. It is for the lookups that find the rule without `getContentModel`.
+ *
+ * @param el - The element
+ * @param rule - The user's tag rule written for the element
+ * @returns The contents that apply to the element
+ */
+function contentsOfTagRule(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, rule) {
+    return rule.conditional?.find(({ condition }) => el.matches(condition))?.contents ?? rule.contents;
 }
 /**
- * Cache for merged specs keyed by the JSON-serialized tag rules.
+ * Whether the user's tag rule is written for the element: the name of the rule is the name
+ * the element is written with, or another spelling of it that the document resolves to the
+ * same component (see `MLElement#matchesTagNameVariant`).
+ *
+ * @param el - The element
+ * @param rule - The user's tag rule
+ * @returns Whether the rule is written for the element
+ */
+export function hasTagRule(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, rule) {
+    return rule.tag === el.rawName || el.matchesTagNameVariant(rule.tag);
+}
+/**
+ * Cache for merged specs: for each base spec of a document, keyed by the JSON-serialized tag rules.
  * Avoids re-merging the same set of user-defined tag rules on every element check.
  */
-const caches = new Map();
+const caches = new WeakMap();
 /**
  * Returns a Specs object that merges the base ML spec with user-defined
- * tag rules. Results are cached by the serialized rules to avoid redundant merging.
+ * tag rules. Results are cached by the specs of the document and the serialized rules to avoid redundant
+ * merging: the specs differ by document (the `specs` of the config is by file), so what is merged
+ * for one must not be given to another.
+ *
+ * Exported for the spec of the cache.
  *
  * @param specs - The base ML spec from the document.
  * @param rules - User-defined tag rules to merge.
  * @returns The merged Specs, either from cache or freshly computed.
  */
-function cachedSpecs(specs, rules) {
+export function cachedSpecs(specs, rules) {
     if (rules.length === 0) {
         return specs;
     }
     const key = JSON.stringify(rules);
-    const cached = caches.get(key);
+    let cache = caches.get(specs);
+    if (!cache) {
+        cache = new Map();
+        caches.set(specs, cache);
+    }
+    const cached = cache.get(key);
     if (cached) {
         return cached;
     }
@@ -118,6 +165,6 @@ function cachedSpecs(specs, rules) {
             })),
         ],
     };
-    caches.set(key, merged);
+    cache.set(key, merged);
     return merged;
 }

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

@@ -1,4 +1,4 @@
-import { cmLog } from './debug.js';
+import { cmLog, depthLog } from './debug.js';
 import { recursiveBranch } from './recursive-branch.js';
 import { Collection, mergeHints, modelLog, normalizeModel } from './utils.js';
 const cLog = cmLog.extend('countCompereResult');
@@ -24,21 +24,28 @@ const cLog = cmLog.extend('countCompereResult');
 export function countPattern(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 childNodes, rules, specs, options, depth, mode) {
-    const ptLog = cmLog.extend(`countPattern#${depth}`);
+    const ptLog = depthLog('countPattern', depth);
+    const ptEnabled = ptLog.enabled;
     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);
+    if (ptEnabled) {
+        ptLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(model, repeat), pattern);
+    }
     let prevResult = null;
     let barelyResult = null;
     let loopCount = 0;
     while (true) {
         loopCount++;
-        ptLog('Check#%s: %s', loopCount, collection);
+        if (ptEnabled) {
+            ptLog('Check#%s: %s', loopCount, collection);
+        }
         const result = recursiveBranch(model, collection.unmatched, rules, specs, options, depth, mode);
         const added = collection.addMatched(result.matched);
         const { matchedCount } = collection;
         if (result.type === 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY') {
-            ptLog('MATCHED_ZERO:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', modelLog(model, repeat), max, collection, matchedCount);
+            if (ptEnabled) {
+                ptLog('MATCHED_ZERO:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', modelLog(model, repeat), max, collection, matchedCount);
+            }
             return compereResult({
                 type: 'MATCHED_ZERO',
                 matched: collection.matched,
@@ -50,7 +57,9 @@ childNodes, rules, specs, options, depth, mode) {
         }
         if (max < collection.matchedCount) {
             collection.max(max);
-            ptLog('UNEXPECTED_EXTRA_NODE:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', modelLog(model, repeat), max, collection, matchedCount);
+            if (ptEnabled) {
+                ptLog('UNEXPECTED_EXTRA_NODE:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', modelLog(model, repeat), max, collection, matchedCount);
+            }
             return compereResult({
                 type: 'UNEXPECTED_EXTRA_NODE',
                 matched: collection.matched,
@@ -64,7 +73,9 @@ childNodes, rules, specs, options, depth, mode) {
             if (result.type === 'MISSING_NODE_ONE_OR_MORE' ||
                 result.type === 'MISSING_NODE_REQUIRED' ||
                 result.type === 'TRANSPARENT_MODEL_DISALLOWS') {
-                ptLog('%s(continued): %s; Needs', result.type, collection, result.query);
+                if (ptEnabled) {
+                    ptLog('%s(continued): %s; Needs', result.type, collection, result.query);
+                }
                 return compereResult({
                     type: result.type,
                     matched: collection.matched,
@@ -74,7 +85,9 @@ childNodes, rules, specs, options, depth, mode) {
                     hint: result.hint,
                 }, barelyResult);
             }
-            ptLog('%s(continued): %s', prevResult.type, collection);
+            if (ptEnabled) {
+                ptLog('%s(continued): %s', prevResult.type, collection);
+            }
             return compereResult(prevResult, barelyResult);
         }
         if (added && collection.unmatched.length > 0) {
@@ -88,7 +101,9 @@ childNodes, rules, specs, options, depth, mode) {
                     hint: result.hint,
                 };
             }
-            ptLog('continue⤴️');
+            if (ptEnabled) {
+                ptLog('continue⤴️');
+            }
             continue;
         }
         if (collection.matchedCount + (result.zeroMatch ? 1 : 0) < min) {
@@ -97,7 +112,9 @@ childNodes, rules, specs, options, depth, mode) {
                 result.type === 'TRANSPARENT_MODEL_DISALLOWS'
                 ? result.type
                 : (missingType ?? 'MISSING_NODE_REQUIRED');
-            ptLog('%s(in %s); Needs %s', resultType, missingType, result.query);
+            if (ptEnabled) {
+                ptLog('%s(in %s); Needs %s', resultType, missingType, result.query);
+            }
             return compereResult({
                 type: resultType,
                 matched: collection.matched,
@@ -129,10 +146,14 @@ childNodes, rules, specs, options, depth, mode) {
         };
         if (collection.unmatched.length > 0) {
             prevResult = matchedResult;
-            ptLog('continue⤴️ (add prev)');
+            if (ptEnabled) {
+                ptLog('continue⤴️ (add prev)');
+            }
             continue;
         }
-        ptLog('%s:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', resultType, modelLog(model, repeat), max, collection, matchedCount);
+        if (ptEnabled) {
+            ptLog('%s:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', resultType, modelLog(model, repeat), max, collection, matchedCount);
+        }
         // When min=0 and no elements were consumed, the pattern legitimately
         // matched zero times — don't propagate the inner sequence's failure.
         // This enables zeroOrMore([oneOrMore dt, oneOrMore dd]) to accept
@@ -168,7 +189,9 @@ function compereResult(
 a, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 b) {
-    cLog('current: %s %O\nbarely: %s %O', a.type, a.hint, b?.type, b?.hint);
+    if (cLog.enabled) {
+        cLog('current: %s %O\nbarely: %s %O', a.type, a.hint, b?.type, b?.hint);
+    }
     if (b == null) {
         return a;
     }

package/lib/permitted-contents/debug.browser.d.ts

@@ -5,6 +5,24 @@ import type { Log } from '../debug.js';
  * In the browser environment, color helpers are no-op stubs.
  */
 export declare const cmLog: Log;
+/**
+ * Returns the `cmLog` child logger for `<name>#<depth>`, created once per
+ * name and depth. `debug`'s `extend()` allocates a logger on every call,
+ * which showed up in profiles when it ran per recursion step. Use this instead
+ * of calling `cmLog.extend()` for per-depth names.
+ *
+ * The cache is bounded by the number of distinct name × depth pairs. The returned
+ * logger is shared by every caller, so setting `.enabled` or `.log` on it affects
+ * all of them.
+ *
+ * Keep in sync with `debug.ts`: `package.json` swaps this file in for that one in
+ * the browser build.
+ *
+ * @param name - The logger's base name, e.g. `order`.
+ * @param depth - The recursion depth the logger belongs to.
+ * @returns The shared child logger for `<name>#<depth>`.
+ */
+export declare function depthLog(name: string, depth: number): Log;
 /** No-op color stub for browser environments: green background. */
 export declare const bgGreen: {
     (): void;

package/lib/permitted-contents/debug.browser.js

@@ -5,6 +5,33 @@ import { log } from '../debug.js';
  * In the browser environment, color helpers are no-op stubs.
  */
 export const cmLog = log.extend('content-model');
+const depthLogs = new Map();
+/**
+ * Returns the `cmLog` child logger for `<name>#<depth>`, created once per
+ * name and depth. `debug`'s `extend()` allocates a logger on every call,
+ * which showed up in profiles when it ran per recursion step. Use this instead
+ * of calling `cmLog.extend()` for per-depth names.
+ *
+ * The cache is bounded by the number of distinct name × depth pairs. The returned
+ * logger is shared by every caller, so setting `.enabled` or `.log` on it affects
+ * all of them.
+ *
+ * Keep in sync with `debug.ts`: `package.json` swaps this file in for that one in
+ * the browser build.
+ *
+ * @param name - The logger's base name, e.g. `order`.
+ * @param depth - The recursion depth the logger belongs to.
+ * @returns The shared child logger for `<name>#<depth>`.
+ */
+export function depthLog(name, depth) {
+    const key = `${name}#${depth}`;
+    let logger = depthLogs.get(key);
+    if (!logger) {
+        logger = cmLog.extend(key);
+        depthLogs.set(key, logger);
+    }
+    return logger;
+}
 const fn = () => { };
 fn.bold = () => { };
 /** No-op color stub for browser environments: green background. */

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

@@ -6,6 +6,24 @@ import color from 'ansi-colors';
  * for structured debug output during content model evaluation.
  */
 export declare const cmLog: Log;
+/**
+ * Returns the `cmLog` child logger for `<name>#<depth>`, created once per
+ * name and depth. `debug`'s `extend()` allocates a logger on every call,
+ * which showed up in profiles when it ran per recursion step. Use this instead
+ * of calling `cmLog.extend()` for per-depth names.
+ *
+ * The cache is bounded by the number of distinct name × depth pairs. The returned
+ * logger is shared by every caller, so setting `.enabled` or `.log` on it affects
+ * all of them.
+ *
+ * Keep in sync with `debug.browser.ts`: `package.json` swaps that file in for this
+ * one in the browser build.
+ *
+ * @param name - The logger's base name, e.g. `order`.
+ * @param depth - The recursion depth the logger belongs to.
+ * @returns The shared child logger for `<name>#<depth>`.
+ */
+export declare function depthLog(name: string, depth: number): Log;
 /** ANSI color helper: green background for highlighting locked-and-matched nodes in debug output. */
 export declare const bgGreen: color.StyleFunction;
 /** ANSI color helper: green foreground for highlighting matched nodes in debug output. */

package/lib/permitted-contents/debug.js

@@ -6,6 +6,33 @@ import { log } from '../debug.js';
  * for structured debug output during content model evaluation.
  */
 export const cmLog = log.extend('content-model');
+const depthLogs = new Map();
+/**
+ * Returns the `cmLog` child logger for `<name>#<depth>`, created once per
+ * name and depth. `debug`'s `extend()` allocates a logger on every call,
+ * which showed up in profiles when it ran per recursion step. Use this instead
+ * of calling `cmLog.extend()` for per-depth names.
+ *
+ * The cache is bounded by the number of distinct name × depth pairs. The returned
+ * logger is shared by every caller, so setting `.enabled` or `.log` on it affects
+ * all of them.
+ *
+ * Keep in sync with `debug.browser.ts`: `package.json` swaps that file in for this
+ * one in the browser build.
+ *
+ * @param name - The logger's base name, e.g. `order`.
+ * @param depth - The recursion depth the logger belongs to.
+ * @returns The shared child logger for `<name>#<depth>`.
+ */
+export function depthLog(name, depth) {
+    const key = `${name}#${depth}`;
+    let logger = depthLogs.get(key);
+    if (!logger) {
+        logger = cmLog.extend(key);
+        depthLogs.set(key, logger);
+    }
+    return logger;
+}
 /** ANSI color helper: green background for highlighting locked-and-matched nodes in debug output. */
 export const bgGreen = color.bgGreen;
 /** ANSI color helper: green foreground for highlighting matched nodes in debug output. */

package/lib/permitted-contents/index.js

@@ -1,5 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
-import { contentModel } from './content-model.js';
+import { contentModel, hasTagRule } from './content-model.js';
 import meta from './meta.js';
 import { transparentMode } from './represent-transparent-nodes.js';
 import { getContentOwner, getReportScope, isContentMutable } from './slot-content.js';
@@ -18,7 +18,7 @@ export default createRule({
             // that user-defined custom-tag rules are not silently bypassed by pretending
             // (see issue #3739).
             const modes = ['pretended'];
-            if (el.pretenderContext?.type === 'pretender' && el.rule.value.some(r => r.tag === el.rawName)) {
+            if (el.pretenderContext?.type === 'pretender' && el.rule.value.some(r => hasTagRule(el, r))) {
                 modes.push('origin');
             }
             for (const mode of modes) {

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

@@ -1,5 +1,5 @@
 import { contentModelCategoryToTagNames } from '@markuplint/ml-spec';
-import { cmLog } from './debug.js';
+import { depthLog } from './debug.js';
 import { cleanObject, matches } from './utils.js';
 /**
  * Tests whether a single child node matches a content model query selector.
@@ -18,11 +18,14 @@ import { cleanObject, matches } from './utils.js';
 export function matchesSelector(query, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 childNode, specs, depth, mode) {
-    const nodeLog = cmLog.extend(`node#${depth}`);
+    const nodeLog = depthLog('node', depth);
+    const nodeEnabled = nodeLog.enabled;
     const { selector, hasText, hasNonEmptyText, hasCustom } = optCondition(query, specs);
     if (childNode == null) {
         if (hasText) {
-            nodeLog('<#text>.matches(%s) => ""', query);
+            if (nodeEnabled) {
+                nodeLog('<#text>.matches(%s) => ""', query);
+            }
             return {
                 type: 'MATCHED_ZERO',
                 matched: [],
@@ -45,7 +48,9 @@ childNode, specs, depth, mode) {
     if (childNode.is(childNode.TEXT_NODE)) {
         if (hasNonEmptyText) {
             if (childNode.isWhitespace()) {
-                nodeLog('<#nonEmptyText>.matches(%s) => WHITESPACE (rejected)', query);
+                if (nodeEnabled) {
+                    nodeLog('<#nonEmptyText>.matches(%s) => WHITESPACE (rejected)', query);
+                }
                 return {
                     type: 'MISSING_NODE',
                     matched: [],
@@ -55,7 +60,9 @@ childNode, specs, depth, mode) {
                     hint: {},
                 };
             }
-            nodeLog('<#nonEmptyText>.matches(%s) => "%s"', query, childNode.raw.trim());
+            if (nodeEnabled) {
+                nodeLog('<#nonEmptyText>.matches(%s) => "%s"', query, childNode.raw.trim());
+            }
             return {
                 type: 'MATCHED',
                 matched: [childNode],
@@ -66,7 +73,9 @@ childNode, specs, depth, mode) {
             };
         }
         if (hasText) {
-            nodeLog('<#text>.matches(%s) => "%s"', query, childNode.raw.trim());
+            if (nodeEnabled) {
+                nodeLog('<#text>.matches(%s) => "%s"', query, childNode.raw.trim());
+            }
             return {
                 type: 'MATCHED',
                 matched: [childNode],
@@ -77,7 +86,9 @@ childNode, specs, depth, mode) {
             };
         }
         if (childNode.isWhitespace()) {
-            nodeLog('<#text>.matches(%s) => WHITESPACE', query);
+            if (nodeEnabled) {
+                nodeLog('<#text>.matches(%s) => WHITESPACE', query);
+            }
             return {
                 type: 'MATCHED',
                 matched: [childNode],
@@ -98,7 +109,9 @@ childNode, specs, depth, mode) {
         };
     }
     if (childNode.is(childNode.MARKUPLINT_PREPROCESSOR_BLOCK)) {
-        nodeLog('%s.matches(%s) => PBlock', childNode.raw, query);
+        if (nodeEnabled) {
+            nodeLog('%s.matches(%s) => PBlock', childNode.raw, query);
+        }
         return {
             type: 'MATCHED',
             matched: [childNode],
@@ -110,7 +123,9 @@ childNode, specs, depth, mode) {
     }
     if (childNode.is(childNode.ELEMENT_NODE)) {
         if (hasCustom && isTreatedAsCustom(childNode, mode)) {
-            nodeLog('%s.matches(%s) => CustomElement', childNode.raw, query);
+            if (nodeEnabled) {
+                nodeLog('%s.matches(%s) => CustomElement', childNode.raw, query);
+            }
             return {
                 type: 'MATCHED',
                 matched: [childNode],
@@ -121,7 +136,9 @@ childNode, specs, depth, mode) {
             };
         }
         const result = matches(selector, childNode, specs, mode);
-        nodeLog('%s.matches(%s) => %s', childNode.raw, query, result.matched);
+        if (nodeEnabled) {
+            nodeLog('%s.matches(%s) => %s', childNode.raw, query, result.matched);
+        }
         if (result.matched) {
             return {
                 type: 'MATCHED',
@@ -172,25 +189,30 @@ childNode, specs, depth, mode) {
  * pretended, so a component that stands for `<section>` would still look
  * authored and slip through `<p>`, `<span>` and `<button>`. In `'pretended'`
  * mode such an element is judged by what it stands for instead, exactly as if
- * the user had written that element. The pretender target is always created
- * with `elementType: 'html'`, so a target that is itself a custom element
- * (its name contains a hyphen) is recognised by name.
+ * the user had written that element, and that comes first: a parser that cannot
+ * tell a component from an element (HTML sees `<MyTabs>` as `html`) still gives a
+ * pretender. The pretender target is created with `elementType: 'html'`, so a
+ * target that is itself a custom element (its name contains a hyphen) is
+ * recognised by name. A target that is a component name (`Tabs.Root`, where
+ * the chain of `pretenders.auto` stopped) is `'authored'`, and what that
+ * component renders is not known, so it is accepted like one written directly.
  *
  * In `'origin'` mode the pretender context is suppressed while matching (see
  * {@link matches}) and the element is seen under its authored name, so it stays
  * accepted as a custom element.
+ *
+ * The `'pretended'` criterion is the one `MLElement.isCustomElement` gives a
+ * `:model()` selector; change them together.
  */
 function isTreatedAsCustom(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 element, mode) {
-    if (element.elementType === 'html') {
-        return false;
-    }
     const pretenderContext = element.pretenderContext;
     if (mode === 'pretended' && pretenderContext?.type === 'pretender') {
-        return pretenderContext.as.localName.includes('-');
+        const { as } = pretenderContext;
+        return as.elementType === 'authored' || as.localName.includes('-');
     }
-    return true;
+    return element.elementType !== 'html';
 }
 /**
  * Pre-computed conditions for well-known queries that do not depend on specs.

package/lib/permitted-contents/order.js

@@ -1,6 +1,6 @@
 import { deepCopy } from '../helpers.js';
 import { complexBranch } from './complex-branch.js';
-import { cmLog } from './debug.js';
+import { depthLog } from './debug.js';
 import { Collection, mergeHints, modelLog } from './utils.js';
 /**
  * Validates an ordered sequence of content model patterns against a list of child nodes.
@@ -29,12 +29,16 @@ import { Collection, mergeHints, modelLog } from './utils.js';
 export function order(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 childNodes, rules, specs, options, depth, mode) {
-    const orderLog = cmLog.extend(`order#${depth}`);
-    const btLog = cmLog.extend(`backtrack#${depth}`);
+    const orderLog = depthLog('order', depth);
+    const btLog = depthLog('backtrack', depth);
+    const orderEnabled = orderLog.enabled;
+    const btEnabled = btLog.enabled;
     const patterns = deepCopy(contents);
     const collection = new Collection(childNodes);
-    orderLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(patterns, ''), patterns);
-    orderLog('Starts: %s', collection);
+    if (orderEnabled) {
+        orderLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(patterns, ''), patterns);
+        orderLog('Starts: %s', collection);
+    }
     let result = undefined;
     let backtrackMode = false;
     let afterBacktrack = false;
@@ -46,7 +50,9 @@ childNodes, rules, specs, options, depth, mode) {
             unmatchedResults.push(result);
             if (backtrackMode) {
                 collection.back();
-                btLog('🔙◀BACK');
+                if (btEnabled) {
+                    btLog('🔙◀BACK');
+                }
                 backtrackMode = false;
                 afterBacktrack = true;
                 continue;
@@ -55,9 +61,11 @@ childNodes, rules, specs, options, depth, mode) {
             if (!barelyMatchedResult) {
                 throw new Error('Unreachable code');
             }
-            orderLog('Result (%s): %s%s', result.type, collection.toString(true), barelyMatchedResult.hint.missing?.barelyMatchedElements == null
-                ? ''
-                : `; But ${barelyMatchedResult.hint.missing.barelyMatchedElements} elements hit out of pattern`);
+            if (orderEnabled) {
+                orderLog('Result (%s): %s%s', result.type, collection.toString(true), barelyMatchedResult.hint.missing?.barelyMatchedElements == null
+                    ? ''
+                    : `; But ${barelyMatchedResult.hint.missing.barelyMatchedElements} elements hit out of pattern`);
+            }
             return {
                 type: barelyMatchedResult.type,
                 matched: collection.matched,
@@ -85,7 +93,9 @@ childNodes, rules, specs, options, depth, mode) {
         patterns.shift();
     }
     if (collection.unmatched.length > 0) {
-        orderLog('Result (UNEXPECTED_EXTRA_NODE): %s', collection.toString(true));
+        if (orderEnabled) {
+            orderLog('Result (UNEXPECTED_EXTRA_NODE): %s', collection.toString(true));
+        }
         return {
             type: 'UNEXPECTED_EXTRA_NODE',
             matched: collection.matched,
@@ -96,7 +106,9 @@ childNodes, rules, specs, options, depth, mode) {
         };
     }
     const resultType = collection.matched.length > 0 ? 'MATCHED' : 'MATCHED_ZERO';
-    orderLog('Result (%s): %s', resultType, collection.toString(true));
+    if (orderEnabled) {
+        orderLog('Result (%s): %s', resultType, collection.toString(true));
+    }
     return {
         type: resultType,
         matched: collection.matched,

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

@@ -195,7 +195,9 @@ childNodes, rules, specs, options, mode) {
             // Cap exceeded (#3895): fall back to the conservative
             // over-approximation documented on MAX_PATTERNS. False negatives
             // are possible beyond this point, so leave a debug trace.
-            cmLog('Transparent pattern cap exceeded on <%s> (%d patterns x %d branches > %d): merging all branch children into every pattern; false negatives are possible', childNode.nodeName, patterns.length, branchGroups.length, MAX_PATTERNS);
+            if (cmLog.enabled) {
+                cmLog('Transparent pattern cap exceeded on <%s> (%d patterns x %d branches > %d): merging all branch children into every pattern; false negatives are possible', childNode.nodeName, patterns.length, branchGroups.length, MAX_PATTERNS);
+            }
             const allChildren = branchGroups.flat();
             for (const p of patterns) {
                 p.push(childNode, ...allChildren);

package/lib/permitted-contents/transparent.js

@@ -16,7 +16,9 @@ export function transparent(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 childNodes) {
     if (childNodes.length === 0 || childNodes[0]?.parentElement?.parentElement) {
-        transparentLog('Skipped');
+        if (transparentLog.enabled) {
+            transparentLog('Skipped');
+        }
         return {
             type: childNodes.length === 0 ? 'MATCHED_ZERO' : 'MATCHED',
             matched: [...childNodes],
@@ -26,7 +28,9 @@ childNodes) {
             hint: {},
         };
     }
-    transparentLog('Transparent model element is component root');
+    if (transparentLog.enabled) {
+        transparentLog('Transparent model element is component root');
+    }
     return {
         type: 'MATCHED',
         matched: [...childNodes],

package/lib/placeholder-label-option/index.d.ts

@@ -5,9 +5,9 @@
  * > multiple attribute specified, and has a display size of 1, then the
  * > select element must have a placeholder label option.
  *
- * `hasPlaceholderLabelOption` decides whether an existing option already
- * satisfies the requirement; `needPlaceholderLabelOption` gates whether the
- * requirement applies to this `<select>`.
+ * `needPlaceholderLabelOption` gates whether the requirement applies to this
+ * `<select>`; `hasPlaceholderLabelOption` then decides whether an existing
+ * option already satisfies it.
  *
  * @see https://html.spec.whatwg.org/multipage/form-elements.html#the-select-element
  */