@jesscss/core 2.0.0-alpha.5 → 2.0.0-alpha.6

package/lib/tree/util/extend-roots.js

@@ -1,700 +0,0 @@
-import { WARN, toDiagnostic } from '../../jess-error.js';
-import { Combinator } from '../combinator.js';
-import { ComplexSelector } from '../selector-complex.js';
-import { SelectorList } from '../selector-list.js';
-import { PseudoSelector } from '../selector-pseudo.js';
-import { applyExtendsToSelector } from './extend.js';
-import { findExtendableLocations } from './extend-helpers.js';
-import { isNode } from './is-node.js';
-import { wouldExtendChange, canUseWalkAndConsume } from './extend-walk.js';
-import { Nil } from '../nil.js';
-import { F_AMPERSAND, F_EXTENDED, F_VISIBLE } from '../node.js';
-import { getOptionalRulesetTraceId } from './ruleset-trace.js';
-/**
- * Fast check: would applying a single extend instruction change the selector?
- *
- * Uses the walk-and-consume dry-run for SimpleSelector find targets (O(depth)),
- * falls back to the full applyExtendsToSelector + valueOf comparison for complex targets.
- */
-function wouldInstructionChangeSel(selector, instruction) {
-    const { target, extendWith, partial } = instruction;
-    // Walk-and-consume fast path for SimpleSelector targets
-    if (canUseWalkAndConsume(selector, target)) {
-        return wouldExtendChange(selector, target, extendWith, partial);
-    }
-    // Fallback: full extend + compare
-    const after = applyExtendsToSelector(selector, [instruction]);
-    return after.valueOf() !== selector.valueOf();
-}
-export class ExtendRootRegistry {
-    parentRoot = new WeakMap();
-    childrenRoots = new WeakMap();
-    layerName = new WeakMap();
-    isProtected = new WeakMap();
-    isCompose = new WeakMap();
-    rootsByLayerName = new Map();
-    rootsByNamespace = new Map();
-    layerNames = new WeakMap();
-    allRoots = new Set();
-    root;
-    extendRootStack = [];
-    getCurrentExtendRoot() {
-        return this.extendRootStack[this.extendRootStack.length - 1];
-    }
-    registerRoot(rules, parent, options) {
-        this.allRoots.add(rules);
-        if (parent) {
-            this.allRoots.add(parent);
-        }
-        if (!this.root) {
-            this.root = rules;
-        }
-        if (parent) {
-            this.parentRoot.set(rules, parent);
-            let children = this.childrenRoots.get(parent);
-            if (!children) {
-                children = new Set();
-                this.childrenRoots.set(parent, children);
-            }
-            children.add(rules);
-        }
-        if (options?.layerName) {
-            this.layerName.set(rules, options.layerName);
-            let layerRoots = this.rootsByLayerName.get(options.layerName);
-            if (!layerRoots) {
-                layerRoots = new Set();
-                this.rootsByLayerName.set(options.layerName, layerRoots);
-            }
-            layerRoots.add(rules);
-        }
-        if (options?.namespace) {
-            let nsRoots = this.rootsByNamespace.get(options.namespace);
-            if (!nsRoots) {
-                nsRoots = new Set();
-                this.rootsByNamespace.set(options.namespace, nsRoots);
-            }
-            nsRoots.add(rules);
-        }
-        if (options?.isProtected) {
-            this.isProtected.set(rules, true);
-        }
-        if (options?.isCompose) {
-            this.isCompose.set(rules, true);
-        }
-    }
-    pushExtendRoot(rules) {
-        this.extendRootStack.push(rules);
-    }
-    popExtendRoot() {
-        this.extendRootStack.pop();
-    }
-    getVisibleRoots(root) {
-        return this.getAccessibleRoots(root);
-    }
-    getAccessibleRoots(root) {
-        const accessible = new Set();
-        const visited = new Set();
-        const traverseChildren = (currentRoot) => {
-            if (visited.has(currentRoot)) {
-                return;
-            }
-            visited.add(currentRoot);
-            accessible.add(currentRoot);
-            if (this.isProtected.get(currentRoot)) {
-                return;
-            }
-            const children = this.childrenRoots.get(currentRoot);
-            if (children) {
-                for (const child of children) {
-                    if (this.isProtected.get(child)) {
-                        continue;
-                    }
-                    traverseChildren(child);
-                }
-            }
-            if (currentRoot.value?.length) {
-                for (const node of currentRoot.value) {
-                    if (node && isNode(node, 'Ruleset') && node.value?.rules && isNode(node.value.rules, 'Rules')) {
-                        const innerRules = node.value.rules;
-                        if (!visited.has(innerRules)) {
-                            accessible.add(innerRules);
-                            traverseChildren(innerRules);
-                        }
-                    }
-                    else if (node && isNode(node, 'Rules')) {
-                        const innerRules = node;
-                        if (!visited.has(innerRules)) {
-                            accessible.add(innerRules);
-                            traverseChildren(innerRules);
-                        }
-                    }
-                }
-            }
-            const layer = this.layerName.get(currentRoot);
-            if (layer) {
-                const sameLayerRoots = this.rootsByLayerName.get(layer);
-                if (sameLayerRoots) {
-                    for (const layerRoot of sameLayerRoots) {
-                        if (layerRoot !== currentRoot && !visited.has(layerRoot) && !this.isProtected.get(layerRoot)) {
-                            accessible.add(layerRoot);
-                            traverseChildren(layerRoot);
-                        }
-                    }
-                }
-            }
-        };
-        traverseChildren(root);
-        return accessible;
-    }
-    isSameOrDescendantRoot(rulesetRoot, extendRoot) {
-        if (rulesetRoot === extendRoot) {
-            return true;
-        }
-        if (this.isProtected.get(rulesetRoot)) {
-            return false;
-        }
-        const layerA = this.layerName.get(rulesetRoot);
-        const layerB = this.layerName.get(extendRoot);
-        if (layerA && layerB && layerA === layerB) {
-            return true;
-        }
-        const children = this.childrenRoots.get(extendRoot);
-        if (!children) {
-            return false;
-        }
-        for (const child of children) {
-            if (this.isProtected.get(child)) {
-                continue;
-            }
-            if (this.isSameOrDescendantRoot(rulesetRoot, child)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    setLayerName(atRule, layerName) {
-        this.layerNames.set(atRule, layerName);
-    }
-    getLayerName(atRule) {
-        return this.layerNames.get(atRule);
-    }
-    takeLayerName(atRule) {
-        const layer = this.layerNames.get(atRule);
-        if (layer) {
-            this.layerNames.delete(atRule);
-        }
-        return layer;
-    }
-    getAllRoots() {
-        return new Set(this.allRoots);
-    }
-    isProtectedRoot(rules) {
-        return this.isProtected.get(rules) === true;
-    }
-}
-const rulesetsByRoot = new Map();
-function getSourceNodeTraceId(ruleset) {
-    const sourceNode = ruleset.sourceNode;
-    if (!sourceNode) {
-        return null;
-    }
-    return getOptionalRulesetTraceId(sourceNode) ?? null;
-}
-export function registerRulesetWithRoot(root, ruleset) {
-    if (!root || !ruleset) {
-        return;
-    }
-    let set = rulesetsByRoot.get(root);
-    if (!set) {
-        set = new Set();
-        rulesetsByRoot.set(root, set);
-    }
-    set.add(ruleset);
-    const sourceNode = ruleset.sourceNode;
-}
-function isInstructionVisibleForRoot(context, rootRules, instruction) {
-    if (!instruction.extendRoot) {
-        return false;
-    }
-    if (instruction.fromReferenceScope === true) {
-        // Less parity: extends declared while evaluating a reference import are non-side-effecting.
-        return false;
-    }
-    if (context.extendRoots.isProtectedRoot(rootRules) && instruction.extendRoot !== rootRules) {
-        return false;
-    }
-    if (instruction.extendRoot === rootRules) {
-        return true;
-    }
-    if (context.extendRoots.isSameOrDescendantRoot(rootRules, instruction.extendRoot)) {
-        return true;
-    }
-    const visibleRoots = context.extendRoots.getVisibleRoots(instruction.extendRoot);
-    return visibleRoots.has(rootRules);
-}
-function rootHasTargetMatch(root, target, partial) {
-    const targetValue = target.valueOf();
-    const stack = [...root.value];
-    while (stack.length > 0) {
-        const node = stack.pop();
-        if (!node || typeof node !== 'object') {
-            continue;
-        }
-        if (isNode(node, 'Ruleset')) {
-            const selector = node.value.selector;
-            if (!selector || isNode(selector, 'Nil')) {
-                continue;
-            }
-            const selectorValue = selector.valueOf();
-            if (selectorValue.includes(targetValue)) {
-                return true;
-            }
-            if (findExtendableLocations(selector, target).hasMatches) {
-                return true;
-            }
-            const rules = node.value.rules;
-            if (rules && isNode(rules, 'Rules')) {
-                stack.push(...rules.value);
-            }
-            continue;
-        }
-        if (isNode(node, 'Rules')) {
-            stack.push(...node.value);
-            continue;
-        }
-        if (isNode(node, 'AtRule')) {
-            const value = node.value;
-            if (value && isNode(value, 'Rules')) {
-                stack.push(...value.value);
-            }
-        }
-    }
-    return false;
-}
-export function processExtends(context) {
-    const instructions = context.extends.map(([target, selectorWithExtend, partial, extendRoot, extendNode, , fromReferenceScope]) => ({
-        target,
-        extendWith: selectorWithExtend,
-        partial,
-        extendRoot,
-        extendNode,
-        fromReferenceScope: fromReferenceScope === true
-    }));
-    if (!instructions.length) {
-        return;
-    }
-    const instructionStats = new Map(instructions.map(i => [i, { visibleMatchCount: 0, blockedMatchCount: 0 }]));
-    for (const [rootRules, rulesetSet] of rulesetsByRoot) {
-        if (!rootRules) {
-            continue;
-        }
-        const visibleExtendSet = new Set(instructions.filter(instruction => isInstructionVisibleForRoot(context, rootRules, instruction)));
-        for (const instruction of instructions) {
-            const selectorDiagnostics = [];
-            const matchedInRoot = Array.from(rulesetSet).some((ruleset) => {
-                const selector = ruleset.value.selector;
-                if (!selector || isNode(selector, 'Nil')) {
-                    return false;
-                }
-                const locations = findExtendableLocations(selector, instruction.target);
-                if (instruction.target.valueOf() === '.base') {
-                    selectorDiagnostics.push({ selector: selector.valueOf(), hasMatches: locations.hasMatches });
-                }
-                return locations.hasMatches;
-            });
-            if (!matchedInRoot) {
-                continue;
-            }
-            const stats = instructionStats.get(instruction);
-            if (!stats) {
-                continue;
-            }
-            if (visibleExtendSet.has(instruction)) {
-                stats.visibleMatchCount += 1;
-            }
-            else {
-                stats.blockedMatchCount += 1;
-            }
-        }
-        const visibleExtends = Array.from(visibleExtendSet);
-        if (!visibleExtends.length) {
-            continue;
-        }
-        const activatingExtends = visibleExtends;
-        for (const ruleset of rulesetSet) {
-            const selector = ruleset.value.selector;
-            if (!selector || isNode(selector, 'Nil')) {
-                ruleset.removeFlag(F_EXTENDED);
-                continue;
-            }
-            const isActivatedByVisibleExtend = activatingExtends.some(instruction => (!instruction.partial
-                || instruction.target.valueOf() === instruction.extendWith.valueOf())
-                && findExtendableLocations(selector, instruction.target).hasMatches);
-            if (isActivatedByVisibleExtend) {
-                ruleset.addFlag(F_EXTENDED);
-                // If a reference-scoped/import-scoped ruleset is externally extended, it must become
-                // visible in output so the merged selector can render.
-                ruleset.addFlag(F_VISIBLE);
-                if (isNode(selector, 'SelectorList')) {
-                    for (const item of selector.value) {
-                        item.addFlag(F_EXTENDED);
-                        item.addFlag(F_VISIBLE);
-                    }
-                }
-                else {
-                    selector.addFlag(F_EXTENDED);
-                    selector.addFlag(F_VISIBLE);
-                }
-            }
-            else {
-                ruleset.removeFlag(F_EXTENDED);
-            }
-            const ownSelector = ruleset.options?.ownSelector;
-            const hasResolvedNestedSelector = Boolean(ownSelector
-                && ownSelector.valueOf() !== selector.valueOf());
-            const hasOnlyPartialExtends = visibleExtends.length > 0 && visibleExtends.every(instruction => instruction.partial);
-            if (ownSelector && hasResolvedNestedSelector && hasOnlyPartialExtends) {
-                const ownNewSelector = applyExtendsToSelector(ownSelector, visibleExtends);
-                const fullNewSelector = applyExtendsToSelector(selector, visibleExtends);
-                const ownBefore = ownSelector.valueOf();
-                const ownAfter = ownNewSelector.valueOf();
-                const fullBefore = selector.valueOf();
-                const fullAfter = fullNewSelector.valueOf();
-                if (ownNewSelector !== ownSelector && ownAfter !== ownBefore) {
-                    ruleset.value.selector = ownNewSelector;
-                    ruleset.options.ownSelector = ownNewSelector;
-                    ruleset.invalidateSelectorValueCache();
-                    if (ownNewSelector.hoistToRoot) {
-                        ruleset.hoistToRoot = true;
-                    }
-                    continue;
-                }
-                if (fullAfter === fullBefore) {
-                    continue;
-                }
-            }
-            if (ownSelector && hasResolvedNestedSelector) {
-                const partialOnly = visibleExtends.filter(instruction => instruction.partial);
-                const nonPartialOnly = visibleExtends.filter(instruction => !instruction.partial);
-                if (partialOnly.length > 0 && nonPartialOnly.length === 0) {
-                    const ownAfterPartialOnly = applyExtendsToSelector(ownSelector, partialOnly);
-                    const fullAfterPartialOnly = applyExtendsToSelector(selector, partialOnly);
-                    const ownChangedByPartialOnly = ownAfterPartialOnly.valueOf() !== ownSelector.valueOf();
-                    const fullChangedByPartialOnly = fullAfterPartialOnly.valueOf() !== selector.valueOf();
-                    const parentSelector = (ruleset.parent?.parent && isNode(ruleset.parent.parent, 'Ruleset')
-                        ? ruleset.parent.parent.value.selector
-                        : null);
-                    const canDeriveOwnFromGeneratedIs = Boolean(!ownChangedByPartialOnly
-                        && fullChangedByPartialOnly
-                        && parentSelector
-                        && !(parentSelector instanceof Nil)
-                        && isNode(fullAfterPartialOnly, 'ComplexSelector')
-                        && !ownSelector.hasFlag(F_AMPERSAND));
-                    if (canDeriveOwnFromGeneratedIs) {
-                        const complex = fullAfterPartialOnly;
-                        const last = complex.value.at(-1);
-                        if (last
-                            && isNode(last, 'PseudoSelector')
-                            && last.value.name === ':is'
-                            && last.value.arg
-                            && isNode(last.value.arg, 'SelectorList')) {
-                            const derivedOwn = last.value.arg.copy(true);
-                            ruleset.value.selector = derivedOwn;
-                            ruleset.options.ownSelector = derivedOwn;
-                            ruleset.invalidateSelectorValueCache();
-                            continue;
-                        }
-                    }
-                }
-                if (partialOnly.length === 0 && nonPartialOnly.length > 0) {
-                    const parentSelectorForOwnSplit = (ruleset.parent?.parent && isNode(ruleset.parent.parent, 'Ruleset')
-                        ? ruleset.parent.parent.value.selector
-                        : null);
-                    const nonPartialDiagnostics = nonPartialOnly.map((instruction) => {
-                        // Walk fast path for ownSelector (no implicit ampersand boundary).
-                        // Full resolved selector has implicit parent/own boundary that
-                        // the walk can't detect, so always use legacy for that.
-                        const ownChangedSingle = wouldInstructionChangeSel(ownSelector, instruction);
-                        const fullAfterSingle = applyExtendsToSelector(selector, [instruction]);
-                        const fullChangedSingle = fullAfterSingle.valueOf() !== selector.valueOf();
-                        const parentHasTargetMatch = Boolean(parentSelectorForOwnSplit
-                            && !(parentSelectorForOwnSplit instanceof Nil)
-                            && findExtendableLocations(parentSelectorForOwnSplit, instruction.target).hasMatches);
-                        return {
-                            instruction,
-                            ownChangedSingle,
-                            fullChangedSingle,
-                            parentHasTargetMatch
-                        };
-                    });
-                    const fullChangedExtendWith = new Set(nonPartialDiagnostics
-                        .filter(d => d.fullChangedSingle)
-                        .map(d => d.instruction.extendWith.valueOf()));
-                    const nonPartialWithInclusion = nonPartialDiagnostics.map((d) => {
-                        const includeOwnOnly = (d.ownChangedSingle
-                            && !d.fullChangedSingle
-                            && !d.parentHasTargetMatch
-                            && !fullChangedExtendWith.has(d.instruction.extendWith.valueOf()));
-                        return { ...d, includeOwnOnly };
-                    });
-                    const nonPartialOwnOnly = nonPartialWithInclusion
-                        .filter(x => x.includeOwnOnly)
-                        .map(x => x.instruction);
-                    const ownAfterOwnOnly = applyExtendsToSelector(ownSelector, nonPartialOwnOnly);
-                    const hasAncestorDrivenNonPartial = nonPartialWithInclusion.some(d => !d.ownChangedSingle
-                        && d.fullChangedSingle
-                        && d.parentHasTargetMatch);
-                    if (hasAncestorDrivenNonPartial) {
-                        // Parent already carries this non-partial effect; keep nested selector local.
-                        ruleset.value.selector = ownAfterOwnOnly;
-                        ruleset.options.ownSelector = ownAfterOwnOnly;
-                        ruleset.invalidateSelectorValueCache();
-                        continue;
-                    }
-                }
-                if (partialOnly.length > 0 && nonPartialOnly.length > 0) {
-                    const parentSelectorForOwnSplit = (ruleset.parent?.parent && isNode(ruleset.parent.parent, 'Ruleset')
-                        ? ruleset.parent.parent.value.selector
-                        : null);
-                    const nonPartialDiagnostics = nonPartialOnly.map((instruction) => {
-                        const ownChangedSingle = wouldInstructionChangeSel(ownSelector, instruction);
-                        const fullAfterSingle = applyExtendsToSelector(selector, [instruction]);
-                        const fullChangedSingle = fullAfterSingle.valueOf() !== selector.valueOf();
-                        const parentHasTargetMatch = Boolean(parentSelectorForOwnSplit
-                            && !(parentSelectorForOwnSplit instanceof Nil)
-                            && findExtendableLocations(parentSelectorForOwnSplit, instruction.target).hasMatches);
-                        return {
-                            instruction,
-                            ownChangedSingle,
-                            fullChangedSingle,
-                            parentHasTargetMatch
-                        };
-                    });
-                    const fullChangedExtendWith = new Set(nonPartialDiagnostics
-                        .filter(d => d.fullChangedSingle)
-                        .map(d => d.instruction.extendWith.valueOf()));
-                    const nonPartialWithInclusion = nonPartialDiagnostics.map((d) => {
-                        const includeOwnOnly = (d.ownChangedSingle
-                            && !d.fullChangedSingle
-                            && !d.parentHasTargetMatch
-                            && !fullChangedExtendWith.has(d.instruction.extendWith.valueOf()));
-                        return { ...d, includeOwnOnly };
-                    });
-                    const nonPartialOwnOnly = nonPartialWithInclusion
-                        .filter(x => x.includeOwnOnly)
-                        .map(x => x.instruction);
-                    const ownAfterPartialAndOwnOnlyNonPartial = applyExtendsToSelector(ownSelector, [...partialOnly, ...nonPartialOwnOnly]);
-                    const ownAfterPartial = applyExtendsToSelector(ownSelector, partialOnly);
-                    const ownAfterNonPartial = applyExtendsToSelector(ownSelector, nonPartialOnly);
-                    const fullAfterNonPartial = applyExtendsToSelector(selector, nonPartialOnly);
-                    const ownChangedByNonPartial = ownAfterNonPartial.valueOf() !== ownSelector.valueOf();
-                    const fullChangedByNonPartial = fullAfterNonPartial.valueOf() !== selector.valueOf();
-                    const nonPartialBoundaryOnly = !ownChangedByNonPartial && fullChangedByNonPartial;
-                    const ownChangedByPartial = ownAfterPartial.valueOf() !== ownSelector.valueOf();
-                    const hasAncestorDrivenNonPartial = nonPartialWithInclusion.some(d => !d.ownChangedSingle
-                        && d.fullChangedSingle
-                        && d.parentHasTargetMatch);
-                    const shouldDeferToParentForNonPartial = Boolean(!ownChangedByPartial
-                        && nonPartialOwnOnly.length === 0
-                        && hasAncestorDrivenNonPartial);
-                    const hasParentMatchedOwnOnlyNonPartial = nonPartialWithInclusion.some(d => d.ownChangedSingle
-                        && !d.fullChangedSingle
-                        && d.parentHasTargetMatch);
-                    // When non-partial extends match only the full (cross-product) selector and not
-                    // the own selector, and partial extends would incorrectly alter the own selector,
-                    // the non-partial extend takes precedence. Applying partial extends to the own
-                    // selector here blocks cross-product de-distribution (`:is(parent) :is(own), .rep_ace`).
-                    if (nonPartialBoundaryOnly && (ownChangedByPartial || nonPartialOwnOnly.length > 0)) {
-                        const newSel = applyExtendsToSelector(selector, nonPartialOnly);
-                        if (newSel.valueOf() !== selector.valueOf()) {
-                            newSel.hoistToRoot = true;
-                            ruleset.value.selector = newSel;
-                            ruleset.invalidateSelectorValueCache();
-                            ruleset.hoistToRoot = true;
-                        }
-                        continue;
-                    }
-                    // For nested rulesets, apply partial (`all`) updates to own selector, but do not
-                    // fold non-partial changes into own selector. Non-partial changes are handled
-                    // through full-selector assignment path below when needed.
-                    if (ownChangedByPartial || nonPartialOwnOnly.length > 0) {
-                        ruleset.value.selector = ownAfterPartialAndOwnOnlyNonPartial;
-                        ruleset.options.ownSelector = ownAfterPartialAndOwnOnlyNonPartial;
-                        ruleset.invalidateSelectorValueCache();
-                        continue;
-                    }
-                    if (hasParentMatchedOwnOnlyNonPartial) {
-                        // Less parity: exact extends that only match nested own selector while parent already
-                        // carries the target should remain parent-scoped (do not inject extender into child selector).
-                        ruleset.value.selector = ownAfterPartial;
-                        ruleset.options.ownSelector = ownAfterPartial;
-                        ruleset.invalidateSelectorValueCache();
-                        continue;
-                    }
-                    if (shouldDeferToParentForNonPartial) {
-                        // Parent selector already carries the non-partial extend effect.
-                        // Keep this nested ruleset relative to its own selector to avoid
-                        // re-materializing parent prefixes inside nested blocks.
-                        ruleset.value.selector = ownAfterPartial;
-                        ruleset.options.ownSelector = ownAfterPartial;
-                        ruleset.invalidateSelectorValueCache();
-                        continue;
-                    }
-                }
-            }
-            let newSelector = applyExtendsToSelector(selector, visibleExtends);
-            if (newSelector !== selector) {
-                const beforeValue = selector.valueOf();
-                const ownRelevantExtends = (ownSelector && hasResolvedNestedSelector)
-                    ? visibleExtends.filter(instruction => instruction.partial)
-                    : visibleExtends;
-                const ownAfterRelevant = (ownSelector && hasResolvedNestedSelector)
-                    ? applyExtendsToSelector(ownSelector, ownRelevantExtends)
-                    : null;
-                const ownChangedByRelevant = Boolean(ownSelector
-                    && ownAfterRelevant
-                    && ownAfterRelevant.valueOf() !== ownSelector.valueOf());
-                const parentRuleset = (ruleset.parent?.parent && isNode(ruleset.parent.parent, 'Ruleset')
-                    ? ruleset.parent.parent
-                    : null);
-                const parentSelectorForBoundary = parentRuleset?.value.selector;
-                const parentHasCombinatorContext = Boolean(parentSelectorForBoundary
-                    && !(parentSelectorForBoundary instanceof Nil)
-                    && (() => {
-                        try {
-                            for (const n of parentSelectorForBoundary.nodes()) {
-                                if (isNode(n, 'Combinator')) {
-                                    return true;
-                                }
-                            }
-                        }
-                        catch { }
-                        return false;
-                    })());
-                const parentHoistedBoundaryCompose = Boolean(ownSelector
-                    && hasResolvedNestedSelector
-                    && !hasOnlyPartialExtends
-                    && !ownChangedByRelevant
-                    && rootRules.options?.referenceMode !== true
-                    && parentRuleset?.hoistToRoot
-                    && !newSelector.hoistToRoot);
-                if (parentHoistedBoundaryCompose) {
-                    const parentSelector = parentRuleset?.value.selector;
-                    if (parentSelector && !(parentSelector instanceof Nil) && isNode(parentSelector, 'SelectorList')) {
-                        const parentItems = parentSelector.value;
-                        const complexItems = parentItems.filter(item => isNode(item, 'ComplexSelector'));
-                        if (complexItems.length === parentItems.length && complexItems.length >= 2) {
-                            const first = complexItems[0];
-                            const allTri = complexItems.every(c => c.value.length === 3 && isNode(c.value[1], 'Combinator'));
-                            if (allTri) {
-                                const leftKey = first.value[0].valueOf();
-                                const combKey = first.value[1].valueOf();
-                                const samePrefix = complexItems.every(c => c.value[0].valueOf() === leftKey
-                                    && c.value[1].valueOf() === combKey);
-                                if (samePrefix) {
-                                    const ownSelectorNode = ownSelector;
-                                    const middleIs = PseudoSelector.create({
-                                        name: ':is',
-                                        arg: SelectorList.create(complexItems.map(c => c.value[2].copy(true)))
-                                    });
-                                    const parentFactored = ComplexSelector.create([
-                                        first.value[0].copy(true),
-                                        first.value[1].copy(true),
-                                        middleIs
-                                    ]);
-                                    const ownArg = isNode(ownSelectorNode, 'SelectorList')
-                                        ? SelectorList.create(ownSelectorNode.value.map(s => s.copy(true)))
-                                        : SelectorList.create([ownSelectorNode.copy(true)]);
-                                    const ownIs = PseudoSelector.create({ name: ':is', arg: ownArg });
-                                    newSelector = ComplexSelector.create([
-                                        ...parentFactored.value.map(c => c.copy(true)),
-                                        Combinator.create(' '),
-                                        ownIs
-                                    ]).inherit(newSelector);
-                                    newSelector.hoistToRoot = true;
-                                }
-                            }
-                        }
-                    }
-                }
-                const boundaryOnlyNestedExactChange = Boolean(ownSelector
-                    && hasResolvedNestedSelector
-                    && !hasOnlyPartialExtends
-                    && !ownChangedByRelevant
-                    && parentHasCombinatorContext
-                    && !(ruleset.parent?.parent
-                        && isNode(ruleset.parent.parent, 'Ruleset')
-                        && Boolean(ruleset.parent.parent.hoistToRoot))
-                    && !newSelector.hoistToRoot);
-                if (boundaryOnlyNestedExactChange) {
-                    newSelector.hoistToRoot = true;
-                }
-                const finalAfterValue = newSelector.valueOf();
-                if (beforeValue === finalAfterValue) {
-                    continue;
-                }
-                if (hasOnlyPartialExtends && isNode(newSelector, 'SelectorList')) {
-                    const previousValues = new Set();
-                    if (isNode(selector, 'SelectorList')) {
-                        for (const item of selector.value) {
-                            previousValues.add(item.valueOf());
-                        }
-                    }
-                    else {
-                        previousValues.add(selector.valueOf());
-                    }
-                    for (const item of newSelector.value) {
-                        if (!previousValues.has(item.valueOf())) {
-                            item.addFlag(F_EXTENDED);
-                        }
-                    }
-                }
-                ruleset.value.selector = newSelector;
-                ruleset.invalidateSelectorValueCache();
-                if (newSelector.hoistToRoot) {
-                    ruleset.hoistToRoot = true;
-                }
-            }
-        }
-    }
-    for (const instruction of instructions) {
-        const stats = instructionStats.get(instruction);
-        if (!stats || instruction.fromReferenceScope === true) {
-            continue;
-        }
-        if (stats.visibleMatchCount > 0) {
-            continue;
-        }
-        const target = instruction.target.valueOf();
-        const targetLocation = instruction.target.location;
-        const targetLine = targetLocation.length >= 2 ? targetLocation[1] : undefined;
-        const targetColumn = targetLocation.length >= 3 ? targetLocation[2] : undefined;
-        const targetFile = instruction.target.treeContext?.file;
-        const targetFilePath = targetFile?.fullPath;
-        const inaccessibleMatchExists = Array.from(context.extendRoots.getAllRoots()).some((root) => {
-            if (isInstructionVisibleForRoot(context, root, instruction)) {
-                return false;
-            }
-            return rootHasTargetMatch(root, instruction.target, instruction.partial);
-        });
-        const blockedProtectedRootExists = Array.from(context.extendRoots.getAllRoots()).some(root => !isInstructionVisibleForRoot(context, root, instruction)
-            && context.extendRoots.isProtectedRoot(root));
-        const diagnostic = (stats.blockedMatchCount > 0 || inaccessibleMatchExists || blockedProtectedRootExists
-            ? WARN.extendNotAccessible({
-                ctx: targetFile ? { file: targetFile } : undefined,
-                filePath: targetFilePath,
-                line: targetLine,
-                column: targetColumn,
-                meta: { target }
-            })
-            : WARN.extendNotFound({
-                ctx: targetFile ? { file: targetFile } : undefined,
-                filePath: targetFilePath,
-                line: targetLine,
-                column: targetColumn,
-                meta: { target }
-            }));
-        context.warnings.push(toDiagnostic(diagnostic));
-    }
-}
-//# sourceMappingURL=extend-roots.js.map