deps: update V8 to 7.5.288.22

PR-URL: https://github.com/nodejs/node/pull/27375
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>

22 files changed, 630 insertions, 323 deletions

diff --git a/deps/v8/src/regexp/arm/regexp-macro-assembler-arm.h b/deps/v8/src/regexp/arm/regexp-macro-assembler-arm.h
index 570b170dcd..c38d8a06d7 100644
--- a/deps/v8/src/regexp/arm/regexp-macro-assembler-arm.h
+++ b/deps/v8/src/regexp/arm/regexp-macro-assembler-arm.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerARM: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerARM(Isolate* isolate, Zone* zone, Mode mode,
                           int registers_to_save);
diff --git a/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h b/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
index 6eba91bd36..9c87bf37b6 100644
--- a/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
+++ b/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerARM64: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM64
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerARM64(Isolate* isolate, Zone* zone, Mode mode,
                             int registers_to_save);
diff --git a/deps/v8/src/regexp/ia32/regexp-macro-assembler-ia32.h b/deps/v8/src/regexp/ia32/regexp-macro-assembler-ia32.h
index 0a6eb558ab..eb6b0335a8 100644
--- a/deps/v8/src/regexp/ia32/regexp-macro-assembler-ia32.h
+++ b/deps/v8/src/regexp/ia32/regexp-macro-assembler-ia32.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerIA32: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerIA32
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerIA32(Isolate* isolate, Zone* zone, Mode mode,
                            int registers_to_save);
diff --git a/deps/v8/src/regexp/interpreter-irregexp.cc b/deps/v8/src/regexp/interpreter-irregexp.cc
index 526a3290f7..55b862dc56 100644
--- a/deps/v8/src/regexp/interpreter-irregexp.cc
+++ b/deps/v8/src/regexp/interpreter-irregexp.cc
@@ -21,8 +21,6 @@
 namespace v8 {
 namespace internal {
 
-typedef unibrow::Mapping<unibrow::Ecma262Canonicalize> Canonicalize;
-
 static bool BackRefMatchesNoCase(Isolate* isolate, int from, int current,
                                  int len, Vector<const uc16> subject,
                                  bool unicode) {
@@ -147,15 +145,82 @@ class BacktrackStack {
   DISALLOW_COPY_AND_ASSIGN(BacktrackStack);
 };
 
+namespace {
+
+IrregexpInterpreter::Result StackOverflow(Isolate* isolate) {
+  // We abort interpreter execution after the stack overflow is thrown, and thus
+  // allow allocation here despite the outer DisallowHeapAllocationScope.
+  AllowHeapAllocation yes_gc;
+  isolate->StackOverflow();
+  return IrregexpInterpreter::EXCEPTION;
+}
+
+// Runs all pending interrupts. Callers must update unhandlified object
+// references after this function completes.
+IrregexpInterpreter::Result HandleInterrupts(Isolate* isolate,
+                                             Handle<String> subject_string) {
+  DisallowHeapAllocation no_gc;
+
+  StackLimitCheck check(isolate);
+  if (check.JsHasOverflowed()) {
+    // A real stack overflow.
+    return StackOverflow(isolate);
+  }
+
+  const bool was_one_byte =
+      String::IsOneByteRepresentationUnderneath(*subject_string);
+
+  Object result;
+  {
+    AllowHeapAllocation yes_gc;
+    result = isolate->stack_guard()->HandleInterrupts();
+  }
+
+  if (result->IsException(isolate)) {
+    return IrregexpInterpreter::EXCEPTION;
+  }
+
+  // If we changed between a LATIN1 and a UC16 string, we need to restart
+  // regexp matching with the appropriate template instantiation of RawMatch.
+  if (String::IsOneByteRepresentationUnderneath(*subject_string) !=
+      was_one_byte) {
+    return IrregexpInterpreter::RETRY;
+  }
+
+  return IrregexpInterpreter::SUCCESS;
+}
+
+template <typename Char>
+void UpdateCodeAndSubjectReferences(Isolate* isolate,
+                                    Handle<ByteArray> code_array,
+                                    Handle<String> subject_string,
+                                    const byte** code_base_out,
+                                    const byte** pc_out,
+                                    Vector<const Char>* subject_string_out) {
+  DisallowHeapAllocation no_gc;
+
+  if (*code_base_out != code_array->GetDataStartAddress()) {
+    const intptr_t pc_offset = *pc_out - *code_base_out;
+    DCHECK_GT(pc_offset, 0);
+    *code_base_out = code_array->GetDataStartAddress();
+    *pc_out = *code_base_out + pc_offset;
+  }
+
+  DCHECK(subject_string->IsFlat());
+  *subject_string_out = subject_string->GetCharVector<Char>(no_gc);
+}
 
 template <typename Char>
-static RegExpImpl::IrregexpResult RawMatch(Isolate* isolate,
-                                           const byte* code_base,
-                                           Vector<const Char> subject,
-                                           int* registers,
-                                           int current,
-                                           uint32_t current_char) {
-  const byte* pc = code_base;
+IrregexpInterpreter::Result RawMatch(Isolate* isolate,
+                                     Handle<ByteArray> code_array,
+                                     Handle<String> subject_string,
+                                     Vector<const Char> subject, int* registers,
+                                     int current, uint32_t current_char) {
+  DisallowHeapAllocation no_gc;
+
+  const byte* pc = code_array->GetDataStartAddress();
+  const byte* code_base = pc;
+
   // BacktrackStack ensures that the memory allocated for the backtracking stack
   // is returned to the system or cached if there is no stack being cached at
   // the moment.
@@ -175,21 +240,21 @@ static RegExpImpl::IrregexpResult RawMatch(Isolate* isolate,
         UNREACHABLE();
       BYTECODE(PUSH_CP)
         if (--backtrack_stack_space < 0) {
-          return RegExpImpl::RE_EXCEPTION;
+          return StackOverflow(isolate);
         }
         *backtrack_sp++ = current;
         pc += BC_PUSH_CP_LENGTH;
         break;
       BYTECODE(PUSH_BT)
         if (--backtrack_stack_space < 0) {
-          return RegExpImpl::RE_EXCEPTION;
+          return StackOverflow(isolate);
         }
         *backtrack_sp++ = Load32Aligned(pc + 4);
         pc += BC_PUSH_BT_LENGTH;
         break;
       BYTECODE(PUSH_REGISTER)
         if (--backtrack_stack_space < 0) {
-          return RegExpImpl::RE_EXCEPTION;
+          return StackOverflow(isolate);
         }
         *backtrack_sp++ = registers[insn >> BYTECODE_SHIFT];
         pc += BC_PUSH_REGISTER_LENGTH;
@@ -227,21 +292,30 @@ static RegExpImpl::IrregexpResult RawMatch(Isolate* isolate,
         current = *backtrack_sp;
         pc += BC_POP_CP_LENGTH;
         break;
-      BYTECODE(POP_BT)
+        // clang-format off
+      BYTECODE(POP_BT) {
+        IrregexpInterpreter::Result return_code = HandleInterrupts(
+            isolate, subject_string);
+        if (return_code != IrregexpInterpreter::SUCCESS) return return_code;
+
+        UpdateCodeAndSubjectReferences(isolate, code_array, subject_string,
+            &code_base, &pc, &subject);
+
         backtrack_stack_space++;
         --backtrack_sp;
         pc = code_base + *backtrack_sp;
         break;
-      BYTECODE(POP_REGISTER)
+      }
+      BYTECODE(POP_REGISTER)  // clang-format on
         backtrack_stack_space++;
         --backtrack_sp;
         registers[insn >> BYTECODE_SHIFT] = *backtrack_sp;
         pc += BC_POP_REGISTER_LENGTH;
         break;
       BYTECODE(FAIL)
-        return RegExpImpl::RE_FAILURE;
+      return IrregexpInterpreter::FAILURE;
       BYTECODE(SUCCEED)
-        return RegExpImpl::RE_SUCCESS;
+      return IrregexpInterpreter::SUCCESS;
       BYTECODE(ADVANCE_CP)
         current += insn >> BYTECODE_SHIFT;
         pc += BC_ADVANCE_CP_LENGTH;
@@ -584,38 +658,34 @@ static RegExpImpl::IrregexpResult RawMatch(Isolate* isolate,
   }
 }
 
+}  // namespace
 
-RegExpImpl::IrregexpResult IrregexpInterpreter::Match(
-    Isolate* isolate,
-    Handle<ByteArray> code_array,
-    Handle<String> subject,
-    int* registers,
-    int start_position) {
-  DCHECK(subject->IsFlat());
+// static
+IrregexpInterpreter::Result IrregexpInterpreter::Match(
+    Isolate* isolate, Handle<ByteArray> code_array,
+    Handle<String> subject_string, int* registers, int start_position) {
+  DCHECK(subject_string->IsFlat());
 
+  // Note: Heap allocation *is* allowed in two situations:
+  // 1. When creating & throwing a stack overflow exception. The interpreter
+  //    aborts afterwards, and thus possible-moved objects are never used.
+  // 2. When handling interrupts. We manually relocate unhandlified references
+  //    after interrupts have run.
   DisallowHeapAllocation no_gc;
-  const byte* code_base = code_array->GetDataStartAddress();
+
   uc16 previous_char = '\n';
-  String::FlatContent subject_content = subject->GetFlatContent(no_gc);
+  String::FlatContent subject_content = subject_string->GetFlatContent(no_gc);
   if (subject_content.IsOneByte()) {
     Vector<const uint8_t> subject_vector = subject_content.ToOneByteVector();
     if (start_position != 0) previous_char = subject_vector[start_position - 1];
-    return RawMatch(isolate,
-                    code_base,
-                    subject_vector,
-                    registers,
-                    start_position,
-                    previous_char);
+    return RawMatch(isolate, code_array, subject_string, subject_vector,
+                    registers, start_position, previous_char);
   } else {
     DCHECK(subject_content.IsTwoByte());
     Vector<const uc16> subject_vector = subject_content.ToUC16Vector();
     if (start_position != 0) previous_char = subject_vector[start_position - 1];
-    return RawMatch(isolate,
-                    code_base,
-                    subject_vector,
-                    registers,
-                    start_position,
-                    previous_char);
+    return RawMatch(isolate, code_array, subject_string, subject_vector,
+                    registers, start_position, previous_char);
   }
 }
 
diff --git a/deps/v8/src/regexp/interpreter-irregexp.h b/deps/v8/src/regexp/interpreter-irregexp.h
index c51e320a07..a57d40854e 100644
--- a/deps/v8/src/regexp/interpreter-irregexp.h
+++ b/deps/v8/src/regexp/interpreter-irregexp.h
@@ -12,16 +12,19 @@
 namespace v8 {
 namespace internal {
 
-class IrregexpInterpreter {
+class V8_EXPORT_PRIVATE IrregexpInterpreter {
  public:
-  static RegExpImpl::IrregexpResult Match(Isolate* isolate,
-                                          Handle<ByteArray> code,
-                                          Handle<String> subject,
-                                          int* captures,
-                                          int start_position);
+  enum Result { RETRY = -2, EXCEPTION = -1, FAILURE = 0, SUCCESS = 1 };
+  STATIC_ASSERT(EXCEPTION == static_cast<int>(RegExpImpl::RE_EXCEPTION));
+  STATIC_ASSERT(FAILURE == static_cast<int>(RegExpImpl::RE_FAILURE));
+  STATIC_ASSERT(SUCCESS == static_cast<int>(RegExpImpl::RE_SUCCESS));
+
+  // The caller is responsible for initializing registers before each call.
+  static Result Match(Isolate* isolate, Handle<ByteArray> code_array,
+                      Handle<String> subject_string, int* registers,
+                      int start_position);
 };
 
-
 }  // namespace internal
 }  // namespace v8
 
diff --git a/deps/v8/src/regexp/jsregexp.cc b/deps/v8/src/regexp/jsregexp.cc
index 7d94adfb86..7995505226 100644
--- a/deps/v8/src/regexp/jsregexp.cc
+++ b/deps/v8/src/regexp/jsregexp.cc
@@ -477,27 +477,40 @@ int RegExpImpl::IrregexpExecRaw(Isolate* isolate, Handle<JSRegExp> regexp,
     int number_of_capture_registers =
         (IrregexpNumberOfCaptures(*irregexp) + 1) * 2;
     int32_t* raw_output = &output[number_of_capture_registers];
-    // We do not touch the actual capture result registers until we know there
-    // has been a match so that we can use those capture results to set the
-    // last match info.
-    for (int i = number_of_capture_registers - 1; i >= 0; i--) {
-      raw_output[i] = -1;
-    }
-    Handle<ByteArray> byte_codes(IrregexpByteCode(*irregexp, is_one_byte),
-                                 isolate);
 
-    IrregexpResult result = IrregexpInterpreter::Match(
-        isolate, byte_codes, subject, raw_output, index);
-    if (result == RE_SUCCESS) {
-      // Copy capture results to the start of the registers array.
-      MemCopy(output, raw_output,
-              number_of_capture_registers * sizeof(int32_t));
-    }
-    if (result == RE_EXCEPTION) {
-      DCHECK(!isolate->has_pending_exception());
-      isolate->StackOverflow();
-    }
-    return result;
+    do {
+      // We do not touch the actual capture result registers until we know there
+      // has been a match so that we can use those capture results to set the
+      // last match info.
+      for (int i = number_of_capture_registers - 1; i >= 0; i--) {
+        raw_output[i] = -1;
+      }
+      Handle<ByteArray> byte_codes(IrregexpByteCode(*irregexp, is_one_byte),
+                                   isolate);
+
+      IrregexpInterpreter::Result result = IrregexpInterpreter::Match(
+          isolate, byte_codes, subject, raw_output, index);
+      DCHECK_IMPLIES(result == IrregexpInterpreter::EXCEPTION,
+                     isolate->has_pending_exception());
+
+      switch (result) {
+        case IrregexpInterpreter::SUCCESS:
+          // Copy capture results to the start of the registers array.
+          MemCopy(output, raw_output,
+                  number_of_capture_registers * sizeof(int32_t));
+          return result;
+        case IrregexpInterpreter::EXCEPTION:
+        case IrregexpInterpreter::FAILURE:
+          return result;
+        case IrregexpInterpreter::RETRY:
+          // The string has changed representation, and we must restart the
+          // match.
+          is_one_byte = String::IsOneByteRepresentationUnderneath(*subject);
+          EnsureCompiledIrregexp(isolate, regexp, subject, is_one_byte);
+          break;
+      }
+    } while (true);
+    UNREACHABLE();
   }
 }
 
@@ -1530,7 +1543,26 @@ void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,
 // that cannot occur in the source string because it is Latin1.
 static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
                                      bool one_byte_subject,
-                                     unibrow::uchar* letters) {
+                                     unibrow::uchar* letters,
+                                     int letter_length) {
+#ifdef V8_INTL_SUPPORT
+  icu::UnicodeSet set;
+  set.add(character);
+  set = set.closeOver(USET_CASE_INSENSITIVE);
+  int32_t range_count = set.getRangeCount();
+  int items = 0;
+  for (int32_t i = 0; i < range_count; i++) {
+    UChar32 start = set.getRangeStart(i);
+    UChar32 end = set.getRangeEnd(i);
+    CHECK(end - start + items <= letter_length);
+    while (start <= end) {
+      if (one_byte_subject && start > String::kMaxOneByteCharCode) break;
+      letters[items++] = (unibrow::uchar)(start);
+      start++;
+    }
+  }
+  return items;
+#else
   int length =
       isolate->jsregexp_uncanonicalize()->get(character, '\0', letters);
   // Unibrow returns 0 or 1 for characters where case independence is
@@ -1551,9 +1583,9 @@ static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
   }
 
   return length;
+#endif  // V8_INTL_SUPPORT
 }
 
-
 static inline bool EmitSimpleCharacter(Isolate* isolate,
                                        RegExpCompiler* compiler,
                                        uc16 c,
@@ -1586,8 +1618,8 @@ static inline bool EmitAtomNonLetter(Isolate* isolate,
                                      bool preloaded) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   bool one_byte = compiler->one_byte();
-  unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
+  unibrow::uchar chars[4];
+  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars, 4);
   if (length < 1) {
     // This can't match.  Must be an one-byte subject and a non-one-byte
     // character.  We do not need to do anything since the one-byte pass
@@ -1647,14 +1679,9 @@ static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
   return false;
 }
 
-
-typedef bool EmitCharacterFunction(Isolate* isolate,
-                                   RegExpCompiler* compiler,
-                                   uc16 c,
-                                   Label* on_failure,
-                                   int cp_offset,
-                                   bool check,
-                                   bool preloaded);
+using EmitCharacterFunction = bool(Isolate* isolate, RegExpCompiler* compiler,
+                                   uc16 c, Label* on_failure, int cp_offset,
+                                   bool check, bool preloaded);
 
 // Only emits letters (things that have case).  Only used for case independent
 // matches.
@@ -1667,8 +1694,8 @@ static inline bool EmitAtomLetter(Isolate* isolate,
                                   bool preloaded) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   bool one_byte = compiler->one_byte();
-  unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
+  unibrow::uchar chars[4];
+  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars, 4);
   if (length <= 1) return false;
   // We may not need to check against the end of the input string
   // if this character lies before a character that matched.
@@ -1676,7 +1703,6 @@ static inline bool EmitAtomLetter(Isolate* isolate,
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
   }
   Label ok;
-  DCHECK_EQ(4, unibrow::Ecma262UnCanonicalize::kMaxWidth);
   switch (length) {
     case 2: {
       if (ShortCutEmitCharacterPair(macro_assembler, one_byte, chars[0],
@@ -1794,7 +1820,7 @@ static void EmitUseLookupTable(
   }
   Factory* factory = masm->isolate()->factory();
   // TODO(erikcorry): Cache these.
-  Handle<ByteArray> ba = factory->NewByteArray(kSize, TENURED);
+  Handle<ByteArray> ba = factory->NewByteArray(kSize, AllocationType::kOld);
   for (int i = 0; i < kSize; i++) {
     ba->set(i, templ[i]);
   }
@@ -2472,9 +2498,9 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
             details->positions(characters_filled_in);
         uc16 c = quarks[i];
         if (elm.atom()->ignore_case()) {
-          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-          int length = GetCaseIndependentLetters(isolate, c,
-                                                 compiler->one_byte(), chars);
+          unibrow::uchar chars[4];
+          int length = GetCaseIndependentLetters(
+              isolate, c, compiler->one_byte(), chars, 4);
           if (length == 0) {
             // This can happen because all case variants are non-Latin1, but we
             // know the input is Latin1.
@@ -3747,7 +3773,8 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
   }
 
   Factory* factory = masm->isolate()->factory();
-  Handle<ByteArray> boolean_skip_table = factory->NewByteArray(kSize, TENURED);
+  Handle<ByteArray> boolean_skip_table =
+      factory->NewByteArray(kSize, AllocationType::kOld);
   int skip_distance = GetSkipTable(
       min_lookahead, max_lookahead, boolean_skip_table);
   DCHECK_NE(0, skip_distance);
@@ -5101,6 +5128,17 @@ int CompareFirstChar(RegExpTree* const* a, RegExpTree* const* b) {
   return 0;
 }
 
+#ifdef V8_INTL_SUPPORT
+
+// Case Insensitve comparesion
+int CompareFirstCharCaseInsensitve(RegExpTree* const* a, RegExpTree* const* b) {
+  RegExpAtom* atom1 = (*a)->AsAtom();
+  RegExpAtom* atom2 = (*b)->AsAtom();
+  icu::UnicodeString character1(atom1->data().at(0));
+  return character1.caseCompare(atom2->data().at(0), U_FOLD_CASE_DEFAULT);
+}
+
+#else
 
 static unibrow::uchar Canonical(
     unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize,
@@ -5113,7 +5151,6 @@ static unibrow::uchar Canonical(
   return canonical;
 }
 
-
 int CompareFirstCharCaseIndependent(
     unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize,
     RegExpTree* const* a, RegExpTree* const* b) {
@@ -5128,7 +5165,7 @@ int CompareFirstCharCaseIndependent(
   }
   return static_cast<int>(character1) - static_cast<int>(character2);
 }
-
+#endif  // V8_INTL_SUPPORT
 
 // We can stable sort runs of atoms, since the order does not matter if they
 // start with different characters.
@@ -5164,6 +5201,10 @@ bool RegExpDisjunction::SortConsecutiveAtoms(RegExpCompiler* compiler) {
     DCHECK_LE(i, alternatives->length());
     DCHECK_LE(first_atom, i);
     if (IgnoreCase(flags)) {
+#ifdef V8_INTL_SUPPORT
+      alternatives->StableSort(CompareFirstCharCaseInsensitve, first_atom,
+                               i - first_atom);
+#else
       unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize =
           compiler->isolate()->regexp_macro_assembler_canonicalize();
       auto compare_closure =
@@ -5171,6 +5212,7 @@ bool RegExpDisjunction::SortConsecutiveAtoms(RegExpCompiler* compiler) {
             return CompareFirstCharCaseIndependent(canonicalize, a, b);
           };
       alternatives->StableSort(compare_closure, first_atom, i - first_atom);
+#endif  // V8_INTL_SUPPORT
     } else {
       alternatives->StableSort(CompareFirstChar, first_atom, i - first_atom);
     }
@@ -5197,7 +5239,11 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) {
     }
     RegExpAtom* const atom = alternative->AsAtom();
     JSRegExp::Flags flags = atom->flags();
+#ifdef V8_INTL_SUPPORT
+    icu::UnicodeString common_prefix(atom->data().at(0));
+#else
     unibrow::uchar common_prefix = atom->data().at(0);
+#endif  // V8_INTL_SUPPORT
     int first_with_prefix = i;
     int prefix_length = atom->length();
     i++;
@@ -5206,6 +5252,14 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) {
       if (!alternative->IsAtom()) break;
       RegExpAtom* const atom = alternative->AsAtom();
       if (atom->flags() != flags) break;
+#ifdef V8_INTL_SUPPORT
+      icu::UnicodeString new_prefix(atom->data().at(0));
+      if (new_prefix != common_prefix) {
+        if (!IgnoreCase(flags)) break;
+        if (common_prefix.caseCompare(new_prefix, U_FOLD_CASE_DEFAULT) != 0)
+          break;
+      }
+#else
       unibrow::uchar new_prefix = atom->data().at(0);
       if (new_prefix != common_prefix) {
         if (!IgnoreCase(flags)) break;
@@ -5215,6 +5269,7 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) {
         common_prefix = Canonical(canonicalize, common_prefix);
         if (new_prefix != common_prefix) break;
       }
+#endif  // V8_INTL_SUPPORT
       prefix_length = Min(prefix_length, atom->length());
       i++;
     }
@@ -5880,6 +5935,53 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
                                         bool is_one_byte) {
   CharacterRange::Canonicalize(ranges);
   int range_count = ranges->length();
+#ifdef V8_INTL_SUPPORT
+  icu::UnicodeSet already_added;
+  icu::UnicodeSet others;
+  for (int i = 0; i < range_count; i++) {
+    CharacterRange range = ranges->at(i);
+    uc32 bottom = range.from();
+    if (bottom > String::kMaxUtf16CodeUnit) continue;
+    uc32 top = Min(range.to(), String::kMaxUtf16CodeUnit);
+    // Nothing to be done for surrogates.
+    if (bottom >= kLeadSurrogateStart && top <= kTrailSurrogateEnd) continue;
+    if (is_one_byte && !RangeContainsLatin1Equivalents(range)) {
+      if (bottom > String::kMaxOneByteCharCode) continue;
+      if (top > String::kMaxOneByteCharCode) top = String::kMaxOneByteCharCode;
+    }
+    already_added.add(bottom, top);
+    while (bottom <= top) {
+      icu::UnicodeString upper(bottom);
+      upper.toUpper();
+      icu::UnicodeSet expanded(bottom, bottom);
+      expanded.closeOver(USET_CASE_INSENSITIVE);
+      for (int32_t i = 0; i < expanded.getRangeCount(); i++) {
+        UChar32 start = expanded.getRangeStart(i);
+        UChar32 end = expanded.getRangeEnd(i);
+        while (start <= end) {
+          icu::UnicodeString upper2(start);
+          upper2.toUpper();
+          // Only add if the upper case are the same.
+          if (upper[0] == upper2[0]) {
+            others.add(start);
+          }
+          start++;
+        }
+      }
+      bottom++;
+    }
+  }
+  others.removeAll(already_added);
+  for (int32_t i = 0; i < others.getRangeCount(); i++) {
+    UChar32 start = others.getRangeStart(i);
+    UChar32 end = others.getRangeEnd(i);
+    if (start == end) {
+      ranges->Add(CharacterRange::Singleton(start), zone);
+    } else {
+      ranges->Add(CharacterRange::Range(start, end), zone);
+    }
+  }
+#else
   for (int i = 0; i < range_count; i++) {
     CharacterRange range = ranges->at(i);
     uc32 bottom = range.from();
@@ -5945,9 +6047,9 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
       }
     }
   }
+#endif  // V8_INTL_SUPPORT
 }
 
-
 bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
   DCHECK_NOT_NULL(ranges);
   int n = ranges->length();
@@ -6425,10 +6527,10 @@ void TextNode::FillInBMInfo(Isolate* isolate, int initial_offset, int budget,
         }
         uc16 character = atom->data()[j];
         if (IgnoreCase(atom->flags())) {
-          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+          unibrow::uchar chars[4];
           int length = GetCaseIndependentLetters(
               isolate, character, bm->max_char() == String::kMaxOneByteCharCode,
-              chars);
+              chars, 4);
           for (int j = 0; j < length; j++) {
             bm->Set(offset, chars[j]);
           }
diff --git a/deps/v8/src/regexp/jsregexp.h b/deps/v8/src/regexp/jsregexp.h
index 109dd91606..0a0b5c10d6 100644
--- a/deps/v8/src/regexp/jsregexp.h
+++ b/deps/v8/src/regexp/jsregexp.h
@@ -207,7 +207,7 @@ class OutSet: public ZoneObject {
  public:
   OutSet() : first_(0), remaining_(nullptr), successors_(nullptr) {}
   OutSet* Extend(unsigned value, Zone* zone);
-  bool Get(unsigned value) const;
+  V8_EXPORT_PRIVATE bool Get(unsigned value) const;
   static const unsigned kFirstLimit = 32;
 
  private:
@@ -258,8 +258,8 @@ class DispatchTable : public ZoneObject {
 
   class Config {
    public:
-    typedef uc32 Key;
-    typedef Entry Value;
+    using Key = uc32;
+    using Value = Entry;
     static const uc32 kNoKey;
     static const Entry NoValue() { return Value(); }
     static inline int Compare(uc32 a, uc32 b) {
@@ -272,8 +272,8 @@ class DispatchTable : public ZoneObject {
     }
   };
 
-  void AddRange(CharacterRange range, int value, Zone* zone);
-  OutSet* Get(uc32 value);
+  V8_EXPORT_PRIVATE void AddRange(CharacterRange range, int value, Zone* zone);
+  V8_EXPORT_PRIVATE OutSet* Get(uc32 value);
   void Dump();
 
   template <typename Callback>
@@ -294,7 +294,8 @@ class DispatchTable : public ZoneObject {
 // Categorizes character ranges into BMP, non-BMP, lead, and trail surrogates.
 class UnicodeRangeSplitter {
  public:
-  UnicodeRangeSplitter(Zone* zone, ZoneList<CharacterRange>* base);
+  V8_EXPORT_PRIVATE UnicodeRangeSplitter(Zone* zone,
+                                         ZoneList<CharacterRange>* base);
   void Call(uc32 from, DispatchTable::Entry entry);
 
   ZoneList<CharacterRange>* bmp() { return bmp_; }
@@ -318,7 +319,6 @@ class UnicodeRangeSplitter {
   ZoneList<CharacterRange>* non_bmp_;
 };
 
-
 #define FOR_EACH_NODE_TYPE(VISIT)                                    \
   VISIT(End)                                                         \
   VISIT(Action)                                                      \
@@ -1403,7 +1403,7 @@ FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 
 // Node visitor used to add the start set of the alternatives to the
 // dispatch table of a choice node.
-class DispatchTableConstructor: public NodeVisitor {
+class V8_EXPORT_PRIVATE DispatchTableConstructor : public NodeVisitor {
  public:
   DispatchTableConstructor(DispatchTable* table, bool ignore_case,
                            Zone* zone)
@@ -1435,7 +1435,6 @@ FOR_EACH_NODE_TYPE(DECLARE_VISIT)
   Zone* zone_;
 };
 
-
 // Assertion propagation moves information about assertions such as
 // \b to the affected nodes.  For instance, in /.\b./ information must
 // be propagated to the first '.' that whatever follows needs to know
@@ -1507,16 +1506,15 @@ class RegExpEngine: public AllStatic {
     int const num_registers = 0;
   };
 
-  static CompilationResult Compile(Isolate* isolate, Zone* zone,
-                                   RegExpCompileData* input,
-                                   JSRegExp::Flags flags,
-                                   Handle<String> pattern,
-                                   Handle<String> sample_subject,
-                                   bool is_one_byte);
+  V8_EXPORT_PRIVATE static CompilationResult Compile(
+      Isolate* isolate, Zone* zone, RegExpCompileData* input,
+      JSRegExp::Flags flags, Handle<String> pattern,
+      Handle<String> sample_subject, bool is_one_byte);
 
   static bool TooMuchRegExpCode(Isolate* isolate, Handle<String> pattern);
 
-  static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
+  V8_EXPORT_PRIVATE static void DotPrint(const char* label, RegExpNode* node,
+                                         bool ignore_case);
 };
 
 
diff --git a/deps/v8/src/regexp/mips/OWNERS b/deps/v8/src/regexp/mips/OWNERS
index b455d9ef29..cab3679d65 100644
--- a/deps/v8/src/regexp/mips/OWNERS
+++ b/deps/v8/src/regexp/mips/OWNERS
@@ -1,3 +1 @@
-arikalo@wavecomp.com
-prudic@wavecomp.com
-skovacevic@wavecomp.com
+xwafish@gmail.com
diff --git a/deps/v8/src/regexp/mips/regexp-macro-assembler-mips.h b/deps/v8/src/regexp/mips/regexp-macro-assembler-mips.h
index 0fabd7e9f6..51004ecc97 100644
--- a/deps/v8/src/regexp/mips/regexp-macro-assembler-mips.h
+++ b/deps/v8/src/regexp/mips/regexp-macro-assembler-mips.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerMIPS: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerMIPS(Isolate* isolate, Zone* zone, Mode mode,
                            int registers_to_save);
diff --git a/deps/v8/src/regexp/mips64/OWNERS b/deps/v8/src/regexp/mips64/OWNERS
index b455d9ef29..cab3679d65 100644
--- a/deps/v8/src/regexp/mips64/OWNERS
+++ b/deps/v8/src/regexp/mips64/OWNERS
@@ -1,3 +1 @@
-arikalo@wavecomp.com
-prudic@wavecomp.com
-skovacevic@wavecomp.com
+xwafish@gmail.com
diff --git a/deps/v8/src/regexp/mips64/regexp-macro-assembler-mips64.h b/deps/v8/src/regexp/mips64/regexp-macro-assembler-mips64.h
index 8d2b4fc521..179f4844d3 100644
--- a/deps/v8/src/regexp/mips64/regexp-macro-assembler-mips64.h
+++ b/deps/v8/src/regexp/mips64/regexp-macro-assembler-mips64.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerMIPS: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerMIPS(Isolate* isolate, Zone* zone, Mode mode,
                            int registers_to_save);
diff --git a/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.cc b/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.cc
index 09df471e52..a646aa17ef 100644
--- a/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.cc
+++ b/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.cc
@@ -1131,7 +1131,19 @@ void RegExpMacroAssemblerPPC::CallCheckStackGuardState(Register scratch) {
   ExternalReference stack_guard_check =
       ExternalReference::re_check_stack_guard_state(isolate());
   __ mov(ip, Operand(stack_guard_check));
-  __ StoreReturnAddressAndCall(ip);
+
+  if (FLAG_embedded_builtins) {
+    EmbeddedData d = EmbeddedData::FromBlob();
+    CHECK(Builtins::IsIsolateIndependent(Builtins::kDirectCEntry));
+    Address entry = d.InstructionStartOfBuiltin(Builtins::kDirectCEntry);
+    __ mov(r0, Operand(entry, RelocInfo::OFF_HEAP_TARGET));
+  } else {
+    // TODO(v8:8519): Remove this once embedded builtins are on unconditionally.
+    Handle<Code> code = BUILTIN_CODE(isolate(), DirectCEntry);
+    __ mov(r0, Operand(reinterpret_cast<intptr_t>(code.location()),
+                       RelocInfo::CODE_TARGET));
+  }
+  __ Call(r0);
 
   // Restore the stack pointer
   stack_space = kNumRequiredStackFrameSlots + stack_passed_arguments;
diff --git a/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.h b/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.h
index c364c54943..4e69daa1e5 100644
--- a/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.h
+++ b/deps/v8/src/regexp/ppc/regexp-macro-assembler-ppc.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerPPC : public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerPPC
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerPPC(Isolate* isolate, Zone* zone, Mode mode,
                           int registers_to_save);
diff --git a/deps/v8/src/regexp/property-sequences.cc b/deps/v8/src/regexp/property-sequences.cc
index 08194f1e70..9a48040083 100644
--- a/deps/v8/src/regexp/property-sequences.cc
+++ b/deps/v8/src/regexp/property-sequences.cc
@@ -18,22 +18,22 @@ package.json
 {
   "private": true,
   "dependencies": {
-    "unicode-11.0.0": "^0.7.8"
+    "unicode-12.0.0": "^0.7.9"
   }
 }
 ```
 
 generate-unicode-sequence-property-data.js
+
 ```
 const toHex = (symbol) => {
   return '0x' + symbol.codePointAt(0).toString(16)
                       .toUpperCase().padStart(6, '0');
 };
 
-```
 const generateData = (property) => {
   const sequences =
-      require(`unicode-11.0.0/Sequence_Property/${ property }/index.js`);
+      require(`unicode-12.0.0/Sequence_Property/${ property }/index.js`);
   const id = property.replace(/_/g, '') + 's';
   const buffer = [];
   for (const sequence of sequences) {
@@ -43,7 +43,7 @@ const generateData = (property) => {
   }
   const output =
       `const uc32 UnicodePropertySequences::k${ id }[] = {\n` +
-      `${ buffer.join('\n') }\n0  // null-terminating the list\n};\n`;
+      `${ buffer.join('\n') }\n    0  // null-terminating the list\n};\n`;
   return output;
 };
 
@@ -59,6 +59,7 @@ for (const property of properties) {
 ```
 */
 
+// clang-format off
 const uc32 UnicodePropertySequences::kEmojiFlagSequences[] = {
     0x01F1E6, 0x01F1E8, 0,
     0x01F1FF, 0x01F1FC, 0,
@@ -329,94 +330,8 @@ const uc32 UnicodePropertySequences::kEmojiTagSequences[] = {
 };
 
 const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
-    0x0026F9, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x0026F9, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C3, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3C4, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CA, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CB, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F3CC, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F3F3, 0x00FE0F, 0x00200D, 0x01F308, 0,
-    0x01F3F4, 0x00200D, 0x002620, 0x00FE0F, 0,
-    0x01F441, 0x00FE0F, 0x00200D, 0x01F5E8, 0x00FE0F, 0,
-    0x01F468, 0x00200D, 0x002695, 0x00FE0F, 0,
-    0x01F468, 0x00200D, 0x002696, 0x00FE0F, 0,
-    0x01F468, 0x00200D, 0x002708, 0x00FE0F, 0,
     0x01F468, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F468, 0,
-    0x01F468, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
-        0x01F468, 0,
-    0x01F468, 0x00200D, 0x01F33E, 0,
-    0x01F468, 0x00200D, 0x01F373, 0,
-    0x01F468, 0x00200D, 0x01F393, 0,
-    0x01F468, 0x00200D, 0x01F3A4, 0,
-    0x01F468, 0x00200D, 0x01F3A8, 0,
-    0x01F468, 0x00200D, 0x01F3EB, 0,
-    0x01F468, 0x00200D, 0x01F3ED, 0,
+    0x01F441, 0x00FE0F, 0x00200D, 0x01F5E8, 0x00FE0F, 0,
     0x01F468, 0x00200D, 0x01F466, 0,
     0x01F468, 0x00200D, 0x01F466, 0x00200D, 0x01F466, 0,
     0x01F468, 0x00200D, 0x01F467, 0,
@@ -432,16 +347,97 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0,
     0x01F468, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F466, 0,
     0x01F468, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F467, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FE, 0,
+    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F468, 0,
+    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F469, 0,
+    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
+        0x01F468, 0,
+    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
+        0x01F469, 0,
+    0x01F469, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F466, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F467, 0,
+    0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F467, 0,
+    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F466, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0,
+    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F466, 0,
+    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F467, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FE, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FF, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FE, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FF, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FB, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FE, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FF, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FB, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FC, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FF, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FB, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FC, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FD, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FB, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FC, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FD, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F468, 0x01F3FE, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FB, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FC, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FD, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F469, 0x01F3FE, 0,
+    0x01F9D1, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0,
+    0x01F9D1, 0x01F3FB, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FB, 0,
+    0x01F9D1, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FB, 0,
+    0x01F9D1, 0x01F3FC, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FC, 0,
+    0x01F9D1, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FB, 0,
+    0x01F9D1, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FC, 0,
+    0x01F9D1, 0x01F3FD, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FD, 0,
+    0x01F9D1, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FB, 0,
+    0x01F9D1, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FC, 0,
+    0x01F9D1, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FD, 0,
+    0x01F9D1, 0x01F3FE, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FE, 0,
+    0x01F9D1, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FB, 0,
+    0x01F9D1, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FC, 0,
+    0x01F9D1, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FD, 0,
+    0x01F9D1, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FE, 0,
+    0x01F9D1, 0x01F3FF, 0x00200D, 0x01F91D, 0x00200D, 0x01F9D1, 0x01F3FF, 0,
+    0x01F468, 0x00200D, 0x002695, 0x00FE0F, 0,
+    0x01F468, 0x00200D, 0x002696, 0x00FE0F, 0,
+    0x01F468, 0x00200D, 0x002708, 0x00FE0F, 0,
+    0x01F468, 0x00200D, 0x01F33E, 0,
+    0x01F468, 0x00200D, 0x01F373, 0,
+    0x01F468, 0x00200D, 0x01F393, 0,
+    0x01F468, 0x00200D, 0x01F3A4, 0,
+    0x01F468, 0x00200D, 0x01F3A8, 0,
+    0x01F468, 0x00200D, 0x01F3EB, 0,
+    0x01F468, 0x00200D, 0x01F3ED, 0,
     0x01F468, 0x00200D, 0x01F4BB, 0,
     0x01F468, 0x00200D, 0x01F4BC, 0,
     0x01F468, 0x00200D, 0x01F527, 0,
     0x01F468, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x00200D, 0x01F680, 0,
     0x01F468, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x00200D, 0x01F9BD, 0,
     0x01F468, 0x01F3FB, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F468, 0x01F3FB, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F468, 0x01F3FB, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -458,10 +454,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x01F3FB, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x01F3FB, 0x00200D, 0x01F680, 0,
     0x01F468, 0x01F3FB, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9BD, 0,
     0x01F468, 0x01F3FC, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F468, 0x01F3FC, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F468, 0x01F3FC, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -478,10 +473,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x01F3FC, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x01F3FC, 0x00200D, 0x01F680, 0,
     0x01F468, 0x01F3FC, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9BD, 0,
     0x01F468, 0x01F3FD, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F468, 0x01F3FD, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F468, 0x01F3FD, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -498,10 +492,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x01F3FD, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x01F3FD, 0x00200D, 0x01F680, 0,
     0x01F468, 0x01F3FD, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9BD, 0,
     0x01F468, 0x01F3FE, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F468, 0x01F3FE, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F468, 0x01F3FE, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -518,10 +511,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x01F3FE, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x01F3FE, 0x00200D, 0x01F680, 0,
     0x01F468, 0x01F3FE, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9BD, 0,
     0x01F468, 0x01F3FF, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F468, 0x01F3FF, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F468, 0x01F3FF, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -538,19 +530,12 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F468, 0x01F3FF, 0x00200D, 0x01F52C, 0,
     0x01F468, 0x01F3FF, 0x00200D, 0x01F680, 0,
     0x01F468, 0x01F3FF, 0x00200D, 0x01F692, 0,
-    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B0, 0,
-    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B1, 0,
-    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B2, 0,
-    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9AF, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9BC, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x00200D, 0x002708, 0x00FE0F, 0,
-    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F468, 0,
-    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F469, 0,
-    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
-        0x01F468, 0,
-    0x01F469, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
-        0x01F469, 0,
     0x01F469, 0x00200D, 0x01F33E, 0,
     0x01F469, 0x00200D, 0x01F373, 0,
     0x01F469, 0x00200D, 0x01F393, 0,
@@ -558,26 +543,15 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x00200D, 0x01F3A8, 0,
     0x01F469, 0x00200D, 0x01F3EB, 0,
     0x01F469, 0x00200D, 0x01F3ED, 0,
-    0x01F469, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F466, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F467, 0,
-    0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F467, 0,
-    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F466, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0,
-    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F466, 0,
-    0x01F469, 0x00200D, 0x01F469, 0x00200D, 0x01F467, 0x00200D, 0x01F467, 0,
     0x01F469, 0x00200D, 0x01F4BB, 0,
     0x01F469, 0x00200D, 0x01F4BC, 0,
     0x01F469, 0x00200D, 0x01F527, 0,
     0x01F469, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x00200D, 0x01F680, 0,
     0x01F469, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x01F3FB, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x01F3FB, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x01F3FB, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -594,10 +568,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x01F3FB, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x01F3FB, 0x00200D, 0x01F680, 0,
     0x01F469, 0x01F3FB, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x01F3FC, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x01F3FC, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x01F3FC, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -614,10 +587,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x01F3FC, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x01F3FC, 0x00200D, 0x01F680, 0,
     0x01F469, 0x01F3FC, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x01F3FD, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x01F3FD, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x01F3FD, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -634,10 +606,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x01F3FD, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x01F3FD, 0x00200D, 0x01F680, 0,
     0x01F469, 0x01F3FD, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x01F3FE, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x01F3FE, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x01F3FE, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -654,10 +625,9 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x01F3FE, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x01F3FE, 0x00200D, 0x01F680, 0,
     0x01F469, 0x01F3FE, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9BD, 0,
     0x01F469, 0x01F3FF, 0x00200D, 0x002695, 0x00FE0F, 0,
     0x01F469, 0x01F3FF, 0x00200D, 0x002696, 0x00FE0F, 0,
     0x01F469, 0x01F3FF, 0x00200D, 0x002708, 0x00FE0F, 0,
@@ -674,10 +644,81 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F469, 0x01F3FF, 0x00200D, 0x01F52C, 0,
     0x01F469, 0x01F3FF, 0x00200D, 0x01F680, 0,
     0x01F469, 0x01F3FF, 0x00200D, 0x01F692, 0,
-    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B0, 0,
-    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B1, 0,
-    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B2, 0,
-    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9AF, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9BC, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9BD, 0,
+    0x0026F9, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x0026F9, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x0026F9, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C3, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3C4, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CA, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CB, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CB, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F3CC, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F3CC, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F46E, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F46E, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F46E, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
@@ -742,7 +783,8 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F481, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F482, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F482, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F482, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F468, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F48B, 0x00200D,
+        0x01F468, 0,
     0x01F482, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F482, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F482, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
@@ -776,8 +818,6 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F487, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F487, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F487, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
-    0x01F575, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
-    0x01F575, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F575, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F575, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F575, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
@@ -788,6 +828,8 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F575, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F575, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F575, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F575, 0x00FE0F, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F575, 0x00FE0F, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F645, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F645, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F645, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
@@ -1006,6 +1048,42 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F9B9, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F9B9, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F9B9, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CD, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CE, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FB, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FC, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FC, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FD, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FD, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FE, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FE, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FF, 0x00200D, 0x002640, 0x00FE0F, 0,
+    0x01F9CF, 0x01F3FF, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F9D6, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F9D6, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F9D6, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
@@ -1106,8 +1184,61 @@ const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
     0x01F9DE, 0x00200D, 0x002642, 0x00FE0F, 0,
     0x01F9DF, 0x00200D, 0x002640, 0x00FE0F, 0,
     0x01F9DF, 0x00200D, 0x002642, 0x00FE0F, 0,
+    0x01F468, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x01F3FB, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x01F3FC, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x01F3FD, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x01F3FE, 0x00200D, 0x01F9B3, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B0, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B1, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B2, 0,
+    0x01F468, 0x01F3FF, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x01F3FB, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x01F3FC, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x01F3FD, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x01F3FE, 0x00200D, 0x01F9B3, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B0, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B1, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B2, 0,
+    0x01F469, 0x01F3FF, 0x00200D, 0x01F9B3, 0,
+    0x01F3F3, 0x00FE0F, 0x00200D, 0x01F308, 0,
+    0x01F3F4, 0x00200D, 0x002620, 0x00FE0F, 0,
+    0x01F415, 0x00200D, 0x01F9BA, 0,
+    0x01F482, 0x01F3FB, 0x00200D, 0x002640, 0x00FE0F, 0,
     0  // null-terminating the list
 };
+// clang-format on
 
 }  // namespace internal
 }  // namespace v8
diff --git a/deps/v8/src/regexp/property-sequences.h b/deps/v8/src/regexp/property-sequences.h
index 52d8a855c5..1d9fce3571 100644
--- a/deps/v8/src/regexp/property-sequences.h
+++ b/deps/v8/src/regexp/property-sequences.h
@@ -15,7 +15,6 @@ namespace internal {
 class UnicodePropertySequences : public AllStatic {
  public:
   static const uc32 kEmojiFlagSequences[];
-
   static const uc32 kEmojiTagSequences[];
   static const uc32 kEmojiZWJSequences[];
 };
diff --git a/deps/v8/src/regexp/regexp-ast.h b/deps/v8/src/regexp/regexp-ast.h
index 22c0ee199a..7c21a02590 100644
--- a/deps/v8/src/regexp/regexp-ast.h
+++ b/deps/v8/src/regexp/regexp-ast.h
@@ -80,11 +80,13 @@ class CharacterRange {
   CharacterRange() : from_(0), to_(0) {}
   // For compatibility with the CHECK_OK macro
   CharacterRange(void* null) { DCHECK_NULL(null); }  // NOLINT
-  static void AddClassEscape(char type, ZoneList<CharacterRange>* ranges,
-                             Zone* zone);
+  V8_EXPORT_PRIVATE static void AddClassEscape(char type,
+                                               ZoneList<CharacterRange>* ranges,
+                                               Zone* zone);
   // Add class escapes. Add case equivalent closure for \w and \W if necessary.
-  static void AddClassEscape(char type, ZoneList<CharacterRange>* ranges,
-                             bool add_unicode_case_equivalents, Zone* zone);
+  V8_EXPORT_PRIVATE static void AddClassEscape(
+      char type, ZoneList<CharacterRange>* ranges,
+      bool add_unicode_case_equivalents, Zone* zone);
   static Vector<const int> GetWordBounds();
   static inline CharacterRange Singleton(uc32 value) {
     return CharacterRange(value, value);
@@ -112,12 +114,12 @@ class CharacterRange {
   bool is_valid() { return from_ <= to_; }
   bool IsEverything(uc32 max) { return from_ == 0 && to_ >= max; }
   bool IsSingleton() { return (from_ == to_); }
-  static void AddCaseEquivalents(Isolate* isolate, Zone* zone,
-                                 ZoneList<CharacterRange>* ranges,
-                                 bool is_one_byte);
+  V8_EXPORT_PRIVATE static void AddCaseEquivalents(
+      Isolate* isolate, Zone* zone, ZoneList<CharacterRange>* ranges,
+      bool is_one_byte);
   // Whether a range list is in canonical form: Ranges ordered by from value,
   // and ranges non-overlapping and non-adjacent.
-  static bool IsCanonical(ZoneList<CharacterRange>* ranges);
+  V8_EXPORT_PRIVATE static bool IsCanonical(ZoneList<CharacterRange>* ranges);
   // Convert range list to canonical form. The characters covered by the ranges
   // will still be the same, but no character is in more than one range, and
   // adjacent ranges are merged. The resulting list may be shorter than the
@@ -148,7 +150,7 @@ class CharacterSet final {
     standard_set_type_ = special_set_type;
   }
   bool is_standard() { return standard_set_type_ != 0; }
-  void Canonicalize();
+  V8_EXPORT_PRIVATE void Canonicalize();
 
  private:
   ZoneList<CharacterRange>* ranges_;
@@ -208,7 +210,8 @@ class RegExpTree : public ZoneObject {
   // expression.
   virtual Interval CaptureRegisters() { return Interval::Empty(); }
   virtual void AppendToText(RegExpText* text, Zone* zone);
-  std::ostream& Print(std::ostream& os, Zone* zone);  // NOLINT
+  V8_EXPORT_PRIVATE std::ostream& Print(std::ostream& os,
+                                        Zone* zone);  // NOLINT
 #define MAKE_ASTYPE(Name)           \
   virtual RegExp##Name* As##Name(); \
   virtual bool Is##Name();
@@ -300,7 +303,7 @@ class RegExpCharacterClass final : public RegExpTree {
     NEGATED = 1 << 0,
     CONTAINS_SPLIT_SURROGATE = 1 << 1,
   };
-  typedef base::Flags<Flag> CharacterClassFlags;
+  using CharacterClassFlags = base::Flags<Flag>;
 
   RegExpCharacterClass(
       Zone* zone, ZoneList<CharacterRange>* ranges, JSRegExp::Flags flags,
diff --git a/deps/v8/src/regexp/regexp-macro-assembler-irregexp.h b/deps/v8/src/regexp/regexp-macro-assembler-irregexp.h
index 3b693f6c6e..9e17dca415 100644
--- a/deps/v8/src/regexp/regexp-macro-assembler-irregexp.h
+++ b/deps/v8/src/regexp/regexp-macro-assembler-irregexp.h
@@ -11,7 +11,8 @@ namespace v8 {
 namespace internal {
 
 // A light-weight assembler for the Irregexp byte code.
-class RegExpMacroAssemblerIrregexp: public RegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerIrregexp
+    : public RegExpMacroAssembler {
  public:
   // Create an assembler. Instructions and relocation information are emitted
   // into a buffer, with the instructions starting from the beginning and the
diff --git a/deps/v8/src/regexp/regexp-macro-assembler.cc b/deps/v8/src/regexp/regexp-macro-assembler.cc
index 323e805fcd..a75c45d24e 100644
--- a/deps/v8/src/regexp/regexp-macro-assembler.cc
+++ b/deps/v8/src/regexp/regexp-macro-assembler.cc
@@ -12,6 +12,7 @@
 
 #ifdef V8_INTL_SUPPORT
 #include "unicode/uchar.h"
+#include "unicode/unistr.h"
 #endif  // V8_INTL_SUPPORT
 
 namespace v8 {
@@ -33,37 +34,17 @@ int RegExpMacroAssembler::CaseInsensitiveCompareUC16(Address byte_offset1,
   // A GC might move the calling generated code and invalidate the
   // return address on the stack.
   DCHECK_EQ(0, byte_length % 2);
+
+#ifdef V8_INTL_SUPPORT
+  int32_t length = (int32_t)(byte_length >> 1);
+  icu::UnicodeString uni_str_1(reinterpret_cast<const char16_t*>(byte_offset1),
+                               length);
+  return uni_str_1.caseCompare(reinterpret_cast<const char16_t*>(byte_offset2),
+                               length, U_FOLD_CASE_DEFAULT) == 0;
+#else
   uc16* substring1 = reinterpret_cast<uc16*>(byte_offset1);
   uc16* substring2 = reinterpret_cast<uc16*>(byte_offset2);
   size_t length = byte_length >> 1;
-
-#ifdef V8_INTL_SUPPORT
-  if (isolate == nullptr) {
-    for (size_t i = 0; i < length; i++) {
-      uc32 c1 = substring1[i];
-      uc32 c2 = substring2[i];
-      if (unibrow::Utf16::IsLeadSurrogate(c1)) {
-        // Non-BMP characters do not have case-equivalents in the BMP.
-        // Both have to be non-BMP for them to be able to match.
-        if (!unibrow::Utf16::IsLeadSurrogate(c2)) return 0;
-        if (i + 1 < length) {
-          uc16 c1t = substring1[i + 1];
-          uc16 c2t = substring2[i + 1];
-          if (unibrow::Utf16::IsTrailSurrogate(c1t) &&
-              unibrow::Utf16::IsTrailSurrogate(c2t)) {
-            c1 = unibrow::Utf16::CombineSurrogatePair(c1, c1t);
-            c2 = unibrow::Utf16::CombineSurrogatePair(c2, c2t);
-            i++;
-          }
-        }
-      }
-      c1 = u_foldCase(c1, U_FOLD_CASE_DEFAULT);
-      c2 = u_foldCase(c2, U_FOLD_CASE_DEFAULT);
-      if (c1 != c2) return 0;
-    }
-    return 1;
-  }
-#endif  // V8_INTL_SUPPORT
   DCHECK_NOT_NULL(isolate);
   unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize =
       isolate->regexp_macro_assembler_canonicalize();
@@ -83,6 +64,7 @@ int RegExpMacroAssembler::CaseInsensitiveCompareUC16(Address byte_offset1,
     }
   }
   return 1;
+#endif  // V8_INTL_SUPPORT
 }
 
 
diff --git a/deps/v8/src/regexp/regexp-macro-assembler.h b/deps/v8/src/regexp/regexp-macro-assembler.h
index 228f4a701b..e28ac1ef22 100644
--- a/deps/v8/src/regexp/regexp-macro-assembler.h
+++ b/deps/v8/src/regexp/regexp-macro-assembler.h
@@ -244,9 +244,11 @@ class NativeRegExpMacroAssembler: public RegExpMacroAssembler {
   }
 
   // Returns a {Result} sentinel, or the number of successful matches.
-  static int Execute(Code code, String input, int start_offset,
-                     const byte* input_start, const byte* input_end,
-                     int* output, int output_size, Isolate* isolate);
+  V8_EXPORT_PRIVATE static int Execute(Code code, String input,
+                                       int start_offset,
+                                       const byte* input_start,
+                                       const byte* input_end, int* output,
+                                       int output_size, Isolate* isolate);
 };
 
 }  // namespace internal
diff --git a/deps/v8/src/regexp/regexp-parser.h b/deps/v8/src/regexp/regexp-parser.h
index 799017bb1c..d6db037de0 100644
--- a/deps/v8/src/regexp/regexp-parser.h
+++ b/deps/v8/src/regexp/regexp-parser.h
@@ -151,7 +151,7 @@ class RegExpBuilder : public ZoneObject {
 #endif
 };
 
-class RegExpParser {
+class V8_EXPORT_PRIVATE RegExpParser {
  public:
   RegExpParser(FlatStringReader* in, Handle<String>* error,
                JSRegExp::Flags flags, Isolate* isolate, Zone* zone);
diff --git a/deps/v8/src/regexp/s390/regexp-macro-assembler-s390.h b/deps/v8/src/regexp/s390/regexp-macro-assembler-s390.h
index 9bb9f31f15..a7de245a10 100644
--- a/deps/v8/src/regexp/s390/regexp-macro-assembler-s390.h
+++ b/deps/v8/src/regexp/s390/regexp-macro-assembler-s390.h
@@ -12,7 +12,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerS390 : public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerS390
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerS390(Isolate* isolate, Zone* zone, Mode mode,
                            int registers_to_save);
diff --git a/deps/v8/src/regexp/x64/regexp-macro-assembler-x64.h b/deps/v8/src/regexp/x64/regexp-macro-assembler-x64.h
index 8d747c9d2a..83193f9319 100644
--- a/deps/v8/src/regexp/x64/regexp-macro-assembler-x64.h
+++ b/deps/v8/src/regexp/x64/regexp-macro-assembler-x64.h
@@ -13,7 +13,8 @@
 namespace v8 {
 namespace internal {
 
-class RegExpMacroAssemblerX64: public NativeRegExpMacroAssembler {
+class V8_EXPORT_PRIVATE RegExpMacroAssemblerX64
+    : public NativeRegExpMacroAssembler {
  public:
   RegExpMacroAssemblerX64(Isolate* isolate, Zone* zone, Mode mode,
                           int registers_to_save);