cataract 0.2.5 → 0.3.0

data/lib/cataract/pure/serializer.rb

@@ -38,6 +38,35 @@ module Cataract
     end
   end
 
+  # @api private
+  # Helper: does the rule's media query differ from the currently open media
+  # block, requiring a new "@media ... {" to be opened? Comma-separated
+  # lists are compared by list id; single queries are compared by content
+  # (type + conditions), since two separately-parsed queries with the same
+  # content should still be grouped under one block.
+  # @return [Boolean]
+  def self._needs_new_media_block?(current_media_query, current_media_query_list_id, rule_media_query,
+                                   rule_media_query_list_id)
+    if rule_media_query_list_id
+      current_media_query_list_id != rule_media_query_list_id
+    else
+      !current_media_query ||
+        current_media_query.type != rule_media_query.type ||
+        current_media_query.conditions != rule_media_query.conditions
+    end
+  end
+
+  # @api private
+  # Helper: read a rule's parent_rule_id, guarding against AtRule (which has
+  # no such member - only Rule participates in CSS nesting, AtRule never is
+  # nested via '&' nesting). Calling .parent_rule_id directly on an AtRule
+  # raises NoMethodError.
+  # @param rule [Rule, AtRule] The rule to check
+  # @return [Integer, nil] parent_rule_id, or nil if the rule isn't a Rule
+  def self._rule_parent_id(rule)
+    rule.is_a?(Rule) ? rule.parent_rule_id : nil
+  end
+
   # Serialize stylesheet to compact CSS string
   #
   # @param rules [Array<Rule>] Array of rules
@@ -63,9 +92,10 @@ module Cataract
     # Build parent-child relationships
     rule_children = {}
     rules.each do |rule|
-      next unless rule.parent_rule_id
+      parent_rule_id = _rule_parent_id(rule)
+      next unless parent_rule_id
 
-      parent_id = rule.parent_rule_id.is_a?(Integer) ? rule.parent_rule_id : rule.parent_rule_id.to_i
+      parent_id = parent_rule_id.is_a?(Integer) ? parent_rule_id : parent_rule_id.to_i
       rule_children[parent_id] ||= []
       rule_children[parent_id] << rule
     end
@@ -83,9 +113,9 @@ module Cataract
 
     rules.each do |rule|
       # Skip rules that have a parent (they'll be serialized as nested)
-      next if rule.parent_rule_id
+      next if _rule_parent_id(rule)
 
-      rule_media_query_id = rule.is_a?(Rule) ? rule.media_query_id : nil
+      rule_media_query_id = rule.media_query_id
       rule_media_query = rule_media_query_id ? media_queries[rule_media_query_id] : nil
       rule_media_query_list_id = rule_media_query_id ? mq_id_to_list_id[rule_media_query_id] : nil
 
@@ -101,13 +131,8 @@ module Cataract
         # Check if we need to open a new media block
         # For lists: compare list_id
         # For single queries: compare by content (type + conditions)
-        needs_new_block = if rule_media_query_list_id
-                            current_media_query_list_id != rule_media_query_list_id
-                          else
-                            !current_media_query ||
-                              current_media_query.type != rule_media_query.type ||
-                              current_media_query.conditions != rule_media_query.conditions
-                          end
+        needs_new_block = _needs_new_media_block?(current_media_query, current_media_query_list_id, rule_media_query,
+                                                  rule_media_query_list_id)
 
         if needs_new_block
           if in_media_block
@@ -152,6 +177,14 @@ module Cataract
 
   # Helper: serialize a rule with its nested children
   def self._serialize_rule_with_nesting(result, rule, rule_children, media_queries)
+    # Check if this is an AtRule - it can never have nested children of its
+    # own via rule_children (only Rule participates in CSS nesting), so it
+    # always serializes the same way regardless of has_nesting
+    if rule.is_a?(AtRule)
+      _serialize_at_rule(result, rule)
+      return
+    end
+
     # Start selector
     result << "#{rule.selector} { "
 
@@ -161,34 +194,33 @@ module Cataract
       _serialize_declarations(result, rule.declarations)
     end
 
-    # Get nested children for this rule
-    children = rule_children[rule.id] || []
+    _serialize_children(result, rule.selector, rule_children[rule.id] || [], rule_children, media_queries, has_declarations)
 
-    # Serialize nested children
+    result << " }\n"
+  end
+
+  # Helper: recursively serialize a rule's nested children. CSS nesting can go
+  # as deep as the parser allows (MAX_PARSE_DEPTH), so this recurses rather
+  # than hand-unrolling a fixed number of levels - a nested rule's own nested
+  # rules are found the same way its parent's were, via rule_children[id].
+  def self._serialize_children(result, parent_selector, children, rule_children, media_queries, parent_has_declarations)
     children.each_with_index do |child, index|
       # Add space before nested content
-      # - Always add space if we had declarations
+      # - Always add space if the parent had declarations
       # - Add space between nested rules (not before first if no declarations)
-      if has_declarations || index > 0
+      if parent_has_declarations || index > 0
         result << ' '
       end
 
-      # Determine if we need to reconstruct the nested selector with &
-      nested_selector = _reconstruct_nested_selector(rule.selector, child.selector, child.nesting_style)
-
       # Check if this child has @media nesting (parent_rule_id present but nesting_style is nil)
       if child.nesting_style.nil? && child.media_query_id && media_queries[child.media_query_id]
         # This is a nested @media rule
         mq = media_queries[child.media_query_id]
-        media_query_string = if mq.conditions
-                               mq.type == :all ? mq.conditions : "#{mq.type} and #{mq.conditions}"
-                             else
-                               mq.type.to_s
-                             end
+        media_query_string = _build_media_query_string(mq, nil, nil, media_queries)
         result << "@media #{media_query_string} { "
         _serialize_declarations(result, child.declarations)
 
-        # Recursively serialize any children of this @media rule
+        # Serialize any children of this @media rule
         media_children = rule_children[child.id] || []
         media_children.each_with_index do |media_child, media_idx|
           result << ' ' if media_idx > 0 || !child.declarations.empty?
@@ -205,31 +237,18 @@ module Cataract
 
         result << ' }'
       else
-        # Regular nested selector
+        # Regular nested selector - determine if we need to reconstruct it with &
+        nested_selector = _reconstruct_nested_selector(parent_selector, child.selector, child.nesting_style)
+
         result << "#{nested_selector} { "
         _serialize_declarations(result, child.declarations)
 
-        # Recursively serialize any children of this nested rule
-        grandchildren = rule_children[child.id] || []
-        grandchildren.each_with_index do |grandchild, grandchild_idx|
-          result << ' ' if grandchild_idx > 0 || !child.declarations.empty?
-
-          nested_grandchild_selector = _reconstruct_nested_selector(
-            child.selector,
-            grandchild.selector,
-            grandchild.nesting_style
-          )
-
-          result << "#{nested_grandchild_selector} { "
-          _serialize_declarations(result, grandchild.declarations)
-          result << ' }'
-        end
+        # Recurse into this child's own nested children, however deep they go
+        _serialize_children(result, child.selector, rule_children[child.id] || [], rule_children, media_queries, !child.declarations.empty?)
 
         result << ' }'
       end
     end
-
-    result << " }\n"
   end
 
   # Reconstruct nested selector representation
@@ -328,7 +347,7 @@ module Cataract
       # Skip if already processed (when grouped)
       next if processed_rule_ids[rule.id]
 
-      rule_media_query_id = rule.is_a?(Rule) ? rule.media_query_id : nil
+      rule_media_query_id = rule.media_query_id
       rule_media_query = rule_media_query_id ? media_queries[rule_media_query_id] : nil
       rule_media_query_list_id = rule_media_query_id ? mq_id_to_list_id[rule_media_query_id] : nil
       is_first_rule = (rule_index == 0)
@@ -376,13 +395,8 @@ module Cataract
         # This rule is in a media query
         # For lists: compare list_id
         # For single queries: compare by content (type + conditions)
-        needs_new_block = if rule_media_query_list_id
-                            current_media_query_list_id != rule_media_query_list_id
-                          else
-                            !current_media_query ||
-                              current_media_query.type != rule_media_query.type ||
-                              current_media_query.conditions != rule_media_query.conditions
-                          end
+        needs_new_block = _needs_new_media_block?(current_media_query, current_media_query_list_id, rule_media_query,
+                                                  rule_media_query_list_id)
 
         if needs_new_block
           # Close previous media block if open
@@ -548,9 +562,10 @@ module Cataract
     # Build parent-child relationships
     rule_children = {}
     rules.each do |rule|
-      next unless rule.parent_rule_id
+      parent_rule_id = _rule_parent_id(rule)
+      next unless parent_rule_id
 
-      parent_id = rule.parent_rule_id.is_a?(Integer) ? rule.parent_rule_id : rule.parent_rule_id.to_i
+      parent_id = parent_rule_id.is_a?(Integer) ? parent_rule_id : parent_rule_id.to_i
       rule_children[parent_id] ||= []
       rule_children[parent_id] << rule
     end
@@ -567,9 +582,9 @@ module Cataract
     in_media_block = false
 
     rules.each do |rule|
-      next if rule.parent_rule_id
+      next if _rule_parent_id(rule)
 
-      rule_media_query_id = rule.is_a?(Rule) ? rule.media_query_id : nil
+      rule_media_query_id = rule.media_query_id
       rule_media_query = rule_media_query_id ? media_queries[rule_media_query_id] : nil
       rule_media_query_list_id = rule_media_query_id ? mq_id_to_list_id[rule_media_query_id] : nil
 
@@ -588,13 +603,8 @@ module Cataract
       else
         # For lists: compare list_id
         # For single queries: compare by content (type + conditions)
-        needs_new_block = if rule_media_query_list_id
-                            current_media_query_list_id != rule_media_query_list_id
-                          else
-                            !current_media_query ||
-                              current_media_query.type != rule_media_query.type ||
-                              current_media_query.conditions != rule_media_query.conditions
-                          end
+        needs_new_block = _needs_new_media_block?(current_media_query, current_media_query_list_id, rule_media_query,
+                                                  rule_media_query_list_id)
 
         if needs_new_block
           if in_media_block
@@ -640,6 +650,14 @@ module Cataract
 
   # Helper: serialize a rule with nested children (formatted)
   def self._serialize_rule_with_nesting_formatted(result, rule, rule_children, indent, media_queries)
+    # Check if this is an AtRule - it can never have nested children of its
+    # own via rule_children (only Rule participates in CSS nesting), so it
+    # always serializes the same way regardless of has_nesting
+    if rule.is_a?(AtRule)
+      _serialize_at_rule_formatted(result, rule, indent)
+      return
+    end
+
     # Selector line with opening brace
     result << indent
     result << rule.selector
@@ -650,29 +668,32 @@ module Cataract
       _serialize_declarations_formatted(result, rule.declarations, "#{indent}  ")
     end
 
-    # Get nested children
-    children = rule_children[rule.id] || []
+    _serialize_children_formatted(result, rule.selector, rule_children[rule.id] || [], rule_children, media_queries, "#{indent}  ")
 
-    # Serialize nested children
-    children.each do |child|
-      nested_selector = _reconstruct_nested_selector(rule.selector, child.selector, child.nesting_style)
+    # Closing brace
+    result << indent
+    result << "}\n"
+  end
 
+  # Helper: recursively serialize a rule's nested children with indentation.
+  # CSS nesting can go as deep as the parser allows (MAX_PARSE_DEPTH), so this
+  # recurses rather than hand-unrolling a fixed number of levels - a nested
+  # rule's own nested rules are found the same way its parent's were, via
+  # rule_children[id], with the indent growing by one level each call.
+  def self._serialize_children_formatted(result, parent_selector, children, rule_children, media_queries, indent)
+    children.each do |child|
       if child.nesting_style.nil? && child.media_query_id && media_queries[child.media_query_id]
         # Nested @media
         mq = media_queries[child.media_query_id]
-        media_query_string = if mq.conditions
-                               mq.type == :all ? mq.conditions : "#{mq.type} and #{mq.conditions}"
-                             else
-                               mq.type.to_s
-                             end
+        media_query_string = _build_media_query_string(mq, nil, nil, media_queries)
         result << indent
-        result << "  @media #{media_query_string} {\n"
+        result << "@media #{media_query_string} {\n"
 
         unless child.declarations.empty?
-          _serialize_declarations_formatted(result, child.declarations, "#{indent}    ")
+          _serialize_declarations_formatted(result, child.declarations, "#{indent}  ")
         end
 
-        # Recursively handle media children
+        # Handle nested media children
         media_children = rule_children[child.id] || []
         media_children.each do |media_child|
           nested_media_selector = _reconstruct_nested_selector(
@@ -682,51 +703,34 @@ module Cataract
           )
 
           result << indent
-          result << "    #{nested_media_selector} {\n"
+          result << "  #{nested_media_selector} {\n"
           unless media_child.declarations.empty?
-            _serialize_declarations_formatted(result, media_child.declarations, "#{indent}      ")
+            _serialize_declarations_formatted(result, media_child.declarations, "#{indent}    ")
           end
           result << indent
-          result << "    }\n"
+          result << "  }\n"
         end
 
         result << indent
-        result << "  }\n"
+        result << "}\n"
       else
         # Regular nested selector
+        nested_selector = _reconstruct_nested_selector(parent_selector, child.selector, child.nesting_style)
+
         result << indent
-        result << "  #{nested_selector} {\n"
+        result << "#{nested_selector} {\n"
 
         unless child.declarations.empty?
-          _serialize_declarations_formatted(result, child.declarations, "#{indent}    ")
+          _serialize_declarations_formatted(result, child.declarations, "#{indent}  ")
         end
 
-        # Recursively handle grandchildren
-        grandchildren = rule_children[child.id] || []
-        grandchildren.each do |grandchild|
-          nested_grandchild_selector = _reconstruct_nested_selector(
-            child.selector,
-            grandchild.selector,
-            grandchild.nesting_style
-          )
-
-          result << indent
-          result << "    #{nested_grandchild_selector} {\n"
-          unless grandchild.declarations.empty?
-            _serialize_declarations_formatted(result, grandchild.declarations, "#{indent}      ")
-          end
-          result << indent
-          result << "    }\n"
-        end
+        # Recurse into this child's own nested children, however deep they go
+        _serialize_children_formatted(result, child.selector, rule_children[child.id] || [], rule_children, media_queries, "#{indent}  ")
 
         result << indent
-        result << "  }\n"
+        result << "}\n"
       end
     end
-
-    # Closing brace
-    result << indent
-    result << "}\n"
   end
 
   # Helper: serialize a single rule with formatting
@@ -788,7 +792,8 @@ module Cataract
   end
 
   # Mark helper methods as private (public APIs: stylesheet_to_s, stylesheet_to_formatted_s)
-  private_class_method :_build_media_query_string, :_stylesheet_to_s_without_nesting, :_serialize_rule_with_nesting,
+  private_class_method :_build_media_query_string, :_needs_new_media_block?, :_stylesheet_to_s_without_nesting,
+                       :_serialize_rule_with_nesting,
                        :_reconstruct_nested_selector, :_find_groupable_selectors, :_declarations_equal?,
                        :_serialize_rule, :_serialize_declarations, :_serialize_declarations_formatted,
                        :_serialize_at_rule, :_stylesheet_to_formatted_s_without_nesting, :_serialize_rule_with_nesting_formatted,

data/lib/cataract/pure/specificity.rb

@@ -4,6 +4,10 @@
 # NO REGEXP ALLOWED - char-by-char parsing only
 
 module Cataract
+  # Legacy CSS2 pseudo-elements written with a single colon (e.g. :before)
+  # that must still be counted as pseudo-elements, not pseudo-classes.
+  PSEUDO_ELEMENT_KEYWORDS = %w[before after first-line first-letter selection].freeze
+
   # Calculate CSS specificity for a selector
   #
   # @param selector [String] CSS selector
@@ -27,180 +31,132 @@ module Cataract
     i = 0
     len = selector.length
 
-    pseudo_element_kwords = %w[before after first-line first-letter selection]
-
     while i < len
       byte = selector.getbyte(i)
 
-      # Skip whitespace and combinators
-      if byte == BYTE_SPACE || byte == BYTE_TAB || byte == BYTE_NEWLINE || byte == BYTE_CR ||
-         byte == BYTE_GT || byte == BYTE_PLUS || byte == BYTE_TILDE || byte == BYTE_COMMA
-        i += 1
-        next
-      end
-
-      # ID selector: #id
       if byte == BYTE_HASH
         id_count += 1
-        i += 1
-        # Skip the identifier
-        while i < len && ident_char?(selector.getbyte(i))
-          i += 1
-        end
-        next
-      end
-
-      # Class selector: .class
-      if byte == BYTE_DOT
+        i = skip_identifier(selector, i + 1, len)
+      elsif byte == BYTE_DOT
         class_count += 1
-        i += 1
-        # Skip the identifier
-        while i < len && ident_char?(selector.getbyte(i))
-          i += 1
-        end
-        next
-      end
-
-      # Attribute selector: [attr]
-      if byte == BYTE_LBRACKET
+        i = skip_identifier(selector, i + 1, len)
+      elsif byte == BYTE_LBRACKET
         attr_count += 1
-        i += 1
-        # Skip to closing bracket
-        bracket_depth = 1
-        while i < len && bracket_depth > 0
-          b = selector.getbyte(i)
-          if b == BYTE_LBRACKET
-            bracket_depth += 1
-          elsif b == BYTE_RBRACKET
-            bracket_depth -= 1
-          end
-          i += 1
-        end
-        next
-      end
-
-      # Pseudo-element (::) or pseudo-class (:)
-      if byte == BYTE_COLON
-        i += 1
-        is_pseudo_element = false
-
-        # Check for double colon (::)
-        if i < len && selector.getbyte(i) == BYTE_COLON
-          is_pseudo_element = true
-          i += 1
-        end
-
-        # Extract pseudo name
-        pseudo_start = i
-        while i < len && ident_char?(selector.getbyte(i))
-          i += 1
-        end
-        pseudo_name = selector[pseudo_start...i]
-
-        # Check for legacy pseudo-elements (single colon but should be double)
-        is_legacy_pseudo_element = false
-        if !is_pseudo_element && !pseudo_name.empty?
-          is_legacy_pseudo_element = pseudo_element_kwords.include?(pseudo_name)
-        end
-
-        # Check for :not() - it doesn't count itself, but its content does
-        is_not = (pseudo_name == 'not')
-
-        # Skip function arguments if present
-        if i < len && selector.getbyte(i) == BYTE_LPAREN
-          i += 1
-          paren_depth = 1
-
-          # If it's :not(), calculate specificity of the content
-          if is_not
-            not_content_start = i
-
-            # Find closing paren
-            while i < len && paren_depth > 0
-              b = selector.getbyte(i)
-              if b == BYTE_LPAREN
-                paren_depth += 1
-              elsif b == BYTE_RPAREN
-                paren_depth -= 1
-              end
-              i += 1 if paren_depth > 0
-            end
-
-            not_content = selector[not_content_start...i]
-
-            # Recursively calculate specificity of :not() content
-            unless not_content.empty?
-              not_specificity = calculate_specificity(not_content)
-
-              # Add :not() content's specificity to our counts
-              additional_a = not_specificity / 100
-              additional_b = (not_specificity % 100) / 10
-              additional_c = not_specificity % 10
-
-              id_count += additional_a
-              class_count += additional_b
-              element_count += additional_c
-            end
-
-            i += 1 # Skip closing paren
-          else
-            # Skip other function arguments
-            while i < len && paren_depth > 0
-              b = selector.getbyte(i)
-              if b == BYTE_LPAREN
-                paren_depth += 1
-              elsif b == BYTE_RPAREN
-                paren_depth -= 1
-              end
-              i += 1
-            end
-
-            # Count the pseudo-class/element
-            if is_pseudo_element || is_legacy_pseudo_element
-              pseudo_element_count += 1
-            else
-              pseudo_class_count += 1
-            end
-          end
-        else
-          # No function arguments - count the pseudo-class/element
-          if is_not
-            # :not without parens is invalid, but don't count it
-          elsif is_pseudo_element || is_legacy_pseudo_element
+        i = skip_attribute_selector(selector, i, len)
+      elsif byte == BYTE_COLON
+        i, is_not, not_content, counts_as_element = parse_pseudo(selector, i, len)
+        if not_content
+          # :not() doesn't count itself, but its content does
+          not_specificity = calculate_specificity(not_content)
+          id_count += not_specificity / 100
+          class_count += (not_specificity % 100) / 10
+          element_count += not_specificity % 10
+        elsif !is_not
+          if counts_as_element
             pseudo_element_count += 1
           else
             pseudo_class_count += 1
           end
         end
-        next
-      end
-
-      # Universal selector: *
-      if byte == BYTE_ASTERISK
-        # Universal selector has specificity 0, don't count
+      elsif letter?(byte)
+        element_count += 1
+        i = skip_identifier(selector, i + 1, len)
+      else
+        # Whitespace, combinators, and the universal selector (*) all have
+        # zero specificity - just skip a single byte.
         i += 1
-        next
       end
+    end
 
-      # Type selector (element name): div, span, etc.
-      if letter?(byte)
-        element_count += 1
-        # Skip the identifier
-        while i < len && ident_char?(selector.getbyte(i))
-          i += 1
-        end
-        next
-      end
+    # Calculate specificity using W3C formula
+    (id_count * 100) +
+      ((class_count + attr_count + pseudo_class_count) * 10) +
+      ((element_count + pseudo_element_count) * 1)
+  end
+
+  # Advances past an identifier (used after #id, .class, element names, and
+  # pseudo names), returning the index of the first non-identifier byte.
+  def self.skip_identifier(selector, pos, len)
+    pos += 1 while pos < len && ident_char?(selector.getbyte(pos))
+    pos
+  end
+  private_class_method :skip_identifier
 
-      # Unknown character, skip it
-      i += 1
+  # Advances past a bracketed [attr] selector, honoring nested brackets,
+  # returning the index just after the matching closing bracket.
+  def self.skip_attribute_selector(selector, pos, len)
+    skip_balanced(selector, pos + 1, len, BYTE_LBRACKET, BYTE_RBRACKET)
+  end
+  private_class_method :skip_attribute_selector
+
+  # Advances past a balanced open/close byte pair (already past the opening
+  # byte, with depth 1), returning the index just after the matching close.
+  def self.skip_balanced(selector, pos, len, open_byte, close_byte)
+    depth = 1
+    while pos < len && depth > 0
+      b = selector.getbyte(pos)
+      depth += 1 if b == open_byte
+      depth -= 1 if b == close_byte
+      pos += 1
+    end
+    pos
+  end
+  private_class_method :skip_balanced
+
+  # Advances past a balanced open/close byte pair (already past the opening
+  # byte, with depth 1), returning the index OF the matching close byte
+  # (rather than past it), so the caller can capture the content in between.
+  def self.find_balanced_close(selector, pos, len, open_byte, close_byte)
+    depth = 1
+    while pos < len && depth > 0
+      b = selector.getbyte(pos)
+      depth += 1 if b == open_byte
+      depth -= 1 if b == close_byte
+      pos += 1 if depth > 0
+    end
+    pos
+  end
+  private_class_method :find_balanced_close
+
+  # Parses a :pseudo-class, ::pseudo-element, or :not(...) token starting at
+  # the colon byte. Returns [new_pos, is_not, not_content, counts_as_element]:
+  # - new_pos: index just after the fully-consumed token (incl. any (...) args)
+  # - is_not: whether this token is :not (which never counts itself)
+  # - not_content: the non-empty content of :not(...), or nil otherwise
+  # - counts_as_element: whether this token counts toward pseudo-elements
+  #   (::foo, or a legacy single-colon pseudo-element like :before) rather
+  #   than pseudo-classes
+  def self.parse_pseudo(selector, pos, len)
+    pos += 1
+    is_pseudo_element = false
+    if pos < len && selector.getbyte(pos) == BYTE_COLON
+      is_pseudo_element = true
+      pos += 1
     end
 
-    # Calculate specificity using W3C formula
-    specificity = (id_count * 100) +
-                  ((class_count + attr_count + pseudo_class_count) * 10) +
-                  ((element_count + pseudo_element_count) * 1)
+    pseudo_start = pos
+    pos = skip_identifier(selector, pos, len)
+    pseudo_name = selector[pseudo_start...pos]
+
+    is_legacy_pseudo_element = !is_pseudo_element && !pseudo_name.empty? &&
+                               PSEUDO_ELEMENT_KEYWORDS.include?(pseudo_name)
+    is_not = (pseudo_name == 'not')
+    not_content = nil
+
+    if pos < len && selector.getbyte(pos) == BYTE_LPAREN
+      pos += 1
+      if is_not
+        content_start = pos
+        pos = find_balanced_close(selector, pos, len, BYTE_LPAREN, BYTE_RPAREN)
+        content = selector[content_start...pos]
+        not_content = content unless content.empty?
+        pos += 1 # Skip closing paren
+      else
+        pos = skip_balanced(selector, pos, len, BYTE_LPAREN, BYTE_RPAREN)
+      end
+    end
 
-    specificity
+    [pos, is_not, not_content, is_pseudo_element || is_legacy_pseudo_element]
   end
+  private_class_method :parse_pseudo
 end