js_regex 3.12.0 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c6bfe5a3631b78df8e258b46c12f9c89eeabefa5ce0967760cd7cc9c152ca8e
-  data.tar.gz: d05300ee0f1496adbfa455533af89d8a42af7808af14fdb1f6c569bfcde5913f
+  metadata.gz: 81da8ab5dab32613d0486bb8b1d0c9926b1cd5dcf5cbf1dae7f7c7b86b695718
+  data.tar.gz: ad87e55f4c1834b237d8f18318fae065625e1e94f7645158ec4a7450967e5b69
 SHA512:
-  metadata.gz: e7ed1e47c10c775151a4ccfbae673c9d122354841a20b7d18aed2e545b81ce9c87584026b2d7433c83be42d30c5e1c9ca823f7f31186cea4278273d3698c2a12
-  data.tar.gz: 9d1e0e0f2ae0865e69262c8eefef4999cbcf877a270eb642ee7f115a3ff77c10c0ca8c6fdb60093fba5244e54bca0de58c1514ad28a1c6c21378e3c64d00b378
+  metadata.gz: 5b6e9d0eea5aa5656d3eaae3dd0ad769a21ef8a32d7304237afbe965266e8a8e8229c256a9110ce1573b2faf52ef112f354fcf84af61183b1f5aeb79035869f5
+  data.tar.gz: e546194d186650cc46aed54b73d92e6320251cb2954e213859fe3e5d4e06e04f502f8e0b5fe7a331db12578b59678484e184485ce4397dd61391677fe4766cd2

data/lib/js_regex/conversion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # This class acts as a facade, passing a Regexp to the Converters.
@@ -37,7 +39,7 @@ class JsRegex
       end
 
       def convert_options(input, custom_options, required_options)
-        options = custom_options.to_s.scan(/[gimsuy]/) + required_options
+        options = custom_options.to_s.scan(/[dgimsuvy]/) + required_options
         if input.is_a?(Regexp) && (input.options & Regexp::IGNORECASE).nonzero?
           options << 'i'
         end

data/lib/js_regex/converter/anchor_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -10,8 +12,10 @@ class JsRegex
 
       def convert_data
         case subtype
-        when :bol, :bos then '^'
-        when :eol, :eos then '$'
+        when :bol then convert_bol
+        when :bos then '^'
+        when :eol then '(?=$|\n)'
+        when :eos then '$'
         when :eos_ob_eol then '(?=\n?$)'
         when :word_boundary then convert_boundary
         when :nonword_boundary then convert_nonboundary
@@ -20,6 +24,15 @@ class JsRegex
         end
       end
 
+      def convert_bol
+        if context.es_2018_or_higher?
+          '(?<=^|\n(?!$))'
+        else
+          # TODO: warn in v4.0.0, or drop ES2009 & ES2015 support
+          '^'
+        end
+      end
+
       def convert_boundary
         if context.es_2018_or_higher? && context.enable_u_option
           BOUNDARY_EXPANSION

data/lib/js_regex/converter/assertion_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'group_converter'
 

data/lib/js_regex/converter/backreference_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -19,17 +21,39 @@ class JsRegex
       end
 
       def convert_name_ref
-        if context.es_2018_or_higher?
-          # ES 2018+ supports named backrefs, but only the angled-bracket syntax
-          Node.new("\\k<#{expression.name}>", reference: new_position, type: :backref)
+        # Check if this is a multiplexed named group reference
+        if expression.referenced_expressions.count > 1
+          convert_multiplexed_name_ref
         else
+          # Always use numeric backrefs since we convert all named groups to numbered
+          # (see comment in GroupConverter)
           convert_to_plain_num_ref
         end
       end
 
       def convert_to_plain_num_ref
         position = new_position
-        Node.new("\\#{position}", reference: position, type: :backref)
+
+        # Check if this backreference refers to a group that was recursively called
+        original_group = target_position
+        if (recursive_position = context.get_recursive_group_position(original_group))
+          # Use the position of the group created by the recursive call
+          position = recursive_position
+        end
+
+        text = "\\#{position}#{'(?:)' if expression.x?}"
+        Node.new(text, reference: position, type: :backref)
+      end
+
+      def convert_multiplexed_name_ref
+        # Create alternation of all groups with the same name
+        positions = expression.referenced_expressions.map do |ref_exp|
+          context.new_capturing_group_position(ref_exp.number)
+        end
+
+        # Build alternation like (?:\1|\2)
+        alternation = positions.map { |pos| "\\#{pos}" }.join('|')
+        Node.new("(?:#{alternation})")
       end
 
       def new_position
@@ -43,18 +67,53 @@ class JsRegex
       def convert_call
         if context.recursions(expression) >= 5
           warn_of("Recursion for '#{expression}' curtailed at 5 levels")
-          return ''
+          return drop
         end
 
         context.count_recursion(expression)
+
+        # Track groups before the wrapper group is added
+        groups_before_wrapper = context.capturing_group_count
+
         context.increment_local_capturing_group_count
         target_copy = expression.referenced_expression.unquantified_clone
         # avoid "Duplicate capture group name" error in JS
         target_copy.token = :capture if target_copy.is?(:named, :group)
+        context.start_subexp_recursion
         result = convert_expression(target_copy)
-        # wrap in group if it is a full-pattern recursion
+        context.end_subexp_recursion
+
+        # Track all groups created during this recursive call
+        # This handles both the directly called group and any nested groups within it
+        # Get all group numbers from the referenced expression
+        original_groups = collect_group_numbers(expression.referenced_expression)
+
+        # The first new group number is groups_before_wrapper + 1
+        # (the wrapper group from increment_local_capturing_group_count doesn't appear in output)
+        first_new_group = groups_before_wrapper + 1
+
+        # Map each original group to its corresponding new group
+        # For example, if we recursively called group 1 which contains group 2,
+        # and this created groups 3 and 4, then:
+        # - group 1 -> group 3
+        # - group 2 -> group 4
+        original_groups.each_with_index do |old_group_num, index|
+          new_group_num = first_new_group + index
+          context.track_recursive_group_call(old_group_num, new_group_num)
+        end
+
+        # wrap in passive group if it is a full-pattern recursion
         expression.reference == 0 ? Node.new('(?:', result, ')') : result
       end
+
+      def collect_group_numbers(exp)
+        return [] if exp.terminal?
+
+        numbers = []
+        numbers << exp.number if exp.capturing?
+        exp.each_expression { |sub| numbers += collect_group_numbers(sub) }
+        numbers
+      end
     end
   end
 end

data/lib/js_regex/converter/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     #
@@ -44,7 +46,9 @@ class JsRegex
       end
 
       def convert_subexpressions
-        Node.new(*expression.map { |subexp| convert_expression(subexp) })
+        # mark alternation and conditional branches for processing in second pass
+        type = expression.is?(:sequence) ? :branch : :plain
+        Node.new(*expression.map { |subexp| convert_expression(subexp) }, type: type)
       end
 
       def convert_expression(expression)
@@ -78,9 +82,15 @@ class JsRegex
       def wrap_in_backrefed_lookahead(content)
         number = context.capturing_group_count + 1
         backref_node = Node.new("\\#{number}", reference: number, type: :backref)
+        backrefed_group = Node.new('(', *content, ')', reference: number, type: :captured_group)
         context.increment_local_capturing_group_count
-        # an empty passive group (?:) is appended as literal digits may follow
-        Node.new('(?=(', *content, '))', backref_node, '(?:)')
+        # The surrounding group is added so that quantifiers apply to the whole.
+        # Without it, `(?:)` would need to be appended as literal digits may follow.
+        Node.new('(?:(?=', backrefed_group, ')', backref_node, ')')
+      end
+
+      def unmatchable_substitution
+        '(?!)'
       end
     end
   end

data/lib/js_regex/converter/conditional_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     #
@@ -10,6 +12,7 @@ class JsRegex
                   :case_insensitive_root,
                   :fail_fast,
                   :in_atomic_group,
+                  :in_subexp_recursion,
                   :warnings
 
       def initialize(case_insensitive_root: false, fail_fast: false, target: nil)
@@ -17,8 +20,10 @@ class JsRegex
         self.capturing_group_count = 0
         self.fail_fast = fail_fast
         self.recursions_per_expression = {}
+        self.recursion_stack = []
         self.required_options_hash = {}
         self.warnings = []
+        self.recursive_group_map = {}
 
         self.case_insensitive_root = case_insensitive_root
         self.target = target
@@ -70,17 +75,34 @@ class JsRegex
       end
 
       def recursions(exp)
-        recursions_per_expression[recursion_id(exp)] || 0
+        # Count recursions in the current stack path only
+        recursion_stack.count { |e| recursion_id(e) == recursion_id(exp) }
       end
 
       def count_recursion(exp)
-        recursions_per_expression[recursion_id(exp)] = recursions(exp) + 1
+        recursion_stack.push(exp)
       end
 
       def recursion_id(exp)
         [exp.class, exp.starts_at]
       end
 
+      def start_subexp_recursion
+        self.in_subexp_recursion = true
+        self.recursion_start_group_count = capturing_group_count
+      end
+
+      def end_subexp_recursion
+        self.in_subexp_recursion = false
+        # Pop the last recursion from stack when exiting
+        recursion_stack.pop if recursion_stack.any?
+      end
+
+      # Get the number of groups at the start of the current recursion
+      def recursion_start_group_count
+        self.recursion_start_group_count || 0
+      end
+
       # takes and returns 1-indexed group positions.
       # new is different from old if capturing groups were added in between.
       def new_capturing_group_position(old_position)
@@ -95,17 +117,31 @@ class JsRegex
         capturing_group_count - total_added_capturing_groups
       end
 
+      # Track that a group was created by a recursive call
+      def track_recursive_group_call(original_group_num, new_group_num)
+        recursive_group_map[original_group_num] = new_group_num
+      end
+
+      # Get the group number created by a recursive call
+      def get_recursive_group_position(original_group_num)
+        recursive_group_map[original_group_num]
+      end
+
       private
 
       attr_accessor :added_capturing_groups_after_group,
                     :recursions_per_expression,
+                    :recursion_stack,
                     :required_options_hash,
+                    :recursive_group_map,
                     :target
 
       attr_writer :capturing_group_count,
                   :case_insensitive_root,
                   :fail_fast,
                   :in_atomic_group,
+                  :in_subexp_recursion,
+                  :recursion_start_group_count,
                   :warnings
 
       def total_added_capturing_groups

data/lib/js_regex/converter/escape_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'literal_converter'
 
@@ -38,14 +40,14 @@ class JsRegex
         case subtype
         when :codepoint_list
           convert_codepoint_list
-        when :control, :meta_sequence
+        when :control, :meta_sequence, :utf8_hex
           unicode_escape_codepoint
         when :literal
           LiteralConverter.convert_data(expression.char, context)
+        when :bell, :escape, :hex, :octal
+          hex_escape_codepoint
         when *ESCAPES_SHARED_BY_RUBY_AND_JS
           pass_through
-        when :bell, :escape, :octal
-          hex_escape_codepoint
         else
           warn_of_unsupported_feature
         end

data/lib/js_regex/converter/freespace_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/group_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -22,12 +24,10 @@ class JsRegex
       end
 
       def build_named_group
-        if context.es_2018_or_higher?
-          # ES 2018+ supports named groups, but only the angled-bracket syntax
-          build_group(head: "(?<#{expression.name}>")
-        else
-          build_group
-        end
+        # Always convert named groups to numbered groups. ES2018+ supports named
+        # groups, but can not handle repeated names in multiplexing or conditional
+        # expansion scenarios.
+        build_group
       end
 
       def emulate_atomic_group
@@ -69,10 +69,6 @@ class JsRegex
         expression.empty?
       end
 
-      def unmatchable_substitution
-        '(?!)'
-      end
-
       def build_absence_group
         head = "(?:(?:.|\\n){,#{expression.inner_match_length.min - 1}}|(?:(?!"
         tail = ')(?:.|\n))*)'
@@ -84,7 +80,7 @@ class JsRegex
         tail = opts[:tail] || ')'
         return Node.new(*wrap(head, tail)) if opts[:capturing].equal?(false)
 
-        context.capture_group
+        context.capture_group unless context.in_subexp_recursion
         ref = expression.number
         Node.new(*wrap(head, tail), reference: ref, type: :captured_group)
       end

data/lib/js_regex/converter/keep_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/literal_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -6,8 +8,8 @@ class JsRegex
     # Template class implementation.
     #
     class LiteralConverter < JsRegex::Converter::Base
-      ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/
-      LITERAL_REQUIRING_ESCAPE_PATTERN = /[\/\f\n\r\t\v]/
+      ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/.freeze
+      LITERAL_REQUIRING_ESCAPE_PATTERN = /[\/\f\n\r\t\v]/.freeze
 
       class << self
         def convert_data(data, context)
@@ -59,7 +61,7 @@ class JsRegex
         result
       end
 
-      HAS_CASE_PATTERN = /[\p{lower}\p{upper}]/
+      HAS_CASE_PATTERN = /[\p{lower}\p{upper}]/.freeze
 
       def handle_locally_case_insensitive_literal(literal)
         literal =~ HAS_CASE_PATTERN ? case_insensitivize(literal) : literal

data/lib/js_regex/converter/meta_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/property_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require 'character_set'
 

data/lib/js_regex/converter/set_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'escape_converter'
 require_relative 'type_converter'
@@ -41,11 +43,7 @@ class JsRegex
       def simple_convert_child(exp)
         case exp.type
         when :literal
-          return false if !context.u? &&
-            exp.text =~ LiteralConverter::ASTRAL_PLANE_CODEPOINT_PATTERN &&
-            !context.enable_u_option
-
-          LiteralConverter.escape_incompatible_bmp_literals(exp.text)
+          simple_convert_literal_child(exp)
         when :set
           # full conversion is needed for nested sets and intersections
           exp.token.equal?(:range) && exp.expressions.map do |op|
@@ -67,7 +65,20 @@ class JsRegex
         end
       end
 
-      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/
+      def simple_convert_literal_child(exp)
+        if !context.u? &&
+           exp.text =~ LiteralConverter::ASTRAL_PLANE_CODEPOINT_PATTERN &&
+           !context.enable_u_option
+          false
+        elsif SET_LITERALS_REQUIRING_ESCAPE_PATTERN.match?(exp.text)
+          "\\#{exp.text}"
+        else
+          LiteralConverter.escape_incompatible_bmp_literals(exp.text)
+        end
+      end
+
+      SET_LITERALS_REQUIRING_ESCAPE_PATTERN = Regexp.union(%w<( ) [ ] { } / - |>)
+      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/.freeze
       CONVERTIBLE_ESCAPE_TOKENS = %i[control meta_sequence bell escape octal] +
         EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS
 

data/lib/js_regex/converter/subexpression_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/type_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -10,10 +12,37 @@ class JsRegex
       NONHEX_EXPANSION           = '[^0-9A-Fa-f]'
       I_MODE_HEX_EXPANSION       = '[0-9A-F]'
       I_MODE_NONHEX_EXPANSION    = '[^0-9A-F]'
+      LINEBREAK_EXPANSION        = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
       ES2018_HEX_EXPANSION       = '\p{AHex}'
       ES2018_NONHEX_EXPANSION    = '\P{AHex}'
-      ES2018_XGRAPHEME_EXPANSION = '[\P{M}\P{Lm}](?:(?:[\u035C\u0361]\P{M}\p{M}*)|\u200d|\p{M}|\p{Lm}|\p{Emoji_Modifier})*'
-      LINEBREAK_EXPANSION        = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
+      # partially taken from https://unicode.org/reports/tr51/#EBNF_and_Regex
+      ES2018_XGRAPHEME_EXPANSION = <<-'REGEXP'.gsub(/\s+/, '')
+        (?:
+          \r\n
+        |
+          \p{RI}\p{RI}
+        |
+          \p{Emoji}
+          (?:
+            \p{EMod}
+          |
+            \uFE0F\u20E3?
+          |
+            [\u{E0020}-\u{E007E}]+\u{E007F}
+          )?
+          (?:
+            \u200D
+            (?:
+              \p{RI}\p{RI}
+            |
+              \p{Emoji}(?:\p{EMod}|\uFE0F\u20E3?|[\u{E0020}-\u{E007E}]+\u{E007F})?
+            )
+          )*
+        |
+          [\P{M}\P{Lm}](?:\u200d|\p{M}|\p{Lm}|\p{Emoji_Modifier})*
+        )
+      REGEXP
+
 
       def self.directly_compatible?(expression, _context = nil)
         case expression.token
@@ -30,7 +59,7 @@ class JsRegex
         case subtype
         when :hex then hex_expansion
         when :nonhex then nonhex_expansion
-        when :linebreak then LINEBREAK_EXPANSION
+        when :linebreak then linebreak_expansion
         when :xgrapheme then xgrapheme
         when :digit, :space, :word
           return pass_through if self.class.directly_compatible?(expression)
@@ -63,6 +92,10 @@ class JsRegex
         end
       end
 
+      def linebreak_expansion
+        wrap_in_backrefed_lookahead(LINEBREAK_EXPANSION)
+      end
+
       def negative_set_substitution
         # ::of_expression returns an inverted set for negative expressions,
         # so we need to un-invert before wrapping in [^ and ]. Kinda lame.
@@ -79,7 +112,7 @@ class JsRegex
 
       def xgrapheme
         if context.es_2018_or_higher? && context.enable_u_option
-          ES2018_XGRAPHEME_EXPANSION
+          wrap_in_backrefed_lookahead(ES2018_XGRAPHEME_EXPANSION)
         else
           warn_of_unsupported_feature
         end

data/lib/js_regex/converter/unsupported_token_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     Dir[File.join(__dir__, 'converter', '*.rb')].sort.each do |file|

data/lib/js_regex/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   # This is mixed into errors, e.g. those thrown by the parser,
   # allowing to `rescue JsRegex::Error`.

data/lib/js_regex/node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # Converter#convert result. Represents a branch or leaf node with an optional
@@ -10,6 +12,7 @@ class JsRegex
 
     TYPES = %i[
       backref
+      branch
       captured_group
       conditional
       dropped
@@ -47,7 +50,7 @@ class JsRegex
       case type
       when :dropped
         ''
-      when :backref, :captured_group, :plain
+      when :backref, :branch, :captured_group, :plain
         children.join << quantifier.to_s
       else
         raise TypeError.new(
@@ -63,6 +66,10 @@ class JsRegex
       self
     end
 
+    def optional?
+      quantifier && quantifier.min == 0
+    end
+
     private
 
     TypeError = Class.new(::TypeError).extend(JsRegex::Error)

data/lib/js_regex/second_pass.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # After conversion of a full Regexp::Expression tree, this
@@ -8,6 +10,7 @@ class JsRegex
       def call(tree)
         substitute_root_level_keep_mark(tree)
         alternate_conditional_permutations(tree)
+        handle_non_participating_backrefs(tree)
         tree
       end
 
@@ -26,12 +29,49 @@ class JsRegex
         tree.update(children: [lookbehind, *post])
       end
 
+      def handle_non_participating_backrefs(tree)
+        level = 0
+        completed_group_numbers = {}
+        group_branches = {}
+        branch_stack = []
+
+        crawl(tree, true) do |node, event|
+          case [node.type, event]
+          when [:branch, :enter]
+            branch_stack.push(node)
+          when [:branch, :exit]
+            branch_stack.pop
+          when [:captured_group, :enter]
+            level += 1
+          when [:captured_group, :exit]
+            unless node.optional? # ignore optional groups
+              group_branches[node.reference] = branch_stack.last
+            end
+            number = level
+            number += 1 while completed_group_numbers[number]
+            completed_group_numbers[number] = true
+            level -= 1
+          when [:backref, :exit]
+            ref_branch = group_branches[node.reference]
+            current_branch = branch_stack.last
+
+            # make bad backrefs non-matchable
+            references_other_branch =
+              ref_branch && current_branch && ref_branch != current_branch
+            forward_reference = !completed_group_numbers[node.reference]
+            if references_other_branch || forward_reference
+              node.update(type: :plain, children: ['(?!)'])
+            end
+          end
+        end
+      end
+
       def alternate_conditional_permutations(tree)
         permutations = conditional_tree_permutations(tree)
         return if permutations.empty?
 
         alternatives = permutations.map.with_index do |variant, i|
-          Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')')
+          Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')', type: :branch)
         end
         tree.update(children: alternatives)
       end
@@ -48,13 +88,16 @@ class JsRegex
           crawl(tree_permutation) do |node|
             build_permutation(node, conds, truthy_conds, caps_per_branch, i)
           end
+          tree_permutation
         end
       end
 
-      def crawl(node, &block)
+      def crawl(node, trace = false, &block)
         return if node.instance_of?(String)
-        yield(node)
-        node.children.each { |child| crawl(child, &block) }
+
+        trace ? yield(node, :enter) : yield(node)
+        node.children.each { |child| crawl(child, trace, &block) }
+        trace && yield(node, :exit)
       end
 
       def conditions(tree)
@@ -90,11 +133,6 @@ class JsRegex
           # backref numbers need to be incremented for subsequent "branches"
           adapt_backref_to_permutation(node, caps_per_branch, i)
         when :captured_group
-          # Remove name, c.f. :backref handling.
-          node.update(children: [
-            node.children.first.sub(/\?<.*>/, ''),
-            *node.children[1..-1]
-          ])
           # if the group is referenced by any condition, modulate its quantity
           if conds.include?(node.reference)
             adapt_referenced_group_to_permutation(node, truthy)
@@ -124,8 +162,9 @@ class JsRegex
       end
 
       def min_quantify(node)
-        return if guarantees_at_least_one_match?(qtf = node.quantifier)
+        return unless node.optional?
 
+        qtf = node.quantifier
         if qtf.max.equal?(1) # any zero_or_one quantifier (?, ??, ?+)
           node.update(quantifier: nil)
         else
@@ -135,10 +174,6 @@ class JsRegex
         end
       end
 
-      def guarantees_at_least_one_match?(quantifier)
-        quantifier.nil? || quantifier.min > 0
-      end
-
       def null_quantify(node)
         null_quantifier = Regexp::Expression::Quantifier.construct(text: '{0}')
         node.update(quantifier: null_quantifier)

data/lib/js_regex/target.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Target
     ES2009 = 'ES2009'

data/lib/js_regex/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
-  VERSION = '3.12.0'
+  VERSION = '3.14.0'
 end

data/lib/js_regex.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # JsRegex converts ::Regexp instances to JavaScript.
 #
 # Usage:

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.12.0
+  version: 3.14.0
 platform: ruby
 authors:
 - Janosch Müller
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -28,22 +27,16 @@ dependencies:
   name: regexp_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.6.2
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '2.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.6.2
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '2.11'
 - !ruby/object:Gem::Dependency
   name: regexp_property_values
   requirement: !ruby/object:Gem::Requirement
@@ -96,7 +89,6 @@ homepage: https://github.com/jaynetics/js_regex
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Converts Ruby regexes to JavaScript regexes.
 test_files: []