In complex, rename 'seen' to leftMatches.

@@ -152,39 +152,39 @@ const compileMatcher = (ast: AST, selector: string): MatcherProducer => {
       case 'complex': {
       case 'complex': {
         const { left, right, combinator, pos } = ast
         const { left, right, combinator, pos } = ast
         const leftMatcher = makeMatcher(left)
         const leftMatcher = makeMatcher(left)
+        const leftCounter = counter++
+        neededContext[ leftCounter ] = () => new WeakSet()
         const rightMatcher = makeMatcher(right)
         const rightMatcher = makeMatcher(right)
-        const setCounter = counter++
-        neededContext[ setCounter ] = () => new WeakSet()
         return (context, node, parent, i, debug) => {
         return (context, node, parent, i, debug) => {
-          const seen = context[ setCounter ]
+          const { [ leftCounter ]: leftMatches } = context
           if (leftMatcher(context, node, parent, i, debug)) {
           if (leftMatcher(context, node, parent, i, debug)) {
             if (debug) console.log('matched on left', { left, right, combinator, pos, parent })
             if (debug) console.log('matched on left', { left, right, combinator, pos, parent })
-            // TODO: Check seen.has(), and maybe skip calling leftMatcher?
-            seen.add(node)
-          } else if (parent && seen.has(parent) && combinator === ' ') {
-            seen.add(node)
+            // TODO: Check leftMatches.has(), and maybe skip calling leftMatcher?
+            leftMatches.add(node)
+          } else if (parent && leftMatches.has(parent) && combinator === ' ') {
+            leftMatches.add(node)
           }
           }
           if (!rightMatcher(context, node, parent, i, debug)) return false
           if (!rightMatcher(context, node, parent, i, debug)) return false
-          seen.add(node)
+          leftMatches.add(node)
           if (debug) console.log('matched on right', { left, right, combinator, pos, node, parent })
           if (debug) console.log('matched on right', { left, right, combinator, pos, node, parent })
           switch (combinator) {
           switch (combinator) {
             case ' ':
             case ' ':
               let parentPtr = parent
               let parentPtr = parent
               while (parentPtr) {
               while (parentPtr) {
-                if (seen.has(parentPtr)) return true
+                if (leftMatches.has(parentPtr)) return true
                 parentPtr = parentPtr.parent
                 parentPtr = parentPtr.parent
               }
               }
               return false
               return false
             case '>':
             case '>':
-              if (debug) console.log('seen parent', seen.has(parent))
-              return parent ? seen.has(parent) : false
+              if (debug) console.log('leftMatches parent', leftMatches.has(parent))
+              return parent ? leftMatches.has(parent) : false
             case '+': {
             case '+': {
               if (!parent) return false
               if (!parent) return false
               let prevSiblings = parent.children.slice(0, i).filter((el) => el.type === ELEMENT_NODE)
               let prevSiblings = parent.children.slice(0, i).filter((el) => el.type === ELEMENT_NODE)
               if (prevSiblings.length === 0) return false
               if (prevSiblings.length === 0) return false
               const prev = prevSiblings[prevSiblings.length - 1]
               const prev = prevSiblings[prevSiblings.length - 1]
               if (!prev) return false
               if (!prev) return false
-              if (seen.has(prev)) return true
+              if (leftMatches.has(prev)) return true
               return false
               return false
             }
             }
             case '~': {
             case '~': {
@@ -192,7 +192,7 @@ const compileMatcher = (ast: AST, selector: string): MatcherProducer => {
               let prevSiblings = parent.children.slice(0, i).filter((el) => el.type === ELEMENT_NODE)
               let prevSiblings = parent.children.slice(0, i).filter((el) => el.type === ELEMENT_NODE)
               if (prevSiblings.length === 0) return false
               if (prevSiblings.length === 0) return false
               for (const prev of prevSiblings) {
               for (const prev of prevSiblings) {
-                if (seen.has(prev)) return true
+                if (leftMatches.has(prev)) return true
               }
               }
               return false
               return false
             }
             }