parselly 1.2.0 → 1.3.0

data/lib/parselly/parser.rb

@@ -656,52 +656,125 @@ end
 require 'set'
 
 # Pre-computed sets for faster lookup
-CAN_END_COMPOUND = Set[:IDENT, :STAR, :RPAREN, :RBRACKET].freeze
+CAN_END_COMPOUND = Set[:IDENT, :STAR, :RPAREN, :RBRACKET, :NUMBER].freeze
 CAN_START_COMPOUND = Set[:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].freeze
-TYPE_SELECTOR_TYPES = Set[:IDENT, :STAR].freeze
-SUBCLASS_SELECTOR_TYPES = Set[:DOT, :HASH, :LBRACKET, :COLON].freeze
-SUBCLASS_SELECTOR_END_TYPES = Set[:IDENT, :RBRACKET, :RPAREN].freeze
 NTH_PSEUDO_NAMES = Set['nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type', 'nth-col', 'nth-last-col'].freeze
-AN_PLUS_B_REGEX = /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/.freeze
+AN_PLUS_B_REGEX = /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/i.freeze
+SELECTOR_LIST_PSEUDO_NAMES = Set['is', 'where', 'not'].freeze
+RELATIVE_SELECTOR_LIST_PSEUDO_NAMES = Set['has'].freeze
+LEGACY_PSEUDO_ELEMENT_NAMES = Set['before', 'after', 'first-line', 'first-letter'].freeze
+ATTRIBUTE_MODIFIERS = Set['i', 's'].freeze
 
 module Parselly
   class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 279)
-def parse(input, tolerant: false)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 425)
+def parse(input, tolerant: false, max_length: nil, max_tokens: nil, max_depth: nil, freeze: false)
   @tolerant = tolerant
   @errors = []
   @error_index = nil
   @suppress_errors = false
+  @max_depth = max_depth
+  @freeze_tree = freeze
+
+  unless input.is_a?(String)
+    error = parse_error('Input must be a String', { line: 1, column: 1, offset: 0 })
+    return Parselly::ParseResult.new(nil, [error]) if tolerant
+
+    raise Parselly::ParseError, error
+  end
+
+  if max_length && input.length > max_length
+    error = parse_error("Input exceeds max_length #{max_length}", { line: 1, column: 1, offset: 0 })
+    return Parselly::ParseResult.new(nil, [error]) if tolerant
+
+    raise Parselly::ParseError, error
+  end
+
   @lexer = Parselly::Lexer.new(input)
   begin
     @tokens = @lexer.tokenize
-  rescue RuntimeError => e
+  rescue Parselly::ParseError, RuntimeError => e
     if tolerant
       @errors << parse_error_from_exception(e)
       return Parselly::ParseResult.new(nil, @errors)
     end
     raise
   end
+
+  if max_tokens && @tokens.size > max_tokens
+    error = parse_error("Input exceeds max_tokens #{max_tokens}", @tokens[max_tokens][2])
+    return Parselly::ParseResult.new(nil, [error]) if tolerant
+
+    raise Parselly::ParseError, error
+  end
+
   preprocess_tokens!
   @index = 0
   @current_position = { line: 1, column: 1, offset: 0 }
 
   if tolerant
     ast = parse_with_recovery
-    normalize_an_plus_b(ast) if ast
+    ast = validate_or_recover_tolerant_ast(ast) if ast
+    ast.freeze_tree if ast && @freeze_tree
     return Parselly::ParseResult.new(ast, @errors)
   end
 
   ast = do_parse
-  normalize_an_plus_b(ast)
+  finalize_ast(ast)
+  ast.freeze_tree if @freeze_tree
   ast
 end
 
 def parse_with_recovery
   do_parse
 rescue Parselly::ParseError, RuntimeError
-  parse_partial_ast
+  parse_selector_list_recovery || parse_partial_ast
+end
+
+def validate_or_recover_tolerant_ast(ast)
+  finalize_ast(ast)
+  ast
+rescue Parselly::ParseError => e
+  @errors << parse_error_from_exception(e)
+  parse_selector_list_recovery(validate: true) || ast
+end
+
+def parse_selector_list_recovery(validate: false)
+  return nil unless @tokens && @tokens.any? { |token| token[0] == :COMMA }
+
+  eof_token = @tokens.last if @tokens.last && @tokens.last[0] == false
+  body_tokens = eof_token ? @tokens[0...-1] : @tokens
+  segments = []
+  current = []
+
+  body_tokens.each do |token|
+    if token[0] == :COMMA
+      segments << current
+      current = []
+    else
+      current << token
+    end
+  end
+  segments << current
+
+  result = Node.new(:selector_list, nil, body_tokens.first&.[](2) || { line: 1, column: 1, offset: 0 })
+  recovered = false
+
+  segments.each do |segment|
+    next if segment.empty?
+
+    begin
+      parsed = parse_from_tokens(segment + [eof_token || [false, nil, segment.last[2]]], suppress_errors: true)
+      finalize_ast(parsed) if validate
+      result.add_child(parsed)
+      recovered = true
+    rescue Parselly::ParseError, RuntimeError
+      next
+    end
+  end
+
+  recovered ? result : nil
 end
 
 def parse_partial_ast
@@ -735,6 +808,8 @@ ensure
 end
 
 def parse_error_from_exception(error)
+  return error.error if error.respond_to?(:error)
+
   line = nil
   column = nil
   offset = nil
@@ -748,17 +823,61 @@ def parse_error_from_exception(error)
   { message: error.message, line: line, column: column, offset: offset }
 end
 
-def identifier_value(token)
+def parse_error(message, position)
+  {
+    message: message,
+    line: position[:line],
+    column: position[:column],
+    offset: position[:offset]
+  }.tap do |error|
+    error[:end_line] = position[:end_line] if position.key?(:end_line)
+    error[:end_column] = position[:end_column] if position.key?(:end_column)
+    error[:end_offset] = position[:end_offset] if position.key?(:end_offset)
+  end
+end
+
+def token_value(token)
   token.respond_to?(:value) ? token.value : token
 end
 
-def identifier_raw(token)
-  token.respond_to?(:raw) ? token.raw : token
+def token_raw(token)
+  token.respond_to?(:raw) ? token.raw : token_value(token)
+end
+
+def token_position(token)
+  token.respond_to?(:position) && token.position ? token.position : @current_position
+end
+
+def token_quote(token)
+  token.respond_to?(:quote) ? token.quote : nil
+end
+
+def pseudo_name(name)
+  name.to_s.downcase
+end
+
+def attribute_modifier_value(token)
+  modifier = token_value(token).to_s
+  normalized_modifier = modifier.downcase
+  return normalized_modifier if ATTRIBUTE_MODIFIERS.include?(normalized_modifier)
+
+  raise_syntax_error("Parse error: invalid attribute modifier '#{modifier}'", token_position(token))
+end
+
+def raise_syntax_error(message, position)
+  error = parse_error(message, position)
+  if @tolerant
+    @errors << error unless @suppress_errors
+    @error_index ||= [@index - 1, 0].max
+  end
+  raise Parselly::SyntaxError, error
 end
 
 def preprocess_tokens!
   return if @tokens.size <= 1
 
+  mark_nth_of_tokens!
+
   new_tokens = Array.new(@tokens.size + (@tokens.size / 2)) # Pre-allocate with conservative estimate
   new_tokens_idx = 0
 
@@ -770,7 +889,7 @@ def preprocess_tokens!
     if i < last_idx
       next_token = @tokens[i + 1]
       if needs_descendant?(token, next_token)
-        pos = { line: token[2][:line], column: token[2][:column], offset: token[2][:offset] }
+        pos = next_token[2]
         new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
         new_tokens_idx += 1
       end
@@ -780,38 +899,129 @@ def preprocess_tokens!
   @tokens = new_tokens.first(new_tokens_idx)
 end
 
-# Insert DESCENDANT combinator if:
-# - Current token can end a compound selector
-# - Next token can start a compound selector
-# - EXCEPT when current is type_selector and next is subclass_selector
-#   (they belong to the same compound selector)
+def mark_nth_of_tokens!
+  paren_depth = 0
+  last_idx = @tokens.size - 1
+
+  @tokens.each_with_index do |token, index|
+    case token[0]
+    when :LPAREN
+      paren_depth += 1
+    when :RPAREN
+      paren_depth -= 1 if paren_depth.positive?
+    when :IDENT
+      next unless paren_depth.positive?
+      next unless token_value(token[1]) == 'of'
+      next if index.zero? || index >= last_idx
+
+      previous_token = @tokens[index - 1]
+      next_token = @tokens[index + 1]
+      if token_gap?(previous_token, token) && token_gap?(token, next_token) &&
+         CAN_START_COMPOUND.include?(next_token[0])
+        token[0] = :OF
+      end
+    end
+  end
+end
+
+# Insert DESCENDANT combinator only when actual ignored input
+# (CSS whitespace or comments) separated two compound selector tokens.
 def needs_descendant?(current, next_tok)
   current_type = current[0]
   next_type = next_tok[0]
 
-  # Type selector followed by subclass selector = same compound
-  # Subclass selector followed by subclass selector = same compound
-  if SUBCLASS_SELECTOR_TYPES.include?(next_type)
-    return false if TYPE_SELECTOR_TYPES.include?(current_type) ||
-                    SUBCLASS_SELECTOR_END_TYPES.include?(current_type)
-  end
+  CAN_END_COMPOUND.include?(current_type) &&
+    CAN_START_COMPOUND.include?(next_type) &&
+    token_gap?(current, next_tok)
+end
+
+def token_gap?(current, next_tok)
+  current_end = current[2][:end_offset] || current[2][:offset]
+  next_tok[2][:offset] > current_end
+end
 
-  CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
+def finalize_ast(node)
+  validate_known_pseudo_functions!(node)
+  validate_max_depth!(node) if @max_depth
 end
 
-def normalize_an_plus_b(node)
+def validate_known_pseudo_functions!(node)
   return unless node.respond_to?(:children) && node.children
 
-  if node.type == :pseudo_function && NTH_PSEUDO_NAMES.include?(node.value)
-    child = node.children.first
-    if child&.type == :selector_list
-      an_plus_b_value = extract_an_plus_b_value(child)
-      if an_plus_b_value
-        node.replace_child(0, Node.new(:an_plus_b, an_plus_b_value, child.position))
-      end
+  if node.type == :pseudo_function
+    name = pseudo_name(node.value)
+    validate_nth_pseudo!(node) if NTH_PSEUDO_NAMES.include?(name)
+    validate_selector_list_pseudo!(node) if SELECTOR_LIST_PSEUDO_NAMES.include?(name)
+    validate_relative_selector_list_pseudo!(node) if RELATIVE_SELECTOR_LIST_PSEUDO_NAMES.include?(name)
+  end
+
+  node.children.compact.each { |child| validate_known_pseudo_functions!(child) }
+end
+
+def validate_nth_pseudo!(node)
+  child = node.children.first
+  return if child&.type == :an_plus_b
+  return if child&.type == :nth_selector_argument
+
+  raise Parselly::SyntaxError, parse_error(
+    "Parse error: invalid argument for :#{node.value}()",
+    child&.position || node.position
+  )
+end
+
+def validate_selector_list_pseudo!(node)
+  child = node.children.first
+  return if child&.type == :selector_list && !relative_selector_list?(child)
+
+  raise Parselly::SyntaxError, parse_error(
+    "Parse error: invalid argument for :#{node.value}()",
+    child&.position || node.position
+  )
+end
+
+def validate_relative_selector_list_pseudo!(node)
+  child = node.children.first
+  return if child&.type == :selector_list
+
+  raise Parselly::SyntaxError, parse_error(
+    "Parse error: invalid argument for :#{node.value}()",
+    child&.position || node.position
+  )
+end
+
+def relative_selector_list?(node)
+  node.type == :selector_list &&
+    node.children.any? { |child| relative_selector?(child) }
+end
+
+def relative_selector?(node)
+  node.type == :selector && node.children.first &&
+    node.children.first.type.to_s.end_with?('_combinator')
+end
+
+def validate_max_depth!(node)
+  stack = [[node, 1]]
+
+  until stack.empty?
+    current, depth = stack.pop
+    if depth > @max_depth
+      raise Parselly::ParseError, parse_error(
+        "Input exceeds max_depth #{@max_depth}",
+        current.position
+      )
     end
+    current.children.each { |child| stack << [child, depth + 1] }
   end
-  node.children.compact.each { |child| normalize_an_plus_b(child) }
+end
+
+def normalize_pseudo_argument(name, argument)
+  return argument unless NTH_PSEUDO_NAMES.include?(pseudo_name(name))
+  return argument unless argument&.type == :selector_list
+
+  an_plus_b_value = extract_an_plus_b_value(argument)
+  return argument unless an_plus_b_value
+
+  Node.new(:an_plus_b, an_plus_b_value, argument.position, raw_value: an_plus_b_value)
 end
 
 def extract_an_plus_b_value(selector_list_node)
@@ -834,205 +1044,248 @@ def next_token
   @index += 1
   @current_position = token_position
 
-  [token_type, token_value]
+  [token_type, parser_token_value(token_value, token_position)]
+end
+
+def parser_token_value(value, position)
+  if value.respond_to?(:position)
+    value.position ||= position if value.respond_to?(:position=)
+    return value
+  end
+
+  Parselly::Lexer::TokenValue.new(value: value, raw: value, position: position)
 end
 
 def on_error(token_id, val, vstack)
   token_name = token_to_str(token_id) || '?'
   pos = @current_position || { line: '?', column: '?' }
-  error = {
-    message: "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[:column]}",
-    line: pos[:line],
-    column: pos[:column],
-    offset: pos[:offset]
-  }
-  if @tolerant
-    @errors << error unless @suppress_errors
-    @error_index ||= [@index - 1, 0].max
-    raise Parselly::ParseError, error
-  end
-  raise error[:message]
+  raise_syntax_error("Parse error: unexpected #{token_name} '#{token_value(val)}' at #{pos[:line]}:#{pos[:column]}", pos)
 end
 ...end parser.y/module_eval...
 ##### State transition tables begin ###
 
 racc_action_table = [
-    45,    47,    50,    14,    15,     8,    16,    55,    18,    70,
-    17,    69,    25,    26,    27,    28,    57,    58,    59,    60,
-    61,    62,    51,    45,    47,    50,    14,    15,     8,    16,
-    37,    19,    80,    17,    33,    25,    26,    27,    28,    34,
-    38,    81,    83,     7,    35,    51,    14,    15,     8,    16,
-    36,    84,    92,    17,    33,    25,    26,    27,    28,    65,
-     7,    93,    39,    14,    15,     8,    16,    19,    66,    32,
-    17,    33,    14,    15,    63,    16,    64,     7,    67,    17,
-    14,    15,     8,    16,    68,     7,    71,    17,    14,    15,
-     8,    16,    78,    32,    79,    17,    14,    15,    82,    16,
-    71,     7,    87,    17,    14,    15,     8,    16,    76,    75,
-    88,    17,    25,    26,    27,    28,    25,    26,    27,    28,
-    89,    90,    91,    94,    95,    96,    97 ]
+     7,    19,    41,    20,   106,    15,    16,     8,    17,    42,
+     7,    44,    18,   -62,   107,    15,    16,     8,    17,   109,
+    36,    34,    18,    45,    90,     7,     9,    37,    43,   110,
+    15,    16,     8,    17,    91,    34,     9,    18,    75,    78,
+    35,    82,    52,    15,    16,     8,    17,   116,    38,    53,
+    18,     9,    26,    27,    28,    29,    30,   117,    71,    70,
+     7,    72,    54,    83,     9,    15,    16,     8,    17,    55,
+    39,    46,    18,    75,    78,    20,    82,    64,    15,    16,
+     8,    17,    65,    66,    67,    18,     9,    26,    27,    28,
+    29,    30,    68,    96,    73,     7,    95,    74,    83,     9,
+    15,    16,     8,    17,    87,    89,    92,    18,   -61,    26,
+    27,    28,    29,    30,    93,    94,    97,     7,   102,   103,
+   104,     9,    15,    16,     8,    17,    56,   108,    97,    18,
+   113,    26,    27,    28,    29,    30,    58,    59,    60,    61,
+    62,    63,   114,     9,    15,    16,   115,    17,   118,    15,
+    16,    18,    17,   119,   120,   121,    18,    26,    27,    28,
+    29,    30,    26,    27,    28,    29,    30 ]
 
 racc_action_check = [
-    33,    33,    33,    33,    33,    33,    33,    36,     1,    51,
-    33,    51,    33,    33,    33,    33,    36,    36,    36,    36,
-    36,    36,    33,    63,    63,    63,    63,    63,    63,    63,
-    17,     2,    68,    63,     7,    63,    63,    63,    63,    14,
-    17,    68,    70,    71,    15,    63,    71,    71,    71,    71,
-    16,    70,    82,    71,    45,    71,    71,    71,    71,    45,
-     0,    82,    18,     0,     0,     0,     0,    20,    45,     4,
-     0,    32,     4,     4,    37,     4,    38,    19,    46,     4,
-    19,    19,    19,    19,    50,    22,    52,    19,    22,    22,
-    22,    22,    65,    30,    66,    22,    30,    30,    69,    30,
-    72,    54,    75,    30,    54,    54,    54,    54,    56,    56,
-    76,    54,     3,     3,     3,     3,    23,    23,    23,    23,
-    77,    80,    81,    83,    84,    92,    93 ]
+     0,     1,    17,     2,    94,     0,     0,     0,     0,    17,
+    20,    18,     0,    75,    94,    20,    20,    20,    20,    96,
+     9,     7,    20,    18,    75,    23,     0,     9,    17,    96,
+    23,    23,    23,    23,    75,    75,    20,    23,    67,    67,
+     8,    67,    34,    67,    67,    67,    67,   108,    15,    34,
+    67,    23,    67,    67,    67,    67,    67,   108,    57,    57,
+    86,    57,    35,    67,    67,    86,    86,    86,    86,    35,
+    16,    19,    86,    87,    87,    21,    87,    41,    87,    87,
+    87,    87,    42,    43,    44,    87,    86,    87,    87,    87,
+    87,    87,    45,    83,    64,    93,    83,    65,    87,    87,
+    93,    93,    93,    93,    68,    69,    76,    93,    79,    93,
+    93,    93,    93,    93,    81,    82,    84,    97,    88,    90,
+    91,    93,    97,    97,    97,    97,    40,    95,    98,    97,
+   101,    97,    97,    97,    97,    97,    40,    40,    40,    40,
+    40,    40,   106,    97,     4,     4,   107,     4,   109,    32,
+    32,     4,    32,   110,   116,   117,    32,     3,     3,     3,
+     3,     3,    24,    24,    24,    24,    24 ]
 
 racc_action_pointer = [
-    58,     8,    18,    98,    67,   nil,   nil,    24,   nil,   nil,
-   nil,   nil,   nil,   nil,    37,    42,    48,    28,    62,    75,
-    54,   nil,    83,   102,   nil,   nil,   nil,   nil,   nil,   nil,
-    91,   nil,    61,    -2,   nil,   nil,    -2,    64,    74,   nil,
-   nil,   nil,   nil,   nil,   nil,    44,    67,   nil,   nil,   nil,
-    82,     7,    73,   nil,    99,   nil,   106,   nil,   nil,   nil,
-   nil,   nil,   nil,    21,   nil,    88,    90,   nil,    17,    96,
-    27,    41,    87,   nil,   nil,    93,   101,   109,   nil,   nil,
-   117,   118,    37,   119,   120,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   121,   122,   nil,   nil,   nil,   nil ]
+    -2,     1,   -12,   141,   137,   nil,   nil,    -7,    12,    18,
+   nil,   nil,   nil,   nil,   nil,    46,    68,     0,     9,    71,
+     8,    60,   nil,    23,   146,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   142,   nil,    40,    60,   nil,   nil,   nil,   nil,
+   115,    49,    54,    81,    72,    90,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    56,   nil,   nil,
+   nil,   nil,   nil,   nil,    92,    95,   nil,    36,    92,   103,
+   nil,   nil,   nil,   nil,   nil,     7,    93,   nil,   nil,   102,
+   nil,   108,   113,    91,   101,   nil,    58,    71,   107,   nil,
+   114,   115,   nil,    93,   -13,   125,     2,   115,   113,   nil,
+   nil,   117,   nil,   nil,   nil,   nil,   137,   141,    30,   143,
+   148,   nil,   nil,   nil,   nil,   nil,   149,   150,   nil,   nil,
+   nil,   nil ]
 
 racc_action_default = [
-   -62,   -62,    -2,    -6,   -16,   -14,   -15,   -19,   -20,   -21,
-   -22,   -23,   -24,   -25,   -62,   -62,   -62,   -62,   -62,   -62,
-    -2,    -4,   -62,    -6,    -8,    -9,   -10,   -11,   -12,   -13,
-   -16,   -18,   -62,   -62,   -26,   -27,   -62,   -37,   -62,    98,
-    -1,    -3,    -5,    -7,   -17,   -19,   -62,   -41,   -42,   -43,
-   -55,   -62,   -57,   -60,   -62,   -28,   -62,   -31,   -32,   -33,
-   -34,   -35,   -36,   -62,   -40,   -62,   -62,   -39,   -46,   -62,
-   -54,   -62,   -57,   -59,   -61,   -62,   -62,   -62,   -47,   -48,
-   -62,   -62,   -51,   -62,   -62,   -56,   -58,   -29,   -30,   -38,
-   -44,   -45,   -62,   -62,   -52,   -53,   -49,   -50 ]
+   -81,   -81,    -2,    -6,   -17,   -15,   -16,   -20,   -21,   -81,
+   -28,   -29,   -30,   -31,   -32,   -81,   -81,   -81,   -81,   -81,
+   -81,    -2,    -4,   -81,    -6,    -8,    -9,   -10,   -11,   -12,
+   -13,   -14,   -17,   -19,   -81,   -81,   -24,   -27,   -33,   -34,
+   -81,   -37,   -81,   -81,   -52,   -81,   122,    -1,    -3,    -5,
+    -7,   -18,   -22,   -25,   -23,   -26,   -35,   -81,   -41,   -42,
+   -43,   -44,   -45,   -46,   -81,   -81,   -40,   -81,   -54,   -50,
+   -47,   -48,   -49,   -38,   -39,   -20,   -81,   -56,   -57,   -58,
+   -59,   -81,   -74,   -81,   -76,   -79,   -81,   -81,   -81,   -51,
+   -81,   -81,   -53,   -81,   -65,   -81,   -73,   -81,   -76,   -78,
+   -80,   -81,   -36,   -66,   -67,   -60,   -81,   -81,   -70,   -81,
+   -81,   -75,   -77,   -55,   -63,   -64,   -81,   -81,   -71,   -72,
+   -68,   -69 ]
 
 racc_goto_table = [
-     2,    46,    30,    31,    22,    24,    73,     1,    42,    21,
-    29,    56,    85,   nil,   nil,   nil,   nil,   nil,   nil,    40,
-   nil,   nil,   nil,   nil,    22,    43,    86,    41,    30,    44,
-   nil,    77,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     2,    32,    33,    23,    25,    99,    76,     1,    22,    49,
+    31,    40,    57,    69,    88,   105,   111,   nil,   nil,   112,
+    47,   nil,   nil,   nil,    23,    50,   101,    48,   nil,    32,
+    51,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    74 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   100 ]
 
 racc_goto_check = [
-     2,    20,    12,    13,     6,     8,    25,     1,     5,     4,
-    10,    19,    23,   nil,   nil,   nil,   nil,   nil,   nil,     2,
-   nil,   nil,   nil,   nil,     6,     8,    25,     4,    12,    13,
-   nil,    20,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     2,    12,    13,     6,     8,    30,    23,     1,     4,     5,
+    10,    19,    20,    21,    22,    26,    28,   nil,   nil,    30,
+     2,   nil,   nil,   nil,     6,     8,    23,     4,   nil,    12,
+    13,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,     2 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,     2 ]
 
 racc_goto_pointer = [
-   nil,     7,     0,   nil,     7,   -14,     1,   nil,     2,   nil,
-     6,   nil,    -2,    -1,   nil,   nil,   nil,   nil,   nil,   -25,
-   -32,   nil,   nil,   -59,   nil,   -46 ]
+   nil,     7,     0,   nil,     6,   -14,     0,   nil,     1,   nil,
+     6,   nil,    -3,    -2,   nil,   nil,   nil,   nil,   nil,    -6,
+   -28,   -44,   -55,   -61,   nil,   nil,   -78,   nil,   -81,   nil,
+   -79 ]
 
 racc_goto_default = [
-   nil,   nil,    53,    20,   nil,     3,    54,    23,   nil,     4,
-   nil,     5,     6,   nil,     9,    10,    11,    12,    13,   nil,
-   nil,    48,    49,    52,    72,   nil ]
+   nil,   nil,    85,    21,   nil,     3,    86,    24,   nil,     4,
+   nil,     5,     6,   nil,    10,    11,    12,    13,    14,   nil,
+   nil,   nil,   nil,   nil,    77,    79,    80,    81,    84,    98,
+   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  2, 29, :_reduce_1,
-  0, 30, :_reduce_2,
-  2, 30, :_reduce_3,
-  2, 27, :_reduce_4,
-  2, 33, :_reduce_5,
-  0, 34, :_reduce_6,
-  2, 34, :_reduce_7,
-  2, 28, :_reduce_8,
-  1, 32, :_reduce_9,
-  1, 32, :_reduce_10,
-  1, 32, :_reduce_11,
-  1, 32, :_reduce_12,
-  2, 31, :_reduce_13,
-  1, 35, :_reduce_14,
-  1, 35, :_reduce_15,
-  0, 39, :_reduce_16,
-  2, 39, :_reduce_17,
-  1, 36, :_reduce_18,
-  1, 37, :_reduce_19,
-  1, 37, :_reduce_20,
-  1, 38, :_reduce_21,
-  1, 38, :_reduce_22,
-  1, 38, :_reduce_23,
-  1, 38, :_reduce_24,
-  1, 38, :_reduce_25,
-  2, 40, :_reduce_26,
+  2, 33, :_reduce_1,
+  0, 34, :_reduce_2,
+  2, 34, :_reduce_3,
+  2, 31, :_reduce_4,
+  2, 37, :_reduce_5,
+  0, 38, :_reduce_6,
+  2, 38, :_reduce_7,
+  2, 32, :_reduce_8,
+  1, 36, :_reduce_9,
+  1, 36, :_reduce_10,
+  1, 36, :_reduce_11,
+  1, 36, :_reduce_12,
+  1, 36, :_reduce_13,
+  2, 35, :_reduce_14,
+  1, 39, :_reduce_15,
+  1, 39, :_reduce_16,
+  0, 43, :_reduce_17,
+  2, 43, :_reduce_18,
+  1, 40, :_reduce_19,
+  1, 41, :_reduce_20,
+  1, 41, :_reduce_21,
+  3, 41, :_reduce_22,
+  3, 41, :_reduce_23,
+  2, 41, :_reduce_24,
+  3, 41, :_reduce_25,
+  3, 41, :_reduce_26,
   2, 41, :_reduce_27,
-  3, 42, :_reduce_28,
-  5, 42, :_reduce_29,
-  5, 42, :_reduce_30,
-  1, 45, :_reduce_31,
-  1, 45, :_reduce_32,
-  1, 45, :_reduce_33,
-  1, 45, :_reduce_34,
-  1, 45, :_reduce_35,
-  1, 45, :_reduce_36,
-  2, 43, :_reduce_37,
-  5, 43, :_reduce_38,
-  4, 43, :_reduce_39,
-  3, 44, :_reduce_40,
-  1, 46, :_reduce_41,
-  1, 46, :_reduce_42,
-  1, 46, :_reduce_43,
-  4, 47, :_reduce_44,
-  4, 47, :_reduce_45,
-  2, 47, :_reduce_46,
-  3, 47, :_reduce_47,
-  3, 47, :_reduce_48,
-  5, 47, :_reduce_49,
-  5, 47, :_reduce_50,
-  3, 47, :_reduce_51,
-  4, 47, :_reduce_52,
-  4, 47, :_reduce_53,
-  2, 47, :_reduce_54,
-  1, 47, :_reduce_55,
-  2, 50, :_reduce_56,
-  0, 51, :_reduce_57,
-  2, 51, :_reduce_58,
-  2, 48, :_reduce_59,
-  1, 49, :_reduce_60,
-  2, 49, :_reduce_61 ]
-
-racc_reduce_n = 62
-
-racc_shift_n = 98
+  1, 42, :_reduce_28,
+  1, 42, :_reduce_29,
+  1, 42, :_reduce_30,
+  1, 42, :_reduce_31,
+  1, 42, :_reduce_32,
+  2, 44, :_reduce_33,
+  2, 45, :_reduce_34,
+  3, 46, :_reduce_35,
+  6, 46, :_reduce_36,
+  1, 49, :_reduce_37,
+  3, 49, :_reduce_38,
+  3, 49, :_reduce_39,
+  2, 49, :_reduce_40,
+  1, 50, :_reduce_41,
+  1, 50, :_reduce_42,
+  1, 50, :_reduce_43,
+  1, 50, :_reduce_44,
+  1, 50, :_reduce_45,
+  1, 50, :_reduce_46,
+  1, 51, :_reduce_47,
+  1, 51, :_reduce_48,
+  1, 51, :_reduce_49,
+  0, 52, :_reduce_50,
+  1, 52, :_reduce_51,
+  2, 47, :_reduce_52,
+  5, 47, :_reduce_53,
+  3, 48, :_reduce_54,
+  6, 48, :_reduce_55,
+  1, 53, :_reduce_56,
+  1, 53, :_reduce_57,
+  1, 53, :_reduce_58,
+  1, 53, :_reduce_59,
+  3, 54, :_reduce_60,
+  1, 57, :_reduce_61,
+  1, 57, :_reduce_62,
+  4, 55, :_reduce_63,
+  4, 55, :_reduce_64,
+  2, 55, :_reduce_65,
+  3, 55, :_reduce_66,
+  3, 55, :_reduce_67,
+  5, 55, :_reduce_68,
+  5, 55, :_reduce_69,
+  3, 55, :_reduce_70,
+  4, 55, :_reduce_71,
+  4, 55, :_reduce_72,
+  2, 55, :_reduce_73,
+  1, 55, :_reduce_74,
+  2, 59, :_reduce_75,
+  0, 60, :_reduce_76,
+  2, 60, :_reduce_77,
+  2, 56, :_reduce_78,
+  1, 58, :_reduce_79,
+  2, 58, :_reduce_80 ]
+
+racc_reduce_n = 81
+
+racc_shift_n = 122
 
 racc_token_table = {
   false => 0,
   :error => 1,
   :IDENT => 2,
   :STRING => 3,
-  :NUMBER => 4,
-  :HASH => 5,
-  :DOT => 6,
-  :STAR => 7,
-  :LBRACKET => 8,
-  :RBRACKET => 9,
-  :LPAREN => 10,
-  :RPAREN => 11,
-  :COLON => 12,
-  :COMMA => 13,
-  :CHILD => 14,
-  :ADJACENT => 15,
-  :SIBLING => 16,
-  :DESCENDANT => 17,
-  :EQUAL => 18,
-  :INCLUDES => 19,
-  :DASHMATCH => 20,
-  :PREFIXMATCH => 21,
-  :SUFFIXMATCH => 22,
-  :SUBSTRINGMATCH => 23,
-  :MINUS => 24,
-  "-temp-group" => 25 }
-
-racc_nt_base = 26
+  :BAD_STRING => 4,
+  :NUMBER => 5,
+  :OF => 6,
+  :HASH => 7,
+  :DOT => 8,
+  :STAR => 9,
+  :LBRACKET => 10,
+  :RBRACKET => 11,
+  :LPAREN => 12,
+  :RPAREN => 13,
+  :COLON => 14,
+  :COMMA => 15,
+  :CHILD => 16,
+  :ADJACENT => 17,
+  :SIBLING => 18,
+  :DESCENDANT => 19,
+  :COLUMN => 20,
+  :EQUAL => 21,
+  :INCLUDES => 22,
+  :DASHMATCH => 23,
+  :PREFIXMATCH => 24,
+  :SUFFIXMATCH => 25,
+  :SUBSTRINGMATCH => 26,
+  :MINUS => 27,
+  :PIPE => 28,
+  "-temp-group" => 29 }
+
+racc_nt_base = 30
 
 racc_use_result_var = true
 
@@ -1058,7 +1311,9 @@ Racc_token_to_s_table = [
   "error",
   "IDENT",
   "STRING",
+  "BAD_STRING",
   "NUMBER",
+  "OF",
   "HASH",
   "DOT",
   "STAR",
@@ -1072,6 +1327,7 @@ Racc_token_to_s_table = [
   "ADJACENT",
   "SIBLING",
   "DESCENDANT",
+  "COLUMN",
   "EQUAL",
   "INCLUDES",
   "DASHMATCH",
@@ -1079,6 +1335,7 @@ Racc_token_to_s_table = [
   "SUFFIXMATCH",
   "SUBSTRINGMATCH",
   "MINUS",
+  "PIPE",
   "\"-temp-group\"",
   "$start",
   "selector_list",
@@ -1099,10 +1356,15 @@ Racc_token_to_s_table = [
   "attribute_selector",
   "pseudo_class_selector",
   "pseudo_element_selector",
+  "attribute_name",
   "attr_matcher",
+  "attribute_value",
+  "attr_modifier",
   "any_value",
+  "nth_of_value",
   "an_plus_b",
   "relative_selector_list",
+  "nth_of_an_plus_b",
   "relative_selector",
   "\"-group@COMMA-relative_selector\"",
   "\"-many@-group@COMMA-relative_selector\"" ]
@@ -1137,7 +1399,7 @@ module_eval(<<'.,.,', 'parser.y', 31)
 
 module_eval(<<'.,.,', 'parser.y', 26)
   def _reduce_4(val, _values, result)
-            result = Node.new(:selector_list, nil, @current_position)
+            result = Node.new(:selector_list, nil, val[0].position)
         result.add_child(val[0])
         val[1].each { |pair| result.add_child(pair[1]) }
 
@@ -1187,45 +1449,45 @@ module_eval(<<'.,.,', 'parser.y', 35)
 
 module_eval(<<'.,.,', 'parser.y', 52)
   def _reduce_9(val, _values, result)
-     result = Node.new(:child_combinator, '>', @current_position)
+     result = Node.new(:child_combinator, '>', token_position(val[0]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 54)
   def _reduce_10(val, _values, result)
-     result = Node.new(:adjacent_combinator, '+', @current_position)
+     result = Node.new(:adjacent_combinator, '+', token_position(val[0]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 56)
   def _reduce_11(val, _values, result)
-     result = Node.new(:sibling_combinator, '~', @current_position)
+     result = Node.new(:sibling_combinator, '~', token_position(val[0]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 58)
   def _reduce_12(val, _values, result)
-     result = Node.new(:descendant_combinator, ' ', @current_position)
+     result = Node.new(:descendant_combinator, ' ', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 64)
+module_eval(<<'.,.,', 'parser.y', 60)
   def _reduce_13(val, _values, result)
-            result = Node.new(:simple_selector_sequence, nil, val[0].position)
-        result.add_child(val[0])
-        val[1].each { |sel| result.add_child(sel) } unless val[1].empty?
-
+     result = Node.new(:column_combinator, '||', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 72)
+module_eval(<<'.,.,', 'parser.y', 66)
   def _reduce_14(val, _values, result)
-     result = val[0]
+            result = Node.new(:simple_selector_sequence, nil, val[0].position)
+        result.add_child(val[0])
+        val[1].each { |sel| result.add_child(sel) } unless val[1].empty?
+
     result
   end
 .,.,
@@ -1237,348 +1499,560 @@ module_eval(<<'.,.,', 'parser.y', 74)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 81)
+module_eval(<<'.,.,', 'parser.y', 76)
   def _reduce_16(val, _values, result)
-    result = val[1] ? val[1].unshift(val[0]) : val
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 81)
+module_eval(<<'.,.,', 'parser.y', 83)
   def _reduce_17(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 79)
+module_eval(<<'.,.,', 'parser.y', 83)
   def _reduce_18(val, _values, result)
-     result = val[0]
+    result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 84)
+module_eval(<<'.,.,', 'parser.y', 81)
   def _reduce_19(val, _values, result)
-     result = Node.new(:type_selector, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
+     result = val[0]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 86)
   def _reduce_20(val, _values, result)
-     result = Node.new(:universal_selector, '*', @current_position)
+     result = Node.new(:type_selector, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 91)
+module_eval(<<'.,.,', 'parser.y', 88)
   def _reduce_21(val, _values, result)
-     result = val[0]
+     result = Node.new(:universal_selector, '*', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 93)
+module_eval(<<'.,.,', 'parser.y', 91)
   def _reduce_22(val, _values, result)
-     result = val[0]
+            result = Node.new(
+          :type_selector,
+          token_value(val[2]),
+          token_position(val[0]),
+          raw_value: "#{token_raw(val[0])}|#{token_raw(val[2])}",
+          namespace: token_value(val[0])
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 95)
+module_eval(<<'.,.,', 'parser.y', 101)
   def _reduce_23(val, _values, result)
-     result = val[0]
+            result = Node.new(
+          :type_selector,
+          token_value(val[2]),
+          token_position(val[0]),
+          raw_value: "*|#{token_raw(val[2])}",
+          namespace: '*'
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 97)
+module_eval(<<'.,.,', 'parser.y', 111)
   def _reduce_24(val, _values, result)
-     result = val[0]
+            result = Node.new(
+          :type_selector,
+          token_value(val[1]),
+          token_position(val[0]),
+          raw_value: "|#{token_raw(val[1])}",
+          namespace: ''
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 99)
+module_eval(<<'.,.,', 'parser.y', 121)
   def _reduce_25(val, _values, result)
-     result = val[0]
+            result = Node.new(
+          :universal_selector,
+          '*',
+          token_position(val[0]),
+          raw_value: "#{token_raw(val[0])}|*",
+          namespace: token_value(val[0])
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 104)
+module_eval(<<'.,.,', 'parser.y', 131)
   def _reduce_26(val, _values, result)
-     result = Node.new(:id_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
+            result = Node.new(
+          :universal_selector,
+          '*',
+          token_position(val[0]),
+          raw_value: '*|*',
+          namespace: '*'
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 109)
+module_eval(<<'.,.,', 'parser.y', 141)
   def _reduce_27(val, _values, result)
-     result = Node.new(:class_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
+            result = Node.new(
+          :universal_selector,
+          '*',
+          token_position(val[0]),
+          raw_value: '|*',
+          namespace: ''
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 114)
+module_eval(<<'.,.,', 'parser.y', 153)
   def _reduce_28(val, _values, result)
-     result = Node.new(:attribute_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 117)
+module_eval(<<'.,.,', 'parser.y', 155)
   def _reduce_29(val, _values, result)
-            result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
-        result.add_child(val[2])
-        result.add_child(Node.new(:value, val[3], @current_position))
-
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 124)
+module_eval(<<'.,.,', 'parser.y', 157)
   def _reduce_30(val, _values, result)
-            result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
-        result.add_child(val[2])
-        result.add_child(Node.new(:value, identifier_value(val[3]), @current_position, raw_value: identifier_raw(val[3])))
-
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 133)
+module_eval(<<'.,.,', 'parser.y', 159)
   def _reduce_31(val, _values, result)
-     result = Node.new(:equal_operator, '=', @current_position)
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 135)
+module_eval(<<'.,.,', 'parser.y', 161)
   def _reduce_32(val, _values, result)
-     result = Node.new(:includes_operator, '~=', @current_position)
+     result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 137)
+module_eval(<<'.,.,', 'parser.y', 166)
   def _reduce_33(val, _values, result)
-     result = Node.new(:dashmatch_operator, '|=', @current_position)
+     result = Node.new(:id_selector, token_value(val[1]), token_position(val[0]), raw_value: token_raw(val[1]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 139)
+module_eval(<<'.,.,', 'parser.y', 171)
   def _reduce_34(val, _values, result)
-     result = Node.new(:prefixmatch_operator, '^=', @current_position)
+     result = Node.new(:class_selector, token_value(val[1]), token_position(val[0]), raw_value: token_raw(val[1]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 141)
+module_eval(<<'.,.,', 'parser.y', 177)
   def _reduce_35(val, _values, result)
-     result = Node.new(:suffixmatch_operator, '$=', @current_position)
+            result = Node.new(
+          :attribute_selector,
+          val[1].value,
+          token_position(val[0]),
+          raw_value: val[1].raw_value,
+          namespace: val[1].namespace
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 143)
+module_eval(<<'.,.,', 'parser.y', 187)
   def _reduce_36(val, _values, result)
-     result = Node.new(:substringmatch_operator, '*=', @current_position)
+            result = Node.new(:attribute_selector, nil, token_position(val[0]), modifier: val[4])
+        result.add_child(val[1])
+        result.add_child(val[2])
+        result.add_child(val[3])
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 148)
+module_eval(<<'.,.,', 'parser.y', 197)
   def _reduce_37(val, _values, result)
-     result = Node.new(:pseudo_class, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
+            result = Node.new(:attribute, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]))
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 151)
+module_eval(<<'.,.,', 'parser.y', 201)
   def _reduce_38(val, _values, result)
-            fn = Node.new(:pseudo_function, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
-        fn.add_child(val[3])
-        result = fn
+            result = Node.new(
+          :attribute,
+          token_value(val[2]),
+          token_position(val[0]),
+          raw_value: "#{token_raw(val[0])}|#{token_raw(val[2])}",
+          namespace: token_value(val[0])
+        )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 157)
+module_eval(<<'.,.,', 'parser.y', 211)
   def _reduce_39(val, _values, result)
-            fn = Node.new(:pseudo_function, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
-        fn.add_child(val[2])
-        result = fn
+            result = Node.new(
+          :attribute,
+          token_value(val[2]),
+          token_position(val[0]),
+          raw_value: "*|#{token_raw(val[2])}",
+          namespace: '*'
+        )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 165)
+module_eval(<<'.,.,', 'parser.y', 221)
   def _reduce_40(val, _values, result)
-     result = Node.new(:pseudo_element, identifier_value(val[2]), @current_position, raw_value: identifier_raw(val[2]))
+            result = Node.new(
+          :attribute,
+          token_value(val[1]),
+          token_position(val[0]),
+          raw_value: "|#{token_raw(val[1])}",
+          namespace: ''
+        )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 170)
+module_eval(<<'.,.,', 'parser.y', 233)
   def _reduce_41(val, _values, result)
-     result = Node.new(:argument, val[0], @current_position)
+     result = Node.new(:equal_operator, '=', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 172)
+module_eval(<<'.,.,', 'parser.y', 235)
   def _reduce_42(val, _values, result)
-     result = val[0]
+     result = Node.new(:includes_operator, '~=', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 174)
+module_eval(<<'.,.,', 'parser.y', 237)
   def _reduce_43(val, _values, result)
-     result = val[0]
+     result = Node.new(:dashmatch_operator, '|=', token_position(val[0]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 181)
+module_eval(<<'.,.,', 'parser.y', 239)
   def _reduce_44(val, _values, result)
+     result = Node.new(:prefixmatch_operator, '^=', token_position(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 241)
+  def _reduce_45(val, _values, result)
+     result = Node.new(:suffixmatch_operator, '$=', token_position(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 243)
+  def _reduce_46(val, _values, result)
+     result = Node.new(:substringmatch_operator, '*=', token_position(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 248)
+  def _reduce_47(val, _values, result)
+     result = Node.new(:value, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]), quote: token_quote(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 250)
+  def _reduce_48(val, _values, result)
+     result = Node.new(:value, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 252)
+  def _reduce_49(val, _values, result)
+     result = Node.new(:value, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 257)
+  def _reduce_50(val, _values, result)
+     result = nil
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 259)
+  def _reduce_51(val, _values, result)
+     result = attribute_modifier_value(val[0])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 265)
+  def _reduce_52(val, _values, result)
+            name = token_value(val[1])
+        node_type = LEGACY_PSEUDO_ELEMENT_NAMES.include?(pseudo_name(name)) ? :pseudo_element : :pseudo_class
+        result = Node.new(node_type, name, token_position(val[0]), raw_value: token_raw(val[1]), prefix: ':')
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 271)
+  def _reduce_53(val, _values, result)
+            fn = Node.new(:pseudo_function, token_value(val[1]), token_position(val[0]), raw_value: token_raw(val[1]), prefix: ':')
+        fn.add_child(normalize_pseudo_argument(fn.value, val[3]))
+        result = fn
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 279)
+  def _reduce_54(val, _values, result)
+     result = Node.new(:pseudo_element, token_value(val[2]), token_position(val[0]), raw_value: token_raw(val[2]), prefix: '::')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 282)
+  def _reduce_55(val, _values, result)
+            fn = Node.new(:pseudo_element_function, token_value(val[2]), token_position(val[0]), raw_value: token_raw(val[2]), prefix: '::')
+        fn.add_child(val[4])
+        result = fn
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 290)
+  def _reduce_56(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 292)
+  def _reduce_57(val, _values, result)
+     result = Node.new(:argument, token_value(val[0]), token_position(val[0]), raw_value: token_raw(val[0]), quote: token_quote(val[0]))
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 294)
+  def _reduce_58(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 296)
+  def _reduce_59(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 302)
+  def _reduce_60(val, _values, result)
+            result = Node.new(:nth_selector_argument, nil, val[0].position)
+        result.add_child(val[0])
+        result.add_child(val[2])
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 310)
+  def _reduce_61(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 313)
+  def _reduce_62(val, _values, result)
+            value = token_value(val[0])
+        unless value =~ AN_PLUS_B_REGEX
+          raise Parselly::SyntaxError, parse_error("Parse error: invalid An+B value '#{value}'", token_position(val[0]))
+        end
+
+        result = Node.new(:an_plus_b, value, token_position(val[0]), raw_value: token_raw(val[0]))
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 326)
+  def _reduce_63(val, _values, result)
             # Handle 'An+B' like '2n+1'
-        result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}+#{val[3]}", @current_position)
+        result = Node.new(:an_plus_b, "#{token_value(val[0])}#{token_value(val[1])}+#{token_value(val[3])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 186)
-  def _reduce_45(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 331)
+  def _reduce_64(val, _values, result)
             # Handle 'An-B' like '2n-1'
-        result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}-#{val[3]}", @current_position)
+        result = Node.new(:an_plus_b, "#{token_value(val[0])}#{token_value(val[1])}-#{token_value(val[3])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 191)
-  def _reduce_46(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 336)
+  def _reduce_65(val, _values, result)
             # Handle 'An' like '2n' or composite like '2n-1' (when '-1' is part of IDENT)
-        result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}", @current_position)
+        result = Node.new(:an_plus_b, "#{token_value(val[0])}#{token_value(val[1])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 196)
-  def _reduce_47(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 341)
+  def _reduce_66(val, _values, result)
             # Handle 'n+B' like 'n+5' or keywords followed by offset (rare but valid)
-        result = Node.new(:an_plus_b, "#{val[0]}+#{val[2]}", @current_position)
+        result = Node.new(:an_plus_b, "#{token_value(val[0])}+#{token_value(val[2])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 201)
-  def _reduce_48(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 346)
+  def _reduce_67(val, _values, result)
             # Handle 'n-B' like 'n-3'
-        result = Node.new(:an_plus_b, "#{val[0]}-#{val[2]}", @current_position)
+        result = Node.new(:an_plus_b, "#{token_value(val[0])}-#{token_value(val[2])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 207)
-  def _reduce_49(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 352)
+  def _reduce_68(val, _values, result)
             # Handle '-An+B' like '-2n+1'
-        result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}+#{val[4]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}#{token_value(val[2])}+#{token_value(val[4])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 212)
-  def _reduce_50(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 357)
+  def _reduce_69(val, _values, result)
             # Handle '-An-B' like '-2n-1'
-        result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}-#{val[4]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}#{token_value(val[2])}-#{token_value(val[4])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 217)
-  def _reduce_51(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 362)
+  def _reduce_70(val, _values, result)
             # Handle '-An' like '-2n' or composite like '-2n+1' (when '+1' is part of IDENT)
-        result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}#{token_value(val[2])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 222)
-  def _reduce_52(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 367)
+  def _reduce_71(val, _values, result)
             # Handle '-n+B' like '-n+3'
-        result = Node.new(:an_plus_b, "-#{val[1]}+#{val[3]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}+#{token_value(val[3])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 227)
-  def _reduce_53(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 372)
+  def _reduce_72(val, _values, result)
             # Handle '-n-B' like '-n-2'
-        result = Node.new(:an_plus_b, "-#{val[1]}-#{val[3]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}-#{token_value(val[3])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 232)
-  def _reduce_54(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 377)
+  def _reduce_73(val, _values, result)
             # Handle '-n' or composite like '-n+3' (when '+3' is part of IDENT)
-        result = Node.new(:an_plus_b, "-#{val[1]}", @current_position)
+        result = Node.new(:an_plus_b, "-#{token_value(val[1])}", token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 238)
-  def _reduce_55(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 383)
+  def _reduce_74(val, _values, result)
             # Handle just a number like '3'
-        result = Node.new(:an_plus_b, val[0].to_s, @current_position)
+        result = Node.new(:an_plus_b, token_value(val[0]).to_s, token_position(val[0]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 251)
-  def _reduce_56(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 396)
+  def _reduce_75(val, _values, result)
     result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 251)
-  def _reduce_57(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 396)
+  def _reduce_76(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 251)
-  def _reduce_58(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 396)
+  def _reduce_77(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 246)
-  def _reduce_59(val, _values, result)
-            result = Node.new(:selector_list, nil, @current_position)
+module_eval(<<'.,.,', 'parser.y', 391)
+  def _reduce_78(val, _values, result)
+            result = Node.new(:selector_list, nil, val[0].position)
         result.add_child(val[0])
         val[1].each { |pair| result.add_child(pair[1]) }
 
@@ -1586,15 +2060,15 @@ module_eval(<<'.,.,', 'parser.y', 246)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 254)
-  def _reduce_60(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 399)
+  def _reduce_79(val, _values, result)
      result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 257)
-  def _reduce_61(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 402)
+  def _reduce_80(val, _values, result)
             result = Node.new(:selector, nil, val[0].position)
         result.add_child(val[0])
         result.add_child(val[1])