decode regex if needed

src/js_ast.zig

@@ -2538,7 +2538,10 @@ pub const E = struct {
     };
 
     pub const RegExp = struct {
-        value: string,
+        data: union(enum) {
+            raw: string,
+            decoded: std.ArrayList(u16),
+        },
 
         // This exists for JavaScript bindings
         // The RegExp constructor expects flags as a second argument.
@@ -2548,7 +2551,7 @@ pub const E = struct {
         //      ^
         flags_offset: ?u16 = null,
 
-        pub var empty = RegExp{ .value = "" };
+        pub var empty = RegExp{ .data = .{ .raw = "" } };
 
         pub fn pattern(this: RegExp) string {
 

src/js_lexer.zig

@@ -295,7 +295,7 @@ fn NewLexer_(
             this.comments_to_preserve_before.clearAndFree();
         }
 
-        fn decodeEscapeSequences(lexer: *LexerType, start: usize, text: string, comptime BufType: type, buf_: *BufType) !void {
+        pub fn decodeEscapeSequences(lexer: *LexerType, start: usize, text: string, comptime BufType: type, buf_: *BufType) !void {
             var buf = buf_.*;
             defer buf_.* = buf;
             if (comptime is_json) lexer.is_ascii_only = false;
@@ -2075,9 +2075,11 @@ fn NewLexer_(
             if (comptime is_json) unreachable;
         }
 
-        pub fn scanRegExp(lexer: *LexerType) !void {
+        // returns true of the regex contents need to be decoded
+        pub fn scanRegExp(lexer: *LexerType) !bool {
             lexer.assertNotJSON();
             lexer.regex_flags_start = null;
+            var decode = lexer.code_point >= 0x80;
             while (true) {
                 switch (lexer.code_point) {
                     '/' => {
@@ -2121,20 +2123,48 @@ fn NewLexer_(
                                 },
                             }
                         }
-                        return;
+
+                        return decode;
                     },
                     '[' => {
                         lexer.step();
+                        if (lexer.code_point >= 0x80) decode = true;
                         while (lexer.code_point != ']') {
-                            try lexer.scanRegExpValidateAndStep();
+                            try lexer.scanRegExpValidateAndStep(&decode);
                         }
                         lexer.step();
+                        if (lexer.code_point >= 0x80) decode = true;
                     },
                     else => {
-                        try lexer.scanRegExpValidateAndStep();
+                        try lexer.scanRegExpValidateAndStep(&decode);
                     },
                 }
             }
+
+            return decode;
+        }
+
+        fn scanRegExpValidateAndStep(lexer: *LexerType, decode: *bool) !void {
+            lexer.assertNotJSON();
+
+            if (lexer.code_point == '\\') {
+                lexer.step();
+                if (lexer.code_point >= 0x80) decode.* = true;
+            }
+
+            switch (lexer.code_point) {
+                '\r', '\n', 0x2028, 0x2029 => {
+                    // Newlines aren't allowed in regular expressions
+                    try lexer.syntaxError();
+                },
+                -1 => { // EOF
+                    try lexer.syntaxError();
+                },
+                else => {
+                    lexer.step();
+                    if (lexer.code_point >= 0x80) decode.* = true;
+                },
+            }
         }
 
         // TODO: use wtf-8 encoding.
@@ -2592,27 +2622,6 @@ fn NewLexer_(
             try lexer.nextInsideJSXElement();
         }
 
-        fn scanRegExpValidateAndStep(lexer: *LexerType) !void {
-            lexer.assertNotJSON();
-
-            if (lexer.code_point == '\\') {
-                lexer.step();
-            }
-
-            switch (lexer.code_point) {
-                '\r', '\n', 0x2028, 0x2029 => {
-                    // Newlines aren't allowed in regular expressions
-                    try lexer.syntaxError();
-                },
-                -1 => { // EOF
-                    try lexer.syntaxError();
-                },
-                else => {
-                    lexer.step();
-                },
-            }
-        }
-
         pub fn rescanCloseBraceAsTemplateToken(lexer: *LexerType) !void {
             lexer.assertNotJSON();
 

src/js_parser.zig

@@ -13095,13 +13095,39 @@ fn NewParser_(
                     return p.newExpr(E.BigInt{ .value = value }, loc);
                 },
                 .t_slash, .t_slash_equals => {
-                    try p.lexer.scanRegExp();
+                    const needs_decode = try p.lexer.scanRegExp();
                     // always set regex_flags_start to null to make sure we don't accidentally use the wrong value later
                     defer p.lexer.regex_flags_start = null;
-                    const value = p.lexer.raw();
+
+                    const raw = p.lexer.raw();
+
+                    if (!needs_decode) {
+                        try p.lexer.next();
+                        return p.newExpr(
+                            E.RegExp{
+                                .data = .{
+                                    .raw = raw,
+                                },
+                                .flags_offset = p.lexer.regex_flags_start,
+                            },
+                            loc,
+                        );
+                    }
+
+                    var buf = std.ArrayList(u16).initCapacity(p.allocator, raw.len) catch unreachable;
+                    try p.lexer.decodeEscapeSequences(p.lexer.start, raw, @TypeOf(buf), &buf);
+
                     try p.lexer.next();
 
-                    return p.newExpr(E.RegExp{ .value = value, .flags_offset = p.lexer.regex_flags_start }, loc);
+                    return p.newExpr(
+                        E.RegExp{
+                            .data = .{
+                                .decoded = buf,
+                            },
+                            .flags_offset = p.lexer.regex_flags_start,
+                        },
+                        loc,
+                    );
                 },
                 .t_void => {
                     try p.lexer.next();