LibJS: Do not directly append RegExp pattern code points during parse

There apparently is a bit of a disconnect between the spec asking us to
construct the pattern using code points and LibRegex not being able to
swallow those. Whenever we had multi-byte code points in the pattern and
tried to match that in unicode mode, we would fail.

Change the parser to encode all non-ASCII code units. Fixes 2 test262
cases in `language/literals/regexp`.

Libraries/LibJS/Runtime/RegExpObject.cpp

@@ -96,19 +96,10 @@ ErrorOr<String, ParseRegexPatternError> parse_regex_pattern(StringView pattern,
     auto utf16_pattern = Utf16String::from_utf8(pattern);
     StringBuilder builder;
 
-    // If the Unicode flag is set, append each code point to the pattern. Otherwise, append each
-    // code unit. But unlike the spec, multi-byte code units must be escaped for LibRegex to parse.
+    // FIXME: We need to escape multi-byte code units for LibRegex to parse since the lexer there doesn't handle unicode.
     auto previous_code_unit_was_backslash = false;
-    for (size_t i = 0; i < utf16_pattern.length_in_code_units();) {
-        if (unicode || unicode_sets) {
-            auto code_point = code_point_at(utf16_pattern, i);
-            builder.append_code_point(code_point.code_point);
-            i += code_point.code_unit_count;
-            continue;
-        }
-
+    for (size_t i = 0; i < utf16_pattern.length_in_code_units(); ++i) {
         u16 code_unit = utf16_pattern.code_unit_at(i);
-        ++i;
 
         if (code_unit > 0x7f) {
             // Incorrectly escaping this code unit will result in a wildly different regex than intended

Libraries/LibJS/Tests/builtins/RegExp/RegExp.js

@@ -81,3 +81,19 @@ test("v flag should enable unicode mode", () => {
 test("parsing a large bytestring shouldn't crash", () => {
     RegExp(new Uint8Array(0x40000));
 });
+
+test("Unicode non-ASCII matching", () => {
+    const cases = [
+        { pattern: /é/u, match: "é", expected: ["é"] },
+        { pattern: /é/, match: "é", expected: ["é"] },
+        { pattern: /\u{61}/u, match: "a", expected: ["a"] },
+        { pattern: /\u{61}/, match: "a", expected: null },
+        { pattern: /😄/u, match: "😄", expected: ["😄"] },
+        { pattern: /😄/u, match: "\ud83d", expected: null },
+        { pattern: /😄/, match: "\ud83d", expected: null },
+    ];
+    for (const test of cases) {
+        const result = test.match.match(test.pattern);
+        expect(result).toEqual(test.expected);
+    }
+});