From c0cebaaa4f116a5f6595911cb59d9a8f47e5191a Mon Sep 17 00:00:00 2001
From: overlookmotel <theoverlookmotel@gmail.com>
Date: Thu, 5 Sep 2024 17:02:44 +0100
Subject: [PATCH] fix(transformer): RegExp transform handle `Term::Quantifier`

---
 crates/oxc_transformer/src/regexp/mod.rs | 28 ++++++++++++++----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/crates/oxc_transformer/src/regexp/mod.rs b/crates/oxc_transformer/src/regexp/mod.rs
index 31c3b26a6f343..d8942b270980e 100644
--- a/crates/oxc_transformer/src/regexp/mod.rs
+++ b/crates/oxc_transformer/src/regexp/mod.rs
@@ -197,27 +197,33 @@ impl<'a> RegExp<'a> {
     ///
     /// Based on parsed regular expression pattern.
     fn has_unsupported_regular_expression_pattern(&self, pattern: &Pattern<'a>) -> bool {
-        let terms_contains_unsupported = |terms: &[Term]| {
-            terms.iter().any(|term| match term {
-                Term::CapturingGroup(_) => self.named_capture_groups,
-                Term::UnicodePropertyEscape(_) => self.unicode_property_escapes,
+        pattern.body.body.iter().any(|alternative| {
+            alternative.body.iter().any(|term| self.term_contains_unsupported(term))
+        })
+    }
+
+    fn term_contains_unsupported(&self, mut term: &Term) -> bool {
+        // Loop because `Term::Quantifier` contains a nested `Term`
+        loop {
+            match term {
+                Term::CapturingGroup(_) => return self.named_capture_groups,
+                Term::UnicodePropertyEscape(_) => return self.unicode_property_escapes,
                 Term::CharacterClass(character_class) => {
-                    self.unicode_property_escapes
+                    return self.unicode_property_escapes
                         && character_class_has_unicode_property_escape(character_class)
                 }
                 Term::LookAroundAssertion(assertion) => {
-                    self.look_behind_assertions
+                    return self.look_behind_assertions
                         && matches!(
                             assertion.kind,
                             LookAroundAssertionKind::Lookbehind
                                 | LookAroundAssertionKind::NegativeLookbehind
                         )
                 }
-                _ => false,
-            })
-        };
-
-        pattern.body.body.iter().any(|alternative| terms_contains_unsupported(&alternative.body))
+                Term::Quantifier(quantifier) => term = &quantifier.body,
+                _ => return false,
+            }
+        }
     }
 }