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

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

@@ -0,0 +1,881 @@
+/**
+ * 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