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

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

@@ -1,881 +0,0 @@
-/**
- * Walk-and-consume extend algorithm.
- *
- * The find selector decomposes into *positions* — each position is a set of
- * simple selectors (AND). Positions are separated by combinators. The walk
- * progresses through the target tree, consuming find positions:
- *
- *   - SimpleSelector find  → 1 position, 1 simple
- *   - CompoundSelector find → 1 position, N simples
- *   - ComplexSelector find  → M positions separated by combinators
- *
- * At each target position:
- *   - full match  → consume ALL of a compound
- *   - partial     → consume any subset of a compound
- *   - :is() / SelectorList → OR (try each alternative)
- *
- * ## :is() as AND branch
- *
- * When :is() appears as a component in a compound selector, it adds an AND
- * branch. The *last* selector in each :is() alternative occupies the same
- * compound position as its sibling components. Everything before the last
- * selector is an ancestral prefix — a separate path.
- *
- *   .a:is(.x > .y).b
- *     → subject has .a, .b, .y (all at one position, ANDed)
- *     → AND is child of .x (ancestral branch from :is())
- *
- * This is equivalent to .x > .a.y.b when there's only one branch. But when
- * combined with outer complex context, the branches can't be flattened:
- *
- *   div + .a:is(.x > .y).b
- *     → subject has .a, .b, .y
- *     → AND follows div     (outer complex path)
- *     → AND is child of .x  (:is() branch path)
- *
- * Walking handles both paths naturally. Flattening cannot represent this.
- *
- * ## Reading back-to-front
- *
- * Selectors read back-to-front: rightmost = subject element, leftward =
- * ancestors/preceding. For :is() alternatives that are complex selectors,
- * the last element is at the current position; the rest is a branch going up.
- *
- * ComplexSelector find support is currently used for diagnostics only
- * (wouldExtendChange); the extend application falls through to legacy
- * due to createProcessedSelector differences.
- */
-import { SelectorList } from '../selector-list.js';
-import { ComplexSelector } from '../selector-complex.js';
-import { CompoundSelector } from '../selector-compound.js';
-import { PseudoSelector } from '../selector-pseudo.js';
-import { Ampersand } from '../ampersand.js';
-import { isNode } from './is-node.js';
-import { F_EXTENDED, F_EXTEND_TARGET } from '../node.js';
-import { createProcessedSelector } from './extend.js';
-const { isArray } = Array;
-function decomposeFind(find) {
-    if (isNode(find, 'ComplexSelector')) {
-        const positions = [];
-        const combinators = [];
-        for (const comp of find.value) {
-            if (isNode(comp, 'Combinator')) {
-                combinators.push(comp.value);
-            }
-            else if (isNode(comp, 'CompoundSelector')) {
-                positions.push([...comp.value]);
-            }
-            else {
-                positions.push([comp]);
-            }
-        }
-        return { positions, combinators, original: find };
-    }
-    if (isNode(find, 'CompoundSelector')) {
-        return {
-            positions: [[...find.value]],
-            combinators: [],
-            original: find
-        };
-    }
-    // SimpleSelector or anything else: single position, single simple
-    return { positions: [[find]], combinators: [], original: find };
-}
-/** Whether the find spans multiple positions (has combinators) */
-function isMultiPosition(spec) {
-    return spec.positions.length > 1;
-}
-/** Whether the current position has multiple simples (compound) */
-function isMultiSimple(spec) {
-    return spec.positions.length === 1 && spec.positions[0].length > 1;
-}
-// ─────────────────────────────────────────────────
-// Equivalence checks
-// ─────────────────────────────────────────────────
-function isWholeNodeMatch(node, spec) {
-    const find = spec.original;
-    if (isNode(node, 'SelectorList') && !isNode(find, 'SelectorList')) {
-        return false;
-    }
-    if (isNode(node, 'ComplexSelector') && isNode(find, 'ComplexSelector')) {
-        return areComplexEquivalent(node, find);
-    }
-    if (isNode(node, 'ComplexSelector') && !isNode(find, 'ComplexSelector')) {
-        return false;
-    }
-    if (isNode(node, 'CompoundSelector') && isNode(find, 'CompoundSelector')) {
-        return areCompoundsEquivalent(node, find);
-    }
-    if (isNode(node, 'CompoundSelector') && !isNode(find, 'CompoundSelector')) {
-        return false;
-    }
-    return node.valueOf() === find.valueOf();
-}
-function areCompoundsEquivalent(a, b) {
-    if (a.value.length !== b.value.length) {
-        return false;
-    }
-    if (a.valueOf() === b.valueOf()) {
-        return true;
-    }
-    const used = new Uint8Array(b.value.length);
-    for (const aComp of a.value) {
-        const aVal = aComp.valueOf();
-        let found = false;
-        for (let j = 0; j < b.value.length; j++) {
-            if (!used[j] && b.value[j].valueOf() === aVal) {
-                used[j] = 1;
-                found = true;
-                break;
-            }
-        }
-        if (!found) {
-            return false;
-        }
-    }
-    return true;
-}
-function areComplexEquivalent(a, b) {
-    if (a.value.length !== b.value.length) {
-        return false;
-    }
-    if (a.valueOf() === b.valueOf()) {
-        return true;
-    }
-    for (let i = 0; i < a.value.length; i++) {
-        const ac = a.value[i];
-        const bc = b.value[i];
-        if (isNode(ac, 'Combinator') !== isNode(bc, 'Combinator')) {
-            return false;
-        }
-        if (isNode(ac, 'Combinator')) {
-            if (ac.value !== bc.value) {
-                return false;
-            }
-            continue;
-        }
-        if (isNode(ac, 'CompoundSelector') && isNode(bc, 'CompoundSelector')) {
-            if (!areCompoundsEquivalent(ac, bc)) {
-                return false;
-            }
-        }
-        else if (ac.valueOf() !== bc.valueOf()) {
-            return false;
-        }
-    }
-    return true;
-}
-// ─────────────────────────────────────────────────
-// Position matching
-// ─────────────────────────────────────────────────
-/**
- * Extract what's at the current position from a selector.
- *
- * For a ComplexSelector, the last non-combinator component is at the current
- * position; everything before it is an ancestral prefix. For anything else,
- * the entire selector is at the current position.
- *
- *   .a          → .a
- *   .a.b        → .a.b
- *   .x > .y     → .y     (the .x > prefix is an ancestral branch)
- *   .x > .y.z   → .y.z
- */
-function tailOf(sel) {
-    if (isNode(sel, 'ComplexSelector')) {
-        const comps = sel.value;
-        for (let i = comps.length - 1; i >= 0; i--) {
-            if (!isNode(comps[i], 'Combinator')) {
-                return comps[i];
-            }
-        }
-    }
-    return sel;
-}
-/**
- * Does `find` match `target` at this compound position?
- *
- * Like compoundComponentMatches, but tail-aware: when an :is() alternative
- * is a ComplexSelector, only its tail (last non-combinator) is at the
- * current position.
- *
- *   .y  vs  :is(.x > .y)  → true (.y is the tail of .x > .y)
- *   .x  vs  :is(.x > .y)  → false (.x is in the ancestral prefix)
- */
-function positionSimpleMatches(find, target) {
-    if (find.valueOf() === target.valueOf()) {
-        return true;
-    }
-    // find is :is() → OR: try each alternative's tail
-    if (isNode(find, 'PseudoSelector') && find.value.name === ':is' && find.value.arg) {
-        const arg = find.value.arg;
-        if (isNode(arg, 'SelectorList')) {
-            return arg.value.some((alt) => positionSimpleMatches(tailOf(alt), target));
-        }
-        return positionSimpleMatches(tailOf(arg), target);
-    }
-    // target is :is() → OR: try each alternative's tail
-    if (isNode(target, 'PseudoSelector') && target.value.name === ':is' && target.value.arg) {
-        const arg = target.value.arg;
-        if (isNode(arg, 'SelectorList')) {
-            return arg.value.some((alt) => positionSimpleMatches(find, tailOf(alt)));
-        }
-        return positionSimpleMatches(find, tailOf(arg));
-    }
-    return false;
-}
-/**
- * Does `targetComp` match `findComp` at this position?
- * Handles :is() as OR alternatives (tail-aware) and compound equivalence.
- */
-function positionComponentMatches(findComp, targetComp) {
-    if (isNode(findComp, 'CompoundSelector') && isNode(targetComp, 'CompoundSelector')) {
-        return areCompoundsEquivalent(findComp, targetComp);
-    }
-    return positionSimpleMatches(findComp, targetComp);
-}
-/**
- * Try to match find positions as a contiguous subsequence in target
- * components. Returns the start index or -1.
- */
-function findSubsequence(targetComps, spec) {
-    // Reconstruct find components (positions interleaved with combinators)
-    const findComps = [];
-    for (let p = 0; p < spec.positions.length; p++) {
-        if (p > 0) {
-            findComps.push({ type: 'Combinator', value: spec.combinators[p - 1] });
-        }
-        const simples = spec.positions[p];
-        if (simples.length === 1) {
-            findComps.push(simples[0]);
-        }
-        else {
-            findComps.push({ type: 'CompoundSelector', value: simples, _isVirtual: true, simples });
-        }
-    }
-    const maxStart = targetComps.length - findComps.length;
-    for (let start = 0; start <= maxStart; start++) {
-        let matches = true;
-        for (let j = 0; j < findComps.length; j++) {
-            const tc = targetComps[start + j];
-            const fc = findComps[j];
-            if (fc.type === 'Combinator') {
-                if (!isNode(tc, 'Combinator') || tc.value !== fc.value) {
-                    matches = false;
-                    break;
-                }
-            }
-            else {
-                if (isNode(tc, 'Combinator')) {
-                    matches = false;
-                    break;
-                }
-                if (fc._isVirtual) {
-                    // Virtual compound: check if all simples match the target component
-                    if (isNode(tc, 'CompoundSelector')) {
-                        if (!areCompoundsEquivalent(CompoundSelector.create(fc.simples), tc)) {
-                            matches = false;
-                            break;
-                        }
-                    }
-                    else {
-                        matches = false;
-                        break;
-                    }
-                }
-                else if (!positionComponentMatches(fc, tc)) {
-                    matches = false;
-                    break;
-                }
-            }
-        }
-        if (matches) {
-            return start;
-        }
-    }
-    return -1;
-}
-/**
- * Try to consume find simples from a compound's components (subsequence match).
- * Returns matched indices or null if not all consumed.
- */
-function consumeSimples(targetComps, findSimples) {
-    const matchIndices = [];
-    let findIdx = 0;
-    for (let i = 0; i < targetComps.length && findIdx < findSimples.length; i++) {
-        if (positionSimpleMatches(findSimples[findIdx], targetComps[i])) {
-            matchIndices.push(i);
-            findIdx++;
-        }
-    }
-    return matchIndices.length === findSimples.length ? matchIndices : null;
-}
-const ROOT_CTX = {
-    isRoot: true,
-    parentType: null,
-    hasContentBefore: false,
-    hasContentAfter: false
-};
-// ─────────────────────────────────────────────────
-// Quick eligibility check
-// ─────────────────────────────────────────────────
-export function canUseWalkAndConsume(target, find) {
-    if (!isNode(find, 'SimpleSelector')
-        && !isNode(find, 'CompoundSelector')
-        && !isNode(find, 'ComplexSelector')) {
-        return false;
-    }
-    if (containsAmpersand(target)) {
-        return false;
-    }
-    return true;
-}
-export function extendWithNeedsConflictValidation(extendWith) {
-    if (isNode(extendWith, 'CompoundSelector')) {
-        return extendWith.value.some((child) => child.isTag || child.isId);
-    }
-    if (extendWith.isTag || extendWith.isId) {
-        return true;
-    }
-    return false;
-}
-function containsAmpersand(sel) {
-    if (sel instanceof Ampersand) {
-        return true;
-    }
-    if (isNode(sel, 'SelectorList') || isNode(sel, 'CompoundSelector') || isNode(sel, 'ComplexSelector')) {
-        return sel.value.some((child) => containsAmpersand(child));
-    }
-    if (isNode(sel, 'PseudoSelector') && sel.value.arg && sel.value.arg.isSelector) {
-        return containsAmpersand(sel.value.arg);
-    }
-    return false;
-}
-// ─────────────────────────────────────────────────
-// Main entry point
-// ─────────────────────────────────────────────────
-export function walkAndExtend(target, find, extendWith, partial) {
-    const spec = decomposeFind(find);
-    return walkNode(target, spec, extendWith, partial, ROOT_CTX);
-}
-// ─────────────────────────────────────────────────
-// Recursive walk
-// ─────────────────────────────────────────────────
-function walkNode(node, spec, extendWith, partial, ctx) {
-    // 1. Whole-node equivalence
-    if (isWholeNodeMatch(node, spec)) {
-        return applyWholeMatch(node, spec, extendWith, partial, ctx);
-    }
-    // 2. Recurse into containers
-    if (isNode(node, 'SelectorList')) {
-        return walkSelectorList(node, spec, extendWith, partial, ctx);
-    }
-    if (isNode(node, 'ComplexSelector')) {
-        return walkComplexSelector(node, spec, extendWith, partial, ctx);
-    }
-    if (isNode(node, 'CompoundSelector')) {
-        return walkCompoundSelector(node, spec, extendWith, partial, ctx);
-    }
-    if (isNode(node, 'PseudoSelector') && node.value.arg && node.value.arg.isSelector) {
-        return walkPseudoSelector(node, spec, extendWith, partial, ctx);
-    }
-    // 3. No match
-    return node;
-}
-// ─────────────────────────────────────────────────
-// Whole-match transformation
-// ─────────────────────────────────────────────────
-function applyWholeMatch(node, spec, extendWith, partial, ctx) {
-    const findVal = spec.original.valueOf();
-    const extendVal = extendWith.valueOf();
-    if (findVal === extendVal) {
-        return node;
-    }
-    if (!partial) {
-        if (ctx.parentType === 'CompoundSelector' || ctx.parentType === 'ComplexSelector') {
-            return node;
-        }
-        return makeList(node, extendWith);
-    }
-    if (ctx.parentType === 'CompoundSelector' || ctx.parentType === 'ComplexSelector') {
-        return wrapInIs(node, extendWith);
-    }
-    return makeList(node, extendWith, true);
-}
-// ─────────────────────────────────────────────────
-// Container walkers
-// ─────────────────────────────────────────────────
-function walkSelectorList(list, spec, extendWith, partial, _ctx) {
-    const items = list.value;
-    const originals = [];
-    const appended = [];
-    let anyChanged = false;
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const childCtx = {
-            isRoot: false,
-            parentType: 'SelectorList',
-            hasContentBefore: i > 0,
-            hasContentAfter: i < items.length - 1
-        };
-        const extended = walkNode(item, spec, extendWith, partial, childCtx);
-        if (extended === item) {
-            originals.push(item);
-        }
-        else if (isNode(extended, 'SelectorList')) {
-            const extItems = extended.value;
-            const first = extItems[0];
-            first.addFlag(F_EXTENDED);
-            if (partial) {
-                first.addFlag(F_EXTEND_TARGET);
-            }
-            originals.push(first);
-            for (let j = 1; j < extItems.length; j++) {
-                const ext = extItems[j];
-                ext.addFlag(F_EXTENDED);
-                appended.push(ext);
-            }
-            anyChanged = true;
-        }
-        else {
-            extended.addFlag(F_EXTENDED);
-            originals.push(extended);
-            anyChanged = true;
-        }
-    }
-    if (!anyChanged) {
-        return list;
-    }
-    const allSelectors = [...originals, ...appended];
-    const processed = createProcessedSelector(allSelectors, true);
-    const processedArray = isArray(processed) ? processed : [processed];
-    const safe = processedArray.map(s => (s === list ? s.clone(true) : s));
-    return SelectorList.create(safe).inherit(list);
-}
-function walkComplexSelector(complex, spec, extendWith, partial, ctx) {
-    // Multi-position find: try contiguous subsequence match
-    if (isMultiPosition(spec)) {
-        return consumePositionsFromComplex(complex, spec, extendWith, partial, ctx);
-    }
-    // Single-position find: walk each component individually
-    const components = complex.value;
-    let anyChanged = false;
-    const newComponents = [...components];
-    for (let i = 0; i < components.length; i++) {
-        const comp = components[i];
-        if (isNode(comp, 'Combinator')) {
-            continue;
-        }
-        const childCtx = {
-            isRoot: false,
-            parentType: 'ComplexSelector',
-            hasContentBefore: i > 0,
-            hasContentAfter: i < components.length - 1
-        };
-        const extended = walkNode(comp, spec, extendWith, partial, childCtx);
-        if (extended !== comp) {
-            newComponents[i] = extended;
-            anyChanged = true;
-        }
-    }
-    if (!anyChanged) {
-        return complex;
-    }
-    return ComplexSelector.create(newComponents).inherit(complex);
-}
-function walkCompoundSelector(compound, spec, extendWith, partial, _ctx) {
-    // Multi-position: can't consume from a single compound
-    if (isMultiPosition(spec)) {
-        return compound;
-    }
-    // Multi-simple: consume find simples from compound components
-    if (isMultiSimple(spec) && partial) {
-        return consumeSimplesFromCompound(compound, spec, extendWith);
-    }
-    // Single-simple: walk individual components (recurses into :is())
-    const components = compound.value;
-    let anyChanged = false;
-    const newComponents = [...components];
-    for (let i = 0; i < components.length; i++) {
-        const comp = components[i];
-        const childCtx = {
-            isRoot: false,
-            parentType: 'CompoundSelector',
-            hasContentBefore: i > 0,
-            hasContentAfter: i < components.length - 1
-        };
-        const extended = walkNode(comp, spec, extendWith, partial, childCtx);
-        if (extended !== comp) {
-            newComponents[i] = extended;
-            anyChanged = true;
-        }
-    }
-    if (!anyChanged) {
-        return compound;
-    }
-    return CompoundSelector.create(newComponents).inherit(compound);
-}
-/**
- * Consume find simples from a compound's components.
- * Matched components → :is(matched, extendWith). Remainder stays.
- */
-function consumeSimplesFromCompound(compound, spec, extendWith) {
-    const targetComps = compound.value;
-    const findSimples = spec.positions[0];
-    const matchIndices = consumeSimples(targetComps, findSimples);
-    if (!matchIndices) {
-        return compound;
-    }
-    const matchedSet = new Set(matchIndices);
-    const remainders = [];
-    for (let i = 0; i < targetComps.length; i++) {
-        if (!matchedSet.has(i)) {
-            remainders.push(targetComps[i]);
-        }
-    }
-    const isWrapper = wrapInIs(spec.original, extendWith);
-    const newComponents = [isWrapper, ...remainders];
-    const result = CompoundSelector.create(newComponents).inherit(compound);
-    result.addFlag(F_EXTENDED);
-    return result;
-}
-/**
- * Consume find positions from a complex selector's components.
- * Contiguous subsequence match with exact combinator matching.
- */
-function consumePositionsFromComplex(complex, spec, extendWith, partial, _ctx) {
-    const targetComps = complex.value;
-    const start = findSubsequence(targetComps, spec);
-    if (start < 0) {
-        return complex;
-    }
-    // Reconstruct find component count (positions + combinators)
-    const findLen = spec.positions.length + spec.combinators.length;
-    const end = start + findLen;
-    const hasBefore = start > 0;
-    const hasAfter = end < targetComps.length;
-    if (!partial && (hasBefore || hasAfter)) {
-        return complex;
-    }
-    if (!hasBefore && !hasAfter) {
-        return makeList(complex, extendWith, true);
-    }
-    // Wrap the matched segment
-    const matchedSegment = targetComps.slice(start, end);
-    const matchedComplex = ComplexSelector.create(matchedSegment).inherit(complex);
-    const isWrapper = wrapInIs(matchedComplex, extendWith);
-    const before = targetComps.slice(0, start);
-    const after = targetComps.slice(end);
-    const newComps = [...before, isWrapper, ...after];
-    const result = ComplexSelector.create(newComps).inherit(complex);
-    result.addFlag(F_EXTENDED);
-    return result;
-}
-function walkPseudoSelector(pseudo, spec, extendWith, partial, ctx) {
-    const arg = pseudo.value.arg;
-    // When :is() is inside a compound, only the tail of each complex
-    // alternative is at the current position. The ancestral prefix is
-    // a separate branch and should not be walked for matching.
-    if (ctx.parentType === 'CompoundSelector') {
-        return walkPseudoTailAware(pseudo, arg, spec, extendWith, partial, ctx);
-    }
-    const childCtx = {
-        isRoot: false,
-        parentType: 'PseudoSelector',
-        hasContentBefore: false,
-        hasContentAfter: false
-    };
-    const extendedArg = walkNode(arg, spec, extendWith, partial, childCtx);
-    if (extendedArg === arg) {
-        return pseudo;
-    }
-    if (!partial && (ctx.hasContentBefore || ctx.hasContentAfter)) {
-        return pseudo;
-    }
-    const result = PseudoSelector.create({
-        name: pseudo.value.name,
-        arg: extendedArg
-    }).inherit(pseudo);
-    result.generated = pseudo.generated;
-    return result;
-}
-/**
- * Walk :is() alternatives tail-aware: for complex alternatives, only the
- * last non-combinator component (the tail) is at the current compound
- * position. The ancestral prefix is not walked.
- */
-function walkPseudoTailAware(pseudo, arg, spec, extendWith, partial, ctx) {
-    if (isNode(arg, 'SelectorList')) {
-        const items = arg.value;
-        let anyChanged = false;
-        const originals = [];
-        const appended = [];
-        for (let i = 0; i < items.length; i++) {
-            const alt = items[i];
-            const extended = walkAlternativeTailAware(alt, spec, extendWith, partial);
-            if (extended === alt) {
-                originals.push(alt);
-            }
-            else if (isNode(extended, 'SelectorList')) {
-                // Decompose: first item stays in position, rest appended at end
-                const extItems = extended.value;
-                originals.push(extItems[0]);
-                for (let j = 1; j < extItems.length; j++) {
-                    appended.push(extItems[j]);
-                }
-                anyChanged = true;
-            }
-            else {
-                originals.push(extended);
-                anyChanged = true;
-            }
-        }
-        if (!anyChanged) {
-            return pseudo;
-        }
-        if (!partial && (ctx.hasContentBefore || ctx.hasContentAfter)) {
-            return pseudo;
-        }
-        const newList = SelectorList.create([...originals, ...appended]).inherit(arg);
-        const result = PseudoSelector.create({
-            name: pseudo.value.name,
-            arg: newList
-        }).inherit(pseudo);
-        result.generated = pseudo.generated;
-        return result;
-    }
-    // Single alternative
-    const extended = walkAlternativeTailAware(arg, spec, extendWith, partial);
-    if (extended === arg) {
-        return pseudo;
-    }
-    if (!partial && (ctx.hasContentBefore || ctx.hasContentAfter)) {
-        return pseudo;
-    }
-    const result = PseudoSelector.create({
-        name: pseudo.value.name,
-        arg: extended
-    }).inherit(pseudo);
-    result.generated = pseudo.generated;
-    return result;
-}
-/**
- * Walk a single :is() alternative. If it's a ComplexSelector, only walk
- * the tail (last non-combinator). Otherwise walk normally.
- */
-function walkAlternativeTailAware(alt, spec, extendWith, partial) {
-    if (!isNode(alt, 'ComplexSelector')) {
-        // Simple or compound alternative: walk normally
-        const childCtx = {
-            isRoot: false,
-            parentType: 'PseudoSelector',
-            hasContentBefore: false,
-            hasContentAfter: false
-        };
-        return walkNode(alt, spec, extendWith, partial, childCtx);
-    }
-    // Complex alternative: only walk the tail
-    const comps = alt.value;
-    let tailIdx = -1;
-    for (let i = comps.length - 1; i >= 0; i--) {
-        if (!isNode(comps[i], 'Combinator')) {
-            tailIdx = i;
-            break;
-        }
-    }
-    if (tailIdx < 0) {
-        return alt;
-    }
-    const tail = comps[tailIdx];
-    // The tail is at the compound position — walk it as if it were a compound child
-    const tailCtx = {
-        isRoot: false,
-        parentType: 'CompoundSelector',
-        hasContentBefore: tailIdx > 0,
-        hasContentAfter: tailIdx < comps.length - 1
-    };
-    const extendedTail = walkNode(tail, spec, extendWith, partial, tailCtx);
-    if (extendedTail === tail) {
-        return alt;
-    }
-    // Reconstruct complex with modified tail, keeping prefix intact
-    const newComps = [...comps];
-    newComps[tailIdx] = extendedTail;
-    return ComplexSelector.create(newComps).inherit(alt);
-}
-// ─────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────
-function makeList(original, extendWith, partial = false) {
-    const a = original.clone(true);
-    a.addFlag(F_EXTENDED);
-    if (partial) {
-        a.addFlag(F_EXTEND_TARGET);
-    }
-    const extendItems = extractIsArgs(extendWith);
-    const items = [a];
-    for (const item of extendItems) {
-        const b = item.clone(true);
-        b.addFlag(F_EXTENDED);
-        items.push(b);
-    }
-    const processed = createProcessedSelector(items, true);
-    const processedArray = isArray(processed) ? processed : [processed];
-    return SelectorList.create(processedArray).inherit(original);
-}
-function extractIsArgs(selector) {
-    if (isNode(selector, 'PseudoSelector') && selector.value.name === ':is' && selector.value.arg) {
-        const arg = selector.value.arg;
-        if (isNode(arg, 'SelectorList')) {
-            return arg.value;
-        }
-        return [arg];
-    }
-    return [selector];
-}
-function wrapInIs(matched, extendWith) {
-    const a = matched.copy(true);
-    a.addFlag(F_EXTEND_TARGET);
-    const extendItems = extractIsArgs(extendWith);
-    const extendCopies = extendItems.map((item) => {
-        const c = item.copy(true);
-        c.addFlag(F_EXTENDED);
-        return c;
-    });
-    if (isNode(matched, 'PseudoSelector') && matched.value.name === ':is' && matched.value.arg) {
-        const existing = isNode(matched.value.arg, 'SelectorList')
-            ? matched.value.arg.value
-            : [matched.value.arg];
-        const existingVals = new Set(existing.map(s => s.valueOf()));
-        const newItems = extendCopies.filter(c => !existingVals.has(c.valueOf()));
-        if (newItems.length === 0) {
-            return matched;
-        }
-        const merged = [...existing.map(s => s.copy(true)), ...newItems];
-        const list = SelectorList.create(merged);
-        const result = PseudoSelector.create({ name: ':is', arg: list }).inherit(matched);
-        result.generated = true;
-        return result;
-    }
-    const list = SelectorList.create([a, ...extendCopies]);
-    const result = PseudoSelector.create({ name: ':is', arg: list }).inherit(matched);
-    result.generated = true;
-    return result;
-}
-// ─────────────────────────────────────────────────
-// Dry-run: would this extend change the selector?
-// ─────────────────────────────────────────────────
-export function wouldExtendChange(target, find, extendWith, partial) {
-    const spec = decomposeFind(find);
-    return wouldMatchNode(target, spec, extendWith, partial, ROOT_CTX);
-}
-function wouldMatchNode(node, spec, extendWith, partial, ctx) {
-    if (spec.original.valueOf() === extendWith.valueOf()) {
-        return false;
-    }
-    if (isWholeNodeMatch(node, spec)) {
-        if (!partial) {
-            if (ctx.parentType === 'CompoundSelector' || ctx.parentType === 'ComplexSelector') {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (isNode(node, 'SelectorList')) {
-        return node.value.some((item, i) => wouldMatchNode(item, spec, extendWith, partial, {
-            isRoot: false,
-            parentType: 'SelectorList',
-            hasContentBefore: i > 0,
-            hasContentAfter: i < node.value.length - 1
-        }));
-    }
-    if (isNode(node, 'ComplexSelector')) {
-        if (isMultiPosition(spec)) {
-            return wouldSubsequenceMatch(node, spec, partial);
-        }
-        return node.value.some((comp, i) => {
-            if (isNode(comp, 'Combinator')) {
-                return false;
-            }
-            return wouldMatchNode(comp, spec, extendWith, partial, {
-                isRoot: false,
-                parentType: 'ComplexSelector',
-                hasContentBefore: i > 0,
-                hasContentAfter: i < node.value.length - 1
-            });
-        });
-    }
-    if (isNode(node, 'CompoundSelector')) {
-        if (isMultiSimple(spec) && partial) {
-            return wouldSimplesMatch(node, spec);
-        }
-        return node.value.some((comp, i) => wouldMatchNode(comp, spec, extendWith, partial, {
-            isRoot: false,
-            parentType: 'CompoundSelector',
-            hasContentBefore: i > 0,
-            hasContentAfter: i < node.value.length - 1
-        }));
-    }
-    if (isNode(node, 'PseudoSelector') && node.value.arg && node.value.arg.isSelector) {
-        const pseudo = node;
-        if (!partial && (ctx.hasContentBefore || ctx.hasContentAfter)) {
-            return false;
-        }
-        // Tail-aware: when :is() is inside a compound, only the tail of
-        // complex alternatives is at the current position.
-        if (ctx.parentType === 'CompoundSelector') {
-            return wouldMatchPseudoTailAware(pseudo, spec, extendWith, partial);
-        }
-        return wouldMatchNode(pseudo.value.arg, spec, extendWith, partial, {
-            isRoot: false,
-            parentType: 'PseudoSelector',
-            hasContentBefore: false,
-            hasContentAfter: false
-        });
-    }
-    return false;
-}
-function wouldMatchPseudoTailAware(pseudo, spec, extendWith, partial) {
-    const arg = pseudo.value.arg;
-    const checkAlt = (alt) => {
-        if (!isNode(alt, 'ComplexSelector')) {
-            return wouldMatchNode(alt, spec, extendWith, partial, {
-                isRoot: false,
-                parentType: 'PseudoSelector',
-                hasContentBefore: false,
-                hasContentAfter: false
-            });
-        }
-        // Complex: only check the tail
-        const comps = alt.value;
-        for (let i = comps.length - 1; i >= 0; i--) {
-            if (!isNode(comps[i], 'Combinator')) {
-                return wouldMatchNode(comps[i], spec, extendWith, partial, {
-                    isRoot: false,
-                    parentType: 'CompoundSelector',
-                    hasContentBefore: i > 0,
-                    hasContentAfter: i < comps.length - 1
-                });
-            }
-        }
-        return false;
-    };
-    if (isNode(arg, 'SelectorList')) {
-        return arg.value.some((alt) => checkAlt(alt));
-    }
-    return checkAlt(arg);
-}
-function wouldSimplesMatch(target, spec) {
-    return consumeSimples(target.value, spec.positions[0]) !== null;
-}
-function wouldSubsequenceMatch(target, spec, partial) {
-    const start = findSubsequence(target.value, spec);
-    if (start < 0) {
-        return false;
-    }
-    if (!partial) {
-        const findLen = spec.positions.length + spec.combinators.length;
-        return start === 0 && findLen === target.value.length;
-    }
-    return true;
-}
-//# sourceMappingURL=extend-walk.js.map