parselly 1.0.0 → 1.2.0

data/lib/parselly/parser.rb

@@ -653,37 +653,131 @@ end
 end
 ###### racc/parser.rb end
 
+require 'set'
+
+# Pre-computed sets for faster lookup
+CAN_END_COMPOUND = Set[:IDENT, :STAR, :RPAREN, :RBRACKET].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
 
 module Parselly
   class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 263)
-def parse(input)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 279)
+def parse(input, tolerant: false)
+  @tolerant = tolerant
+  @errors = []
+  @error_index = nil
+  @suppress_errors = false
   @lexer = Parselly::Lexer.new(input)
-  @tokens = @lexer.tokenize
+  begin
+    @tokens = @lexer.tokenize
+  rescue RuntimeError => e
+    if tolerant
+      @errors << parse_error_from_exception(e)
+      return Parselly::ParseResult.new(nil, @errors)
+    end
+    raise
+  end
   preprocess_tokens!
   @index = 0
-  @current_position = { line: 1, column: 1 }
+  @current_position = { line: 1, column: 1, offset: 0 }
+
+  if tolerant
+    ast = parse_with_recovery
+    normalize_an_plus_b(ast) if ast
+    return Parselly::ParseResult.new(ast, @errors)
+  end
+
   ast = do_parse
   normalize_an_plus_b(ast)
   ast
 end
 
+def parse_with_recovery
+  do_parse
+rescue Parselly::ParseError, RuntimeError
+  parse_partial_ast
+end
+
+def parse_partial_ast
+  return nil unless @tokens && !@tokens.empty?
+
+  eof_token = @tokens.last if @tokens.last && @tokens.last[0] == false
+  tokens = @tokens.dup
+  tokens.pop if eof_token
+  limit = @error_index || tokens.length
+
+  while limit > 0
+    truncated = tokens[0...limit]
+    truncated << eof_token if eof_token
+    begin
+      return parse_from_tokens(truncated, suppress_errors: true)
+    rescue Parselly::ParseError, RuntimeError
+      limit -= 1
+    end
+  end
+  nil
+end
+
+def parse_from_tokens(tokens, suppress_errors: false)
+  @tokens = tokens
+  @index = 0
+  @current_position = { line: 1, column: 1, offset: 0 }
+  @suppress_errors = suppress_errors
+  do_parse
+ensure
+  @suppress_errors = false
+end
+
+def parse_error_from_exception(error)
+  line = nil
+  column = nil
+  offset = nil
+  if error.message =~ /at (\d+):(\d+)/
+    line = Regexp.last_match(1).to_i
+    column = Regexp.last_match(2).to_i
+  end
+  if error.message =~ /offset (\d+)/
+    offset = Regexp.last_match(1).to_i
+  end
+  { message: error.message, line: line, column: column, offset: offset }
+end
+
+def identifier_value(token)
+  token.respond_to?(:value) ? token.value : token
+end
+
+def identifier_raw(token)
+  token.respond_to?(:raw) ? token.raw : token
+end
+
 def preprocess_tokens!
-  new_tokens = []
-  i = 0
-  while i < @tokens.size
-    token = @tokens[i]
-    next_token = @tokens[i + 1]
-    new_tokens << token
-    if next_token && needs_descendant?(token, next_token)
-      pos = { line: token[2][:line], column: token[2][:column] }
-      new_tokens << [:DESCENDANT, ' ', pos]
+  return if @tokens.size <= 1
+
+  new_tokens = Array.new(@tokens.size + (@tokens.size / 2)) # Pre-allocate with conservative estimate
+  new_tokens_idx = 0
+
+  last_idx = @tokens.size - 1
+  @tokens.each_with_index do |token, i|
+    new_tokens[new_tokens_idx] = token
+    new_tokens_idx += 1
+
+    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] }
+        new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
+        new_tokens_idx += 1
+      end
     end
-    i += 1
   end
 
-  @tokens = new_tokens
+  @tokens = new_tokens.first(new_tokens_idx)
 end
 
 # Insert DESCENDANT combinator if:
@@ -695,62 +789,42 @@ def needs_descendant?(current, next_tok)
   current_type = current[0]
   next_type = next_tok[0]
 
-  can_end = can_end_compound?(current_type)
-  can_start = can_start_compound?(next_type)
-
   # Type selector followed by subclass selector = same compound
-  if [:IDENT, :STAR].include?(current_type) &&
-     [:DOT, :HASH, :LBRACKET, :COLON].include?(next_type)
-    return false
+  # 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 && can_start
-end
-
-def can_end_compound?(token_type)
-  [:IDENT, :STAR, :RPAREN, :RBRACKET].include?(token_type)
-end
-
-def can_start_compound?(token_type)
-  # Type selectors and subclass selectors can start a compound selector
-  [:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].include?(token_type)
+  CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
 end
 
 def normalize_an_plus_b(node)
   return unless node.respond_to?(:children) && node.children
 
-  if node.type == :pseudo_function && nth_pseudo?(node.value)
+  if node.type == :pseudo_function && NTH_PSEUDO_NAMES.include?(node.value)
     child = node.children.first
-    if child && child.type == :selector_list
+    if child&.type == :selector_list
       an_plus_b_value = extract_an_plus_b_value(child)
       if an_plus_b_value
-        node.children[0] = Node.new(:an_plus_b, an_plus_b_value, child.position)
+        node.replace_child(0, Node.new(:an_plus_b, an_plus_b_value, child.position))
       end
     end
   end
   node.children.compact.each { |child| normalize_an_plus_b(child) }
 end
 
-def nth_pseudo?(name)
-  %w[nth-child nth-last-child nth-of-type nth-last-of-type nth-col nth-last-col].include?(name)
-end
-
 def extract_an_plus_b_value(selector_list_node)
   return nil unless selector_list_node.children.size == 1
 
   seq = selector_list_node.children.first
-  return nil unless seq.type == :simple_selector_sequence
-  return nil unless seq.children.size == 1
+  return nil unless seq.type == :simple_selector_sequence && seq.children.size == 1
 
   type_sel = seq.children.first
   return nil unless type_sel.type == :type_selector
 
   value = type_sel.value
-  if value =~ /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/
-    value
-  else
-    nil
-  end
+  value if value =~ AN_PLUS_B_REGEX
 end
 
 def next_token
@@ -766,88 +840,101 @@ end
 def on_error(token_id, val, vstack)
   token_name = token_to_str(token_id) || '?'
   pos = @current_position || { line: '?', column: '?' }
-  raise "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[: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]
 end
 ...end parser.y/module_eval...
 ##### State transition tables begin ###
 
 racc_action_table = [
-    55,    57,    60,    14,    15,     8,    16,    35,    18,    67,
-    17,    19,    25,    26,    27,    28,    32,    36,    68,    79,
-     7,    33,    61,    14,    15,     8,    16,    43,    80,    72,
-    17,    71,    25,    26,    27,    28,    45,    46,    47,    48,
-    49,    50,     7,    54,    53,    14,    15,     8,    16,    34,
-     7,    37,    17,    14,    15,     8,    16,    19,     7,    51,
-    17,    14,    15,     8,    16,    82,     7,    52,    17,    14,
-    15,     8,    16,    88,    83,    65,    17,    14,    15,    66,
-    16,    69,    89,    70,    17,    14,    15,    73,    16,    77,
-    78,    81,    17,    25,    26,    27,    28,    25,    26,    27,
-    28,    73,    86,    87,    90,    91,    92,    93 ]
+    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 ]
 
 racc_action_check = [
-    51,    51,    51,    51,    51,    51,    51,    17,     1,    55,
-    51,     2,    51,    51,    51,    51,    14,    17,    55,    70,
-    73,    15,    51,    73,    73,    73,    73,    34,    70,    61,
-    73,    61,    73,    73,    73,    73,    34,    34,    34,    34,
-    34,    34,     0,    44,    44,     0,     0,     0,     0,    16,
-    19,    18,     0,    19,    19,    19,    19,    20,    22,    35,
-    19,    22,    22,    22,    22,    72,    64,    36,    22,    64,
-    64,    64,    64,    81,    72,    53,    64,     4,     4,    54,
-     4,    56,    81,    60,     4,    30,    30,    62,    30,    67,
-    68,    71,    30,     3,     3,     3,     3,    23,    23,    23,
-    23,    74,    79,    80,    82,    83,    88,    89 ]
+    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 ]
 
 racc_action_pointer = [
-    40,     8,    -2,    79,    72,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    14,    19,    47,     5,    51,    48,
-    44,   nil,    56,    83,   nil,   nil,   nil,   nil,   nil,   nil,
-    80,   nil,   nil,   nil,    18,    49,    65,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    41,   nil,   nil,   nil,   nil,   nil,
-   nil,    -2,   nil,    66,    70,    -6,    70,   nil,   nil,   nil,
-    81,    27,    74,   nil,    64,   nil,   nil,    85,    86,   nil,
-     4,    89,    50,    18,    88,   nil,   nil,   nil,   nil,    98,
-    99,    58,   100,   101,   nil,   nil,   nil,   nil,   102,   103,
-   nil,   nil,   nil,   nil ]
+    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 ]
 
 racc_action_default = [
-   -61,   -61,    -2,    -6,   -16,   -14,   -15,   -19,   -20,   -21,
-   -22,   -23,   -24,   -25,   -61,   -61,   -61,   -61,   -61,   -61,
-    -2,    -4,   -61,    -6,    -8,    -9,   -10,   -11,   -12,   -13,
-   -16,   -18,   -26,   -27,   -61,   -37,   -61,    94,    -1,    -3,
-    -5,    -7,   -17,   -28,   -61,   -31,   -32,   -33,   -34,   -35,
-   -36,   -61,   -39,   -61,   -61,   -19,   -61,   -40,   -41,   -42,
-   -54,   -61,   -56,   -59,   -61,   -29,   -30,   -61,   -61,   -38,
-   -45,   -61,   -53,   -61,   -56,   -58,   -60,   -46,   -47,   -61,
-   -61,   -50,   -61,   -61,   -55,   -57,   -43,   -44,   -61,   -61,
-   -51,   -52,   -48,   -49 ]
+   -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 ]
 
 racc_goto_table = [
-     2,    30,    31,    64,    62,    21,    75,     1,    40,    24,
-    29,    44,    56,    58,    59,   nil,   nil,   nil,    85,    38,
-   nil,   nil,   nil,    39,   nil,    64,    84,    30,    42,    41,
+     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,
    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,    76 ]
+   nil,   nil,   nil,   nil,    74 ]
 
 racc_goto_check = [
-     2,    12,    13,     6,    23,     4,    25,     1,     5,     8,
-    10,    19,    20,    21,    22,   nil,   nil,   nil,    25,     2,
-   nil,   nil,   nil,     4,   nil,     6,    23,    12,    13,     8,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     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,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,     2 ]
 
 racc_goto_pointer = [
-   nil,     7,     0,   nil,     3,   -14,   -48,   nil,     6,   nil,
-     6,   nil,    -3,    -2,   nil,   nil,   nil,   nil,   nil,   -23,
-   -39,   -38,   -37,   -47,   nil,   -56 ]
+   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 ]
 
 racc_goto_default = [
-   nil,   nil,    63,    20,   nil,     3,    22,    23,   nil,     4,
+   nil,   nil,    53,    20,   nil,     3,    54,    23,   nil,     4,
    nil,     5,     6,   nil,     9,    10,    11,    12,    13,   nil,
-   nil,   nil,   nil,   nil,    74,   nil ]
+   nil,    48,    49,    52,    72,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
@@ -889,32 +976,33 @@ racc_reduce_table = [
   1, 45, :_reduce_36,
   2, 43, :_reduce_37,
   5, 43, :_reduce_38,
-  3, 44, :_reduce_39,
-  1, 46, :_reduce_40,
+  4, 43, :_reduce_39,
+  3, 44, :_reduce_40,
   1, 46, :_reduce_41,
   1, 46, :_reduce_42,
-  4, 47, :_reduce_43,
+  1, 46, :_reduce_43,
   4, 47, :_reduce_44,
-  2, 47, :_reduce_45,
-  3, 47, :_reduce_46,
+  4, 47, :_reduce_45,
+  2, 47, :_reduce_46,
   3, 47, :_reduce_47,
-  5, 47, :_reduce_48,
+  3, 47, :_reduce_48,
   5, 47, :_reduce_49,
-  3, 47, :_reduce_50,
-  4, 47, :_reduce_51,
+  5, 47, :_reduce_50,
+  3, 47, :_reduce_51,
   4, 47, :_reduce_52,
-  2, 47, :_reduce_53,
-  1, 47, :_reduce_54,
-  2, 50, :_reduce_55,
-  0, 51, :_reduce_56,
-  2, 51, :_reduce_57,
-  2, 48, :_reduce_58,
-  1, 49, :_reduce_59,
-  2, 49, :_reduce_60 ]
+  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 = 61
+racc_reduce_n = 62
 
-racc_shift_n = 94
+racc_shift_n = 98
 
 racc_token_table = {
   false => 0,
@@ -1172,7 +1260,7 @@ module_eval(<<'.,.,', 'parser.y', 79)
 
 module_eval(<<'.,.,', 'parser.y', 84)
   def _reduce_19(val, _values, result)
-     result = Node.new(:type_selector, val[0], @current_position)
+     result = Node.new(:type_selector, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
     result
   end
 .,.,
@@ -1221,21 +1309,21 @@ module_eval(<<'.,.,', 'parser.y', 99)
 
 module_eval(<<'.,.,', 'parser.y', 104)
   def _reduce_26(val, _values, result)
-     result = Node.new(:id_selector, val[1], @current_position)
+     result = Node.new(:id_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 109)
   def _reduce_27(val, _values, result)
-     result = Node.new(:class_selector, val[1], @current_position)
+     result = Node.new(:class_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 114)
   def _reduce_28(val, _values, result)
-     result = Node.new(:attribute_selector, val[1], @current_position)
+     result = Node.new(:attribute_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
@@ -1243,7 +1331,7 @@ module_eval(<<'.,.,', 'parser.y', 114)
 module_eval(<<'.,.,', 'parser.y', 117)
   def _reduce_29(val, _values, result)
             result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @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))
 
@@ -1254,9 +1342,9 @@ module_eval(<<'.,.,', 'parser.y', 117)
 module_eval(<<'.,.,', 'parser.y', 124)
   def _reduce_30(val, _values, result)
             result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @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.add_child(Node.new(:value, identifier_value(val[3]), @current_position, raw_value: identifier_raw(val[3])))
 
     result
   end
@@ -1306,14 +1394,14 @@ module_eval(<<'.,.,', 'parser.y', 143)
 
 module_eval(<<'.,.,', 'parser.y', 148)
   def _reduce_37(val, _values, result)
-     result = Node.new(:pseudo_class, val[1], @current_position)
+     result = Node.new(:pseudo_class, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 151)
   def _reduce_38(val, _values, result)
-            fn = Node.new(:pseudo_function, val[1], @current_position)
+            fn = Node.new(:pseudo_function, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
         fn.add_child(val[3])
         result = fn
 
@@ -1321,36 +1409,46 @@ module_eval(<<'.,.,', 'parser.y', 151)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 159)
+module_eval(<<'.,.,', 'parser.y', 157)
   def _reduce_39(val, _values, result)
-     result = Node.new(:pseudo_element, val[2], @current_position)
+            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
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 164)
+module_eval(<<'.,.,', 'parser.y', 165)
   def _reduce_40(val, _values, result)
-     result = Node.new(:argument, val[0], @current_position)
+     result = Node.new(:pseudo_element, identifier_value(val[2]), @current_position, raw_value: identifier_raw(val[2]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 166)
+module_eval(<<'.,.,', 'parser.y', 170)
   def _reduce_41(val, _values, result)
-     result = val[0]
+     result = Node.new(:argument, val[0], @current_position)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 168)
+module_eval(<<'.,.,', 'parser.y', 172)
   def _reduce_42(val, _values, result)
      result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 175)
+module_eval(<<'.,.,', 'parser.y', 174)
   def _reduce_43(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 181)
+  def _reduce_44(val, _values, result)
             # Handle 'An+B' like '2n+1'
         result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}+#{val[3]}", @current_position)
 
@@ -1358,8 +1456,8 @@ module_eval(<<'.,.,', 'parser.y', 175)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 180)
-  def _reduce_44(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 186)
+  def _reduce_45(val, _values, result)
             # Handle 'An-B' like '2n-1'
         result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}-#{val[3]}", @current_position)
 
@@ -1367,8 +1465,8 @@ module_eval(<<'.,.,', 'parser.y', 180)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 185)
-  def _reduce_45(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 191)
+  def _reduce_46(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)
 
@@ -1376,8 +1474,8 @@ module_eval(<<'.,.,', 'parser.y', 185)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 190)
-  def _reduce_46(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 196)
+  def _reduce_47(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)
 
@@ -1385,8 +1483,8 @@ module_eval(<<'.,.,', 'parser.y', 190)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 195)
-  def _reduce_47(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 201)
+  def _reduce_48(val, _values, result)
             # Handle 'n-B' like 'n-3'
         result = Node.new(:an_plus_b, "#{val[0]}-#{val[2]}", @current_position)
 
@@ -1394,8 +1492,8 @@ module_eval(<<'.,.,', 'parser.y', 195)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 201)
-  def _reduce_48(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 207)
+  def _reduce_49(val, _values, result)
             # Handle '-An+B' like '-2n+1'
         result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}+#{val[4]}", @current_position)
 
@@ -1403,8 +1501,8 @@ module_eval(<<'.,.,', 'parser.y', 201)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 206)
-  def _reduce_49(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 212)
+  def _reduce_50(val, _values, result)
             # Handle '-An-B' like '-2n-1'
         result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}-#{val[4]}", @current_position)
 
@@ -1412,8 +1510,8 @@ module_eval(<<'.,.,', 'parser.y', 206)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 211)
-  def _reduce_50(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 217)
+  def _reduce_51(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)
 
@@ -1421,8 +1519,8 @@ module_eval(<<'.,.,', 'parser.y', 211)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 216)
-  def _reduce_51(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 222)
+  def _reduce_52(val, _values, result)
             # Handle '-n+B' like '-n+3'
         result = Node.new(:an_plus_b, "-#{val[1]}+#{val[3]}", @current_position)
 
@@ -1430,8 +1528,8 @@ module_eval(<<'.,.,', 'parser.y', 216)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 221)
-  def _reduce_52(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 227)
+  def _reduce_53(val, _values, result)
             # Handle '-n-B' like '-n-2'
         result = Node.new(:an_plus_b, "-#{val[1]}-#{val[3]}", @current_position)
 
@@ -1439,8 +1537,8 @@ module_eval(<<'.,.,', 'parser.y', 221)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 226)
-  def _reduce_53(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 232)
+  def _reduce_54(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)
 
@@ -1448,8 +1546,8 @@ module_eval(<<'.,.,', 'parser.y', 226)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 232)
-  def _reduce_54(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 238)
+  def _reduce_55(val, _values, result)
             # Handle just a number like '3'
         result = Node.new(:an_plus_b, val[0].to_s, @current_position)
 
@@ -1457,29 +1555,29 @@ module_eval(<<'.,.,', 'parser.y', 232)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_55(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_56(val, _values, result)
     result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_56(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_57(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_57(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_58(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 240)
-  def _reduce_58(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 246)
+  def _reduce_59(val, _values, result)
             result = Node.new(:selector_list, nil, @current_position)
         result.add_child(val[0])
         val[1].each { |pair| result.add_child(pair[1]) }
@@ -1488,15 +1586,15 @@ module_eval(<<'.,.,', 'parser.y', 240)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 248)
-  def _reduce_59(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 254)
+  def _reduce_60(val, _values, result)
      result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 251)
-  def _reduce_60(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 257)
+  def _reduce_61(val, _values, result)
             result = Node.new(:selector, nil, val[0].position)
         result.add_child(val[0])
         result.add_child(val[1])