@jesscss/core 2.0.0-alpha.1

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

@@ -0,0 +1,682 @@
+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 { Nil } from '../nil.js';
+import { F_EXTENDED, F_VISIBLE } from '../node.js';
+import { getOptionalRulesetTraceId } from './ruleset-trace.js';
+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'));
+                    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) => {
+                        const ownAfterSingle = applyExtendsToSelector(ownSelector, [instruction]);
+                        const fullAfterSingle = applyExtendsToSelector(selector, [instruction]);
+                        const ownChangedSingle = ownAfterSingle.valueOf() !== ownSelector.valueOf();
+                        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 ownAfterSingle = applyExtendsToSelector(ownSelector, [instruction]);
+                        const fullAfterSingle = applyExtendsToSelector(selector, [instruction]);
+                        const ownChangedSingle = ownAfterSingle.valueOf() !== ownSelector.valueOf();
+                        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 ownAfterAll = applyExtendsToSelector(ownSelector, visibleExtends);
+                    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