nudge-ui 0.2.5 → 0.2.6

package/dist/inspector/tokens/resolution/ruleMatching.js

@@ -1,6 +1,6 @@
 import { INTERACTION_STATES } from "../../shell/styleState.js";
 import { collectRules as collectCssomRules, documentRevisions as getDocumentRevisions } from "./cssomCollector.js";
-import { computeSpecificity, hasSelectorPseudoClass, isElementSensitiveSelector, canMatchSelectorSubject, selectorPseudoClasses, splitSelectorAtTopLevel, } from "./selectorSemantics.js";
+import { computeSpecificity, hasSelectorPseudoClass, isElementSensitiveSelector, canMatchSelectorSubject, selectorPseudoClasses, selectorSubjectClass, splitSelectorAtTopLevel, } from "./selectorSemantics.js";
 const TRANSIENT_PSEUDO_CLASSES = new Set([
     "hover",
     "active",
@@ -11,10 +11,7 @@ const TRANSIENT_PSEUDO_CLASSES = new Set([
     "target",
 ]);
 const INTERACTION_PSEUDO_CLASSES = new Set(INTERACTION_STATES);
-/**
- * Applies a per-branch selector transform to a selector list, so one stateful
- * branch such as `.b:active` cannot drop a plain sibling branch such as `.a`.
- */
+/** Per-branch transform, so a stateful branch such as `.b:active` cannot drop a plain sibling branch. */
 function transformSelectorBranches(selector, transformBranch) {
     if (!selector.includes(","))
         return transformBranch(selector);
@@ -37,9 +34,7 @@ function branchForState(selector, state) {
         return states.size === 0 ? selector : null;
     if (!states.has(state))
         return states.size === 0 ? selector : null;
-    // CSSOM cannot ask the browser whether a hypothetical pseudo-class matches.
-    // Removing interaction pseudo-classes gives the authored rule a stable
-    // element match for inspection. The real rule remains untouched.
+    // CSSOM cannot test a hypothetical pseudo-class, so strip it for a stable element match; the real rule is untouched.
     let transformed = selector;
     for (let index = pseudoClasses.length - 1; index >= 0; index--) {
         const pseudoClass = pseudoClasses[index];
@@ -48,12 +43,28 @@ function branchForState(selector, state) {
     return transformed;
 }
 function specificityForBranch(rule, branch) {
-    // Single-branch selectors reuse the specificity collected from CSSOM; the
-    // matched branch is the whole selector. Multi-branch selectors need the
-    // matched branch's own weight, so recompute per branch.
+    // Multi-branch selectors need the matched branch's own weight; a single branch reuses the CSSOM specificity.
     return rule.selectorText.includes(",") ? computeSpecificity(branch) : rule.specificity;
 }
 const transformedRulesMemo = new WeakMap();
+// Lists change per revision but selectors rarely do, so transformed selectors are cached by text.
+const TRANSFORMED_SELECTOR_CACHE_MAX = 32_768;
+const transformedSelectorMemo = new Map();
+function transformSelector(selectorText, transform) {
+    let byText = transformedSelectorMemo.get(transform);
+    if (!byText) {
+        byText = new Map();
+        transformedSelectorMemo.set(transform, byText);
+    }
+    const cached = byText.get(selectorText);
+    if (cached !== undefined)
+        return cached;
+    const transformed = transform === "stable" ? stableSelector(selectorText) : selectorForState(selectorText, transform);
+    if (byText.size >= TRANSFORMED_SELECTOR_CACHE_MAX)
+        byText.clear();
+    byText.set(selectorText, transformed);
+    return transformed;
+}
 function rulesForTransform(rules, transform) {
     let byTransform = transformedRulesMemo.get(rules);
     if (!byTransform) {
@@ -67,21 +78,90 @@ function rulesForTransform(rules, transform) {
     if (transform === "live") {
         transformed = rules.map((rule) => ({ rule, selectorText: rule.selectorText }));
     }
-    else if (transform === "stable") {
-        transformed = rules.flatMap((rule) => {
-            const selectorText = stableSelector(rule.selectorText);
-            return selectorText ? [{ rule, selectorText }] : [];
-        });
-    }
     else {
         transformed = rules.flatMap((rule) => {
-            const selectorText = selectorForState(rule.selectorText, transform);
+            const selectorText = transformSelector(rule.selectorText, transform);
             return selectorText ? [{ rule, selectorText }] : [];
         });
     }
     byTransform.set(transform, transformed);
     return transformed;
 }
+const subjectClassIndexMemo = new WeakMap();
+const SUBJECT_CLASS_KEYS_CACHE_MAX = 32_768;
+const subjectClassKeysMemo = new Map();
+/** One required class per branch, or null when some branch requires none. */
+function subjectClassKeys(selectorText) {
+    const cached = subjectClassKeysMemo.get(selectorText);
+    if (cached !== undefined)
+        return cached;
+    const keys = new Set();
+    let indexed = true;
+    for (const branch of splitSelectorAtTopLevel(selectorText, ",")) {
+        const className = selectorSubjectClass(branch.trim());
+        if (className === null) {
+            indexed = false;
+            break;
+        }
+        keys.add(className);
+    }
+    const result = indexed ? [...keys] : null;
+    if (subjectClassKeysMemo.size >= SUBJECT_CLASS_KEYS_CACHE_MAX)
+        subjectClassKeysMemo.clear();
+    subjectClassKeysMemo.set(selectorText, result);
+    return result;
+}
+function subjectClassIndex(entries) {
+    const cached = subjectClassIndexMemo.get(entries);
+    if (cached)
+        return cached;
+    const byClass = new Map();
+    const unindexed = [];
+    entries.forEach((entry, index) => {
+        const keys = subjectClassKeys(entry.selectorText);
+        if (keys === null) {
+            unindexed.push(index);
+            return;
+        }
+        for (const key of keys) {
+            const bucket = byClass.get(key);
+            if (bucket)
+                bucket.push(index);
+            else
+                byClass.set(key, [index]);
+        }
+    });
+    const built = { byClass, unindexed, unindexedEntries: unindexed.map((index) => entries[index]) };
+    subjectClassIndexMemo.set(entries, built);
+    return built;
+}
+/** Entries that can match `el`, in original order; only skips branches `canMatchSelectorSubject` would reject anyway. */
+function candidateEntries(entries, el) {
+    const index = subjectClassIndex(entries);
+    if (el.classList.length === 0 || index.byClass.size === 0)
+        return index.unindexedEntries;
+    let picked = null;
+    for (const className of el.classList) {
+        const bucket = index.byClass.get(className);
+        if (!bucket)
+            continue;
+        picked ??= [...index.unindexed];
+        for (const entryIndex of bucket)
+            picked.push(entryIndex);
+    }
+    if (!picked)
+        return index.unindexedEntries;
+    picked.sort((left, right) => left - right);
+    const candidates = [];
+    let previous = -1;
+    for (const entryIndex of picked) {
+        if (entryIndex === previous)
+            continue;
+        previous = entryIndex;
+        candidates.push(entries[entryIndex]);
+    }
+    return candidates;
+}
 const sourceSiteMatchBucketsMemo = new WeakMap();
 function sourceSiteMatchBuckets(rules, transform) {
     let byTransform = sourceSiteMatchBucketsMemo.get(rules);
@@ -105,24 +185,15 @@ const SOURCE_SITE_CACHE_MAX = 4096;
 let sourceSiteMatchCaches = new WeakMap();
 let sourceSiteMatchCacheEntries = 0;
 const concreteElementMatchCaches = new WeakMap();
-// The all-rules sweep shares the active sweep's revision cache for stable
-// selectors. Element-sensitive selectors stay fresh because browser state can
-// change without a mutation observed by the registry.
 const allMatchesMemo = new WeakMap();
-/** Test-only cache reset. */
 export function resetSourceSiteMatchCache() {
     sourceSiteMatchCaches = new WeakMap();
     sourceSiteMatchCacheEntries = 0;
 }
-/** Test-only cache size. */
 export function sourceSiteMatchCacheSize() {
     return sourceSiteMatchCacheEntries;
 }
-/**
- * Captures selector-relevant state without serializing the whole document.
- * Element and ancestor attributes cover the common source-site selectors while
- * child/sibling-sensitive selectors are handled conservatively below.
- */
+/** Selector-relevant element and ancestor attributes, without serializing the whole document. */
 function sourceSiteContextKey(el) {
     const lineage = [];
     let current = el;
@@ -137,12 +208,7 @@ function sourceSiteContextKey(el) {
     }
     return lineage.join("\u0001");
 }
-/**
- * Source-site identity key for the matched-rule cache. The element's class is
- * part of the key because sibling instances of a source site can carry
- * different classes (for example rows in a large list), which changes which
- * rules match even though their `data-cid`/`data-src` are identical.
- */
+/** `data-cid`/`data-src` are identical across sibling instances, so the class is part of the key. */
 function sourceSiteKey(el, transform) {
     const cid = el.getAttribute("data-cid") ?? "";
     const src = el.getAttribute("data-src") ?? "";
@@ -161,11 +227,7 @@ export function matchRuleForElement(el, entry) {
         specificity: specificityForBranch(entry.rule, branch),
     };
 }
-/**
- * Captures the current match outcome for selectors whose truth can change
- * without a document revision. This keeps the expensive resolved-row cache
- * usable while invalidating it when states such as `checked` actually change.
- */
+/** Match key for selectors whose truth can change without a document revision. */
 function elementSensitiveMatchKey(el, rules, transform, sensitiveMatchesByElement) {
     const entries = sourceSiteMatchBuckets(rules, transform).elementSensitive;
     if (entries.length === 0)
@@ -175,7 +237,7 @@ function elementSensitiveMatchKey(el, rules, transform, sensitiveMatchesByElemen
     let depth = 0;
     while (current) {
         const elementMatches = [];
-        for (const entry of entries) {
+        for (const entry of candidateEntries(entries, current)) {
             const match = matchRuleForElement(current, entry);
             if (!match)
                 continue;
@@ -192,24 +254,20 @@ function sensitiveMatchesForElement(el, buckets, matchesByElement) {
     const cached = matchesByElement.get(el);
     if (cached)
         return cached;
-    const matched = buckets.elementSensitive.flatMap((entry) => {
+    const matched = candidateEntries(buckets.elementSensitive, el).flatMap((entry) => {
         const match = matchRuleForElement(el, entry);
         return match ? [match] : [];
     });
     matchesByElement.set(el, matched);
     return matched;
 }
-/**
- * Matches transformed rules against one element. Stable source-site identities
- * reuse revision-keyed matches; unstable identities and relationship-sensitive
- * selectors are matched on each call.
- */
+/** Stable source-site identities reuse revision-keyed matches; unstable identities and relationship-sensitive selectors match per call. */
 function getCachedElementMatches(el, rules, transform, sensitiveMatchesByElement = new Map()) {
     const buckets = sourceSiteMatchBuckets(rules, transform);
     const { cacheable, elementSensitive } = buckets;
     const collect = (entries) => {
         const matched = [];
-        for (const entry of entries) {
+        for (const entry of candidateEntries(entries, el)) {
             if (entry.rule.active === false)
                 continue;
             const match = matchRuleForElement(el, entry);
@@ -278,29 +336,24 @@ function getCachedElementMatches(el, rules, transform, sensitiveMatchesByElement
             matched: cachedMatches,
         });
     }
-    // Browser state such as `checked` or `target` can change without a DOM or
-    // stylesheet revision, so element-sensitive matches must stay fresh.
+    // Browser state (:checked, :target) can change without a revision, so element-sensitive matches stay fresh.
     const elementMatches = elementSensitive.length > 0
         ? sensitiveMatchesForElement(el, buckets, sensitiveMatchesByElement).filter((match) => match.rule.active !== false)
         : [];
     return elementMatches.length === 0 ? cachedMatches : [...cachedMatches, ...elementMatches];
 }
-/**
- * Matches selectors without applying conditional wrappers. The result retains
- * inactive media alternatives for attribution, while transient selectors and
- * the `live` transform retain their freshness requirements.
- */
+/** Keeps inactive media alternatives for attribution; transient and `live` matches keep their freshness requirements. */
 function getAllElementMatches(el, rules, transform, sensitiveMatchesByElement = new Map()) {
     const buckets = sourceSiteMatchBuckets(rules, transform);
     if (transform === "live") {
-        const cacheableMatches = buckets.cacheable.flatMap((entry) => {
+        const cacheableMatches = candidateEntries(buckets.cacheable, el).flatMap((entry) => {
             const match = matchRuleForElement(el, entry);
             return match ? [match] : [];
         });
         return [...cacheableMatches, ...sensitiveMatchesForElement(el, buckets, sensitiveMatchesByElement)];
     }
     const { cacheable, elementSensitive } = buckets;
-    const collect = (entries) => entries.flatMap((entry) => {
+    const collect = (entries) => candidateEntries(entries, el).flatMap((entry) => {
         const match = matchRuleForElement(el, entry);
         return match ? [match] : [];
     });
@@ -333,13 +386,9 @@ function getAllElementMatches(el, rules, transform, sensitiveMatchesByElement =
         : [];
     return sensitiveMatches.length === 0 ? cachedMatches : [...cachedMatches, ...sensitiveMatches];
 }
-// Branch splits repeat across sweeps, so memoize them for the finite selector
-// set in a stylesheet snapshot.
-const SELECTOR_SPLIT_CACHE_MAX = 8192;
+// Branch splits repeat across sweeps over a finite selector set, so memoize them.
+const SELECTOR_SPLIT_CACHE_MAX = 32_768;
 const selectorSplitMemo = new Map();
-// Branch matches are reusable for state-independent selectors. Transient
-// selectors stay uncached because their state is not represented by document
-// revisions.
 const ELEMENT_BRANCH_CACHE_MAX = 16384;
 const elementBranchMemo = new WeakMap();
 function isBranchMemoizable(selectorText) {
@@ -394,7 +443,6 @@ function matchingSelectorBranch(el, selectorText) {
     }
     return branch;
 }
-/** Creates a matcher for one CSSOM snapshot. */
 export function createRuleMatcher(rules, transform) {
     const sensitiveMatches = new Map();
     return {
@@ -405,10 +453,7 @@ export function createRuleMatcher(rules, transform) {
         }),
     };
 }
-/**
- * Interaction states whose pseudo-class appears in the snapshot. Skipping
- * absent states avoids a full match sweep after each stylesheet revision.
- */
+/** States whose pseudo-class appears in the snapshot, so absent states skip a full match sweep. */
 const statesWithPseudoInSnapshot = new WeakMap();
 function statesWithPseudoInSelectors(rules) {
     let present = statesWithPseudoInSnapshot.get(rules);
@@ -425,6 +470,15 @@ function statesWithPseudoInSelectors(rules) {
     }
     return present;
 }
+/** Warms transforms, buckets, and class indexes so an idle frame pays their parsing cost. */
+export function prewarmRuleMatching(rules) {
+    const transforms = ["base", "stable", "live", ...statesWithPseudoInSelectors(rules)];
+    for (const transform of new Set(transforms)) {
+        const { cacheable, elementSensitive } = sourceSiteMatchBuckets(rules, transform);
+        subjectClassIndex(cacheable);
+        subjectClassIndex(elementSensitive);
+    }
+}
 export function getAvailableInteractionStates(el) {
     const doc = el.ownerDocument ?? document;
     const { rules } = collectCssomRules(doc);

package/dist/inspector/tokens/resolution/selectorSemantics.d.ts

@@ -1,15 +1,7 @@
 export declare function splitSelectorAtTopLevel(selector: string, separator?: string): string[];
-/** Test-only specificity cache size. */
 export declare function specificityComputationCount(): number;
-/** Test-only specificity cache reset. */
 export declare function resetSpecificityMemo(): void;
-/**
- * Computes the cascade weight for a selector without asking the DOM to match
- * it. Results are memoized per selector string for the resolution paths that
- * still recompute branch specificity (multi-branch selectors).
- */
 export declare function computeSpecificity(selectorText: string): number;
-/** Unmemoized implementation used by equivalence tests. */
 export declare function computeSpecificityCore(selectorText: string): number;
 export interface SelectorPseudoClass {
     name: string;
@@ -19,10 +11,7 @@ export interface SelectorPseudoClass {
 export declare function selectorPseudoClasses(selector: string): readonly SelectorPseudoClass[];
 export declare function hasSelectorPseudoClass(selector: string, names: ReadonlySet<string>): boolean;
 export declare function isElementSensitiveSelector(selector: string): boolean;
-/**
- * Rejects selectors whose rightmost compound requires a class the element
- * does not have. This is a conservative prefilter: it only returns false for
- * an impossible positive class requirement and leaves all other selectors to
- * the browser's selector engine.
- */
+/** Class the selector's subject (rightmost compound) requires, or null when it requires none. */
+export declare function selectorSubjectClass(selector: string): string | null;
+/** Conservative prefilter: false only for an impossible required subject class; everything else goes to the browser engine. */
 export declare function canMatchSelectorSubject(el: Element, selector: string): boolean;

package/dist/inspector/tokens/resolution/selectorSemantics.js

@@ -41,23 +41,16 @@ export function splitSelectorAtTopLevel(selector, separator) {
         parts.push(last);
     return parts;
 }
-const SPECIFICITY_MEMO_LIMIT = 10_000;
+const SPECIFICITY_MEMO_LIMIT = 32_768;
 const specificityMemo = new Map();
 let specificityComputations = 0;
-/** Test-only specificity cache size. */
 export function specificityComputationCount() {
     return specificityComputations;
 }
-/** Test-only specificity cache reset. */
 export function resetSpecificityMemo() {
     specificityMemo.clear();
     specificityComputations = 0;
 }
-/**
- * Computes the cascade weight for a selector without asking the DOM to match
- * it. Results are memoized per selector string for the resolution paths that
- * still recompute branch specificity (multi-branch selectors).
- */
 export function computeSpecificity(selectorText) {
     const cached = specificityMemo.get(selectorText);
     if (cached !== undefined)
@@ -69,7 +62,6 @@ export function computeSpecificity(selectorText) {
     specificityMemo.set(selectorText, result);
     return result;
 }
-/** Unmemoized implementation used by equivalence tests. */
 export function computeSpecificityCore(selectorText) {
     const selector = selectorText.trim();
     const commaParts = splitSelectorAtTopLevel(selector, ",");
@@ -104,7 +96,7 @@ export function computeSpecificityCore(selectorText) {
     }
     return idCount * 1000000 + classCount * 10000 + elementCount * 100;
 }
-const SELECTOR_PSEUDO_CLASS_CACHE_MAX = 16_384;
+const SELECTOR_PSEUDO_CLASS_CACHE_MAX = 32_768;
 const selectorPseudoClassMemo = new Map();
 export function selectorPseudoClasses(selector) {
     const cached = selectorPseudoClassMemo.get(selector);
@@ -164,7 +156,7 @@ export function hasSelectorPseudoClass(selector, names) {
 }
 const STATIC_SELECTOR_FUNCTIONS = new Set(["is", "where", "not"]);
 const STATIC_PSEUDO_CLASSES = new Set(["host", "root"]);
-const SELECTOR_SENSITIVITY_CACHE_MAX = 16_384;
+const SELECTOR_SENSITIVITY_CACHE_MAX = 32_768;
 const selectorSensitivityMemo = new Map();
 function selectorFunctionEnd(selector, openingIndex) {
     let parentheses = 0;
@@ -249,8 +241,7 @@ function computeElementSensitiveSelector(selector) {
                 attributeDepth--;
             continue;
         }
-        // Tailwind escapes utility variants such as `.sm\\:text-red-500`. The
-        // escaped colon is part of the class name, not a pseudo-class boundary.
+        // Tailwind escapes variants (`.sm\\:text-red-500`); an escaped colon is part of the class, not a pseudo boundary.
         if (escaped) {
             escaped = false;
             continue;
@@ -270,9 +261,7 @@ function computeElementSensitiveSelector(selector) {
         const pseudoElement = selector[index + 1] === ":";
         const pseudo = /^[A-Za-z-]+/.exec(selector.slice(index + (pseudoElement ? 2 : 1)))?.[0];
         if (pseudoElement) {
-            // Pseudo-elements do not change whether the originating element matches
-            // a selector. Continue scanning after the name so a real pseudo-class
-            // elsewhere in the selector remains element-sensitive.
+            // Pseudo-elements do not make the originating element element-sensitive; keep scanning after the name.
             if (!pseudo)
                 return true;
             index += pseudo.length + 1;
@@ -297,10 +286,7 @@ function computeElementSensitiveSelector(selector) {
             index = end;
             continue;
         }
-        // :root and :host are represented by the complete ancestor/document
-        // context. Other pseudo-classes can vary per concrete element without an
-        // attribute or sibling mutation (for example :checked, :visited, and
-        // :target), so keep them in the element-sensitive bucket.
+        // :root/:host are covered by ancestor context; other pseudo-classes (:checked, :visited, :target) can vary per element, so keep them element-sensitive.
         if (STATIC_PSEUDO_CLASSES.has(pseudoName))
             continue;
         return true;
@@ -402,7 +388,7 @@ function unescapeCssIdentifier(value) {
     })
         .replace(/\\(.)/g, "$1");
 }
-const SELECTOR_CLASS_REQUIREMENTS_CACHE_MAX = 16_384;
+const SELECTOR_CLASS_REQUIREMENTS_CACHE_MAX = 32_768;
 const selectorClassRequirementsMemo = new Map();
 function selectorClassRequirements(selector) {
     const cached = selectorClassRequirementsMemo.get(selector);
@@ -469,12 +455,11 @@ function selectorClassRequirements(selector) {
     selectorClassRequirementsMemo.set(selector, requirements);
     return requirements;
 }
-/**
- * Rejects selectors whose rightmost compound requires a class the element
- * does not have. This is a conservative prefilter: it only returns false for
- * an impossible positive class requirement and leaves all other selectors to
- * the browser's selector engine.
- */
+/** Class the selector's subject (rightmost compound) requires, or null when it requires none. */
+export function selectorSubjectClass(selector) {
+    return selectorClassRequirements(selector)[0] ?? null;
+}
+/** Conservative prefilter: false only for an impossible required subject class; everything else goes to the browser engine. */
 export function canMatchSelectorSubject(el, selector) {
     return selectorClassRequirements(selector).every((className) => el.classList.contains(className));
 }

package/dist/inspector/tokens/resolution.d.ts

@@ -2,35 +2,16 @@ import type { InteractionState } from "../shell/styleState.js";
 import { type ContainerQueryEvaluator } from "./resolution/containerQueryEvaluator.js";
 import type { MatchedRule, ResolvedProperty, TokenTable } from "../../css/model/index.js";
 export { getAvailableInteractionStates, resetSourceSiteMatchCache, sourceSiteMatchCacheSize } from "./resolution/ruleMatching.js";
-export { buildTokenTable, getTokenTable, getAvailableTokenEntriesForElement, getAvailableTokenCatalog } from "./tokenAvailability.js";
+export { buildTokenTable, getAvailableTokenEntriesForElement, getAvailableTokenCatalog } from "./tokenAvailability.js";
 export { invalidateStyleResolutionCache } from "./resolution/cssomCollector.js";
-/**
- * Builds (or reuses) the document's CSSOM rule snapshot ahead of a resolution
- * sweep. Idempotent: the walk runs once per stylesheet revision and is a cache
- * hit afterwards, so a scheduler can warm it in its own frame to keep the
- * subsequent resolution sweep's blocking time small.
- */
+/** Idempotent per stylesheet revision; warms the snapshot ahead of a sweep so its blocking time stays small. */
 export declare function prewarmCssomRuleSnapshot(doc: Document): void;
 /** Prepares both cascades together so a selection refresh inserts one probe sheet. */
 export declare function prefetchContainerQueries(elements: readonly HTMLElement[], state: InteractionState, evaluator: ContainerQueryEvaluator): void;
-/**
- * Package-private cascade fixture seam. This exercises selector, layer,
- * importance, and interaction-state coordination while still crossing the
- * public value-semantics Interface through `resolveDeclaration`.
- * It is intentionally absent from the package exports.
- */
+/** Test-only cascade fixture seam, intentionally absent from the package exports. */
 export declare function resolveRuleFixture(el: HTMLElement, rules: MatchedRule[], tokenTable: TokenTable): ResolvedProperty[];
 export declare function getResolvedProperties(el: HTMLElement, tokenTable: TokenTable, evaluator?: ContainerQueryEvaluator): ResolvedProperty[];
-/**
- * Resolve the authored cascade for a chosen interaction state without relying
- * on the pointer's current location. This is intentionally attribution-first:
- * values with no authored declaration still fall back to the browser's live
- * computed value in the field layer.
- */
+/** Authored cascade for a chosen interaction state, independent of the pointer's live paint. */
 export declare function getResolvedPropertiesForState(el: HTMLElement, tokenTable: TokenTable, state: InteractionState, evaluator?: ContainerQueryEvaluator): ResolvedProperty[];
-/**
- * Resolves the cascade with transient interaction selectors removed. Used when
- * an editor must stay linked to the stable token beneath a live :hover/:focus
- * paint. Memoized per (element, revisions, tokenTable).
- */
+/** Cascade with transient interaction selectors removed, so an editor stays linked to the token beneath a live :hover/:focus paint. */
 export declare function getResolvedPropertiesStable(el: HTMLElement, tokenTable: TokenTable, evaluator?: ContainerQueryEvaluator): ResolvedProperty[];