deps: update V8 to 9.3.345.16

PR-URL: https://github.com/nodejs/node/pull/39469
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

13 files changed, 194 insertions, 167 deletions

diff --git a/deps/v8/src/strings/char-predicates-inl.h b/deps/v8/src/strings/char-predicates-inl.h
index 4c43172ff4..243681bac4 100644
--- a/deps/v8/src/strings/char-predicates-inl.h
+++ b/deps/v8/src/strings/char-predicates-inl.h
@@ -15,61 +15,61 @@ namespace internal {
 // If c is in 'A'-'Z' or 'a'-'z', return its lower-case.
 // Else, return something outside of 'A'-'Z' and 'a'-'z'.
 // Note: it ignores LOCALE.
-inline constexpr int AsciiAlphaToLower(uc32 c) { return c | 0x20; }
+inline constexpr int AsciiAlphaToLower(base::uc32 c) { return c | 0x20; }
 
-inline constexpr bool IsCarriageReturn(uc32 c) { return c == 0x000D; }
+inline constexpr bool IsCarriageReturn(base::uc32 c) { return c == 0x000D; }
 
-inline constexpr bool IsLineFeed(uc32 c) { return c == 0x000A; }
+inline constexpr bool IsLineFeed(base::uc32 c) { return c == 0x000A; }
 
-inline constexpr bool IsAsciiIdentifier(uc32 c) {
+inline constexpr bool IsAsciiIdentifier(base::uc32 c) {
   return IsAlphaNumeric(c) || c == '$' || c == '_';
 }
 
-inline constexpr bool IsAlphaNumeric(uc32 c) {
+inline constexpr bool IsAlphaNumeric(base::uc32 c) {
   return base::IsInRange(AsciiAlphaToLower(c), 'a', 'z') || IsDecimalDigit(c);
 }
 
-inline constexpr bool IsDecimalDigit(uc32 c) {
+inline constexpr bool IsDecimalDigit(base::uc32 c) {
   // ECMA-262, 3rd, 7.8.3 (p 16)
   return base::IsInRange(c, '0', '9');
 }
 
-inline constexpr bool IsHexDigit(uc32 c) {
+inline constexpr bool IsHexDigit(base::uc32 c) {
   // ECMA-262, 3rd, 7.6 (p 15)
   return IsDecimalDigit(c) || base::IsInRange(AsciiAlphaToLower(c), 'a', 'f');
 }
 
-inline constexpr bool IsOctalDigit(uc32 c) {
+inline constexpr bool IsOctalDigit(base::uc32 c) {
   // ECMA-262, 6th, 7.8.3
   return base::IsInRange(c, '0', '7');
 }
 
-inline constexpr bool IsNonOctalDecimalDigit(uc32 c) {
+inline constexpr bool IsNonOctalDecimalDigit(base::uc32 c) {
   return base::IsInRange(c, '8', '9');
 }
 
-inline constexpr bool IsBinaryDigit(uc32 c) {
+inline constexpr bool IsBinaryDigit(base::uc32 c) {
   // ECMA-262, 6th, 7.8.3
   return c == '0' || c == '1';
 }
 
-inline constexpr bool IsAsciiLower(uc32 c) {
+inline constexpr bool IsAsciiLower(base::uc32 c) {
   return base::IsInRange(c, 'a', 'z');
 }
 
-inline constexpr bool IsAsciiUpper(uc32 c) {
+inline constexpr bool IsAsciiUpper(base::uc32 c) {
   return base::IsInRange(c, 'A', 'Z');
 }
 
-inline constexpr uc32 ToAsciiUpper(uc32 c) {
+inline constexpr base::uc32 ToAsciiUpper(base::uc32 c) {
   return c & ~(IsAsciiLower(c) << 5);
 }
 
-inline constexpr uc32 ToAsciiLower(uc32 c) {
+inline constexpr base::uc32 ToAsciiLower(base::uc32 c) {
   return c | (IsAsciiUpper(c) << 5);
 }
 
-inline constexpr bool IsRegExpWord(uc32 c) {
+inline constexpr bool IsRegExpWord(base::uc32 c) {
   return IsAlphaNumeric(c) || c == '_';
 }
 
@@ -84,7 +84,7 @@ enum OneByteCharFlags {
 
 // See http://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
 // ID_Start. Additionally includes '_' and '$'.
-constexpr bool IsOneByteIDStart(uc32 c) {
+constexpr bool IsOneByteIDStart(base::uc32 c) {
   return c == 0x0024 || (c >= 0x0041 && c <= 0x005A) || c == 0x005F ||
          (c >= 0x0061 && c <= 0x007A) || c == 0x00AA || c == 0x00B5 ||
          c == 0x00BA || (c >= 0x00C0 && c <= 0x00D6) ||
@@ -93,7 +93,7 @@ constexpr bool IsOneByteIDStart(uc32 c) {
 
 // See http://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
 // ID_Continue. Additionally includes '_' and '$'.
-constexpr bool IsOneByteIDContinue(uc32 c) {
+constexpr bool IsOneByteIDContinue(base::uc32 c) {
   return c == 0x0024 || (c >= 0x0030 && c <= 0x0039) || c == 0x005F ||
          (c >= 0x0041 && c <= 0x005A) || (c >= 0x0061 && c <= 0x007A) ||
          c == 0x00AA || c == 0x00B5 || c == 0x00B7 || c == 0x00BA ||
@@ -101,11 +101,11 @@ constexpr bool IsOneByteIDContinue(uc32 c) {
          (c >= 0x00F8 && c <= 0x00FF);
 }
 
-constexpr bool IsOneByteWhitespace(uc32 c) {
+constexpr bool IsOneByteWhitespace(base::uc32 c) {
   return c == '\t' || c == '\v' || c == '\f' || c == ' ' || c == u'\xa0';
 }
 
-constexpr uint8_t BuildOneByteCharFlags(uc32 c) {
+constexpr uint8_t BuildOneByteCharFlags(base::uc32 c) {
   uint8_t result = 0;
   if (IsOneByteIDStart(c) || c == '\\') result |= kIsIdentifierStart;
   if (IsOneByteIDContinue(c) || c == '\\') result |= kIsIdentifierPart;
@@ -130,28 +130,28 @@ const constexpr uint8_t kOneByteCharFlags[256] = {
 #undef BUILD_CHAR_FLAGS
 };
 
-bool IsIdentifierStart(uc32 c) {
+bool IsIdentifierStart(base::uc32 c) {
   if (!base::IsInRange(c, 0, 255)) return IsIdentifierStartSlow(c);
   DCHECK_EQ(IsIdentifierStartSlow(c),
             static_cast<bool>(kOneByteCharFlags[c] & kIsIdentifierStart));
   return kOneByteCharFlags[c] & kIsIdentifierStart;
 }
 
-bool IsIdentifierPart(uc32 c) {
+bool IsIdentifierPart(base::uc32 c) {
   if (!base::IsInRange(c, 0, 255)) return IsIdentifierPartSlow(c);
   DCHECK_EQ(IsIdentifierPartSlow(c),
             static_cast<bool>(kOneByteCharFlags[c] & kIsIdentifierPart));
   return kOneByteCharFlags[c] & kIsIdentifierPart;
 }
 
-bool IsWhiteSpace(uc32 c) {
+bool IsWhiteSpace(base::uc32 c) {
   if (!base::IsInRange(c, 0, 255)) return IsWhiteSpaceSlow(c);
   DCHECK_EQ(IsWhiteSpaceSlow(c),
             static_cast<bool>(kOneByteCharFlags[c] & kIsWhiteSpace));
   return kOneByteCharFlags[c] & kIsWhiteSpace;
 }
 
-bool IsWhiteSpaceOrLineTerminator(uc32 c) {
+bool IsWhiteSpaceOrLineTerminator(base::uc32 c) {
   if (!base::IsInRange(c, 0, 255)) return IsWhiteSpaceOrLineTerminatorSlow(c);
   DCHECK_EQ(
       IsWhiteSpaceOrLineTerminatorSlow(c),
@@ -159,7 +159,7 @@ bool IsWhiteSpaceOrLineTerminator(uc32 c) {
   return kOneByteCharFlags[c] & kIsWhiteSpaceOrLineTerminator;
 }
 
-bool IsLineTerminatorSequence(uc32 c, uc32 next) {
+bool IsLineTerminatorSequence(base::uc32 c, base::uc32 next) {
   if (kOneByteCharFlags[static_cast<uint8_t>(c)] & kMaybeLineEnd) {
     if (c == '\n') return true;
     if (c == '\r') return next != '\n';
diff --git a/deps/v8/src/strings/char-predicates.cc b/deps/v8/src/strings/char-predicates.cc
index 0133a03517..4d0676481c 100644
--- a/deps/v8/src/strings/char-predicates.cc
+++ b/deps/v8/src/strings/char-predicates.cc
@@ -16,7 +16,7 @@ namespace internal {
 
 // ES#sec-names-and-keywords Names and Keywords
 // UnicodeIDStart, '$', '_' and '\'
-bool IsIdentifierStartSlow(uc32 c) {
+bool IsIdentifierStartSlow(base::uc32 c) {
   // cannot use u_isIDStart because it does not work for
   // Other_ID_Start characters.
   return u_hasBinaryProperty(c, UCHAR_ID_START) ||
@@ -25,7 +25,7 @@ bool IsIdentifierStartSlow(uc32 c) {
 
 // ES#sec-names-and-keywords Names and Keywords
 // UnicodeIDContinue, '$', '_', '\', ZWJ, and ZWNJ
-bool IsIdentifierPartSlow(uc32 c) {
+bool IsIdentifierPartSlow(base::uc32 c) {
   // Can't use u_isIDPart because it does not work for
   // Other_ID_Continue characters.
   return u_hasBinaryProperty(c, UCHAR_ID_CONTINUE) ||
@@ -35,7 +35,7 @@ bool IsIdentifierPartSlow(uc32 c) {
 
 // ES#sec-white-space White Space
 // gC=Zs, U+0009, U+000B, U+000C, U+FEFF
-bool IsWhiteSpaceSlow(uc32 c) {
+bool IsWhiteSpaceSlow(base::uc32 c) {
   return (u_charType(c) == U_SPACE_SEPARATOR) ||
          (c < 0x0D && (c == 0x09 || c == 0x0B || c == 0x0C)) || c == 0xFEFF;
 }
diff --git a/deps/v8/src/strings/char-predicates.h b/deps/v8/src/strings/char-predicates.h
index 1df20e072a..b23c5ef2a2 100644
--- a/deps/v8/src/strings/char-predicates.h
+++ b/deps/v8/src/strings/char-predicates.h
@@ -5,6 +5,7 @@
 #ifndef V8_STRINGS_CHAR_PREDICATES_H_
 #define V8_STRINGS_CHAR_PREDICATES_H_
 
+#include "src/base/strings.h"
 #include "src/common/globals.h"
 #include "src/strings/unicode.h"
 
@@ -14,33 +15,33 @@ namespace internal {
 // Unicode character predicates as defined by ECMA-262, 3rd,
 // used for lexical analysis.
 
-inline constexpr int AsciiAlphaToLower(uc32 c);
-inline constexpr bool IsCarriageReturn(uc32 c);
-inline constexpr bool IsLineFeed(uc32 c);
-inline constexpr bool IsAsciiIdentifier(uc32 c);
-inline constexpr bool IsAlphaNumeric(uc32 c);
-inline constexpr bool IsDecimalDigit(uc32 c);
-inline constexpr bool IsHexDigit(uc32 c);
-inline constexpr bool IsOctalDigit(uc32 c);
-inline constexpr bool IsBinaryDigit(uc32 c);
-inline constexpr bool IsRegExpWord(uc32 c);
+inline constexpr int AsciiAlphaToLower(base::uc32 c);
+inline constexpr bool IsCarriageReturn(base::uc32 c);
+inline constexpr bool IsLineFeed(base::uc32 c);
+inline constexpr bool IsAsciiIdentifier(base::uc32 c);
+inline constexpr bool IsAlphaNumeric(base::uc32 c);
+inline constexpr bool IsDecimalDigit(base::uc32 c);
+inline constexpr bool IsHexDigit(base::uc32 c);
+inline constexpr bool IsOctalDigit(base::uc32 c);
+inline constexpr bool IsBinaryDigit(base::uc32 c);
+inline constexpr bool IsRegExpWord(base::uc32 c);
 
-inline constexpr bool IsAsciiLower(uc32 ch);
-inline constexpr bool IsAsciiUpper(uc32 ch);
+inline constexpr bool IsAsciiLower(base::uc32 ch);
+inline constexpr bool IsAsciiUpper(base::uc32 ch);
 
-inline constexpr uc32 ToAsciiUpper(uc32 ch);
-inline constexpr uc32 ToAsciiLower(uc32 ch);
+inline constexpr base::uc32 ToAsciiUpper(base::uc32 ch);
+inline constexpr base::uc32 ToAsciiLower(base::uc32 ch);
 
 // ES#sec-names-and-keywords
 // This includes '_', '$' and '\', and ID_Start according to
 // http://www.unicode.org/reports/tr31/, which consists of categories
 // 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl', but excluding properties
 // 'Pattern_Syntax' or 'Pattern_White_Space'.
-inline bool IsIdentifierStart(uc32 c);
+inline bool IsIdentifierStart(base::uc32 c);
 #ifdef V8_INTL_SUPPORT
-V8_EXPORT_PRIVATE bool IsIdentifierStartSlow(uc32 c);
+V8_EXPORT_PRIVATE bool IsIdentifierStartSlow(base::uc32 c);
 #else
-inline bool IsIdentifierStartSlow(uc32 c) {
+inline bool IsIdentifierStartSlow(base::uc32 c) {
   // Non-BMP characters are not supported without I18N.
   return (c <= 0xFFFF) ? unibrow::ID_Start::Is(c) : false;
 }
@@ -51,11 +52,11 @@ inline bool IsIdentifierStartSlow(uc32 c) {
 // http://www.unicode.org/reports/tr31/, which consists of ID_Start,
 // the categories 'Mn', 'Mc', 'Nd', 'Pc', but excluding properties
 // 'Pattern_Syntax' or 'Pattern_White_Space'.
-inline bool IsIdentifierPart(uc32 c);
+inline bool IsIdentifierPart(base::uc32 c);
 #ifdef V8_INTL_SUPPORT
-V8_EXPORT_PRIVATE bool IsIdentifierPartSlow(uc32 c);
+V8_EXPORT_PRIVATE bool IsIdentifierPartSlow(base::uc32 c);
 #else
-inline bool IsIdentifierPartSlow(uc32 c) {
+inline bool IsIdentifierPartSlow(base::uc32 c) {
   // Non-BMP charaacters are not supported without I18N.
   if (c <= 0xFFFF) {
     return unibrow::ID_Start::Is(c) || unibrow::ID_Continue::Is(c);
@@ -67,22 +68,24 @@ inline bool IsIdentifierPartSlow(uc32 c) {
 // ES6 draft section 11.2
 // This includes all code points of Unicode category 'Zs'.
 // Further included are \u0009, \u000b, \u000c, and \ufeff.
-inline bool IsWhiteSpace(uc32 c);
+inline bool IsWhiteSpace(base::uc32 c);
 #ifdef V8_INTL_SUPPORT
-V8_EXPORT_PRIVATE bool IsWhiteSpaceSlow(uc32 c);
+V8_EXPORT_PRIVATE bool IsWhiteSpaceSlow(base::uc32 c);
 #else
-inline bool IsWhiteSpaceSlow(uc32 c) { return unibrow::WhiteSpace::Is(c); }
+inline bool IsWhiteSpaceSlow(base::uc32 c) {
+  return unibrow::WhiteSpace::Is(c);
+}
 #endif
 
 // WhiteSpace and LineTerminator according to ES6 draft section 11.2 and 11.3
 // This includes all the characters with Unicode category 'Z' (= Zs+Zl+Zp)
 // as well as \u0009 - \u000d and \ufeff.
-inline bool IsWhiteSpaceOrLineTerminator(uc32 c);
-inline bool IsWhiteSpaceOrLineTerminatorSlow(uc32 c) {
+inline bool IsWhiteSpaceOrLineTerminator(base::uc32 c);
+inline bool IsWhiteSpaceOrLineTerminatorSlow(base::uc32 c) {
   return IsWhiteSpaceSlow(c) || unibrow::IsLineTerminator(c);
 }
 
-inline bool IsLineTerminatorSequence(uc32 c, uc32 next);
+inline bool IsLineTerminatorSequence(base::uc32 c, base::uc32 next);
 
 }  // namespace internal
 }  // namespace v8
diff --git a/deps/v8/src/strings/string-builder-inl.h b/deps/v8/src/strings/string-builder-inl.h
index 80b88963c0..e2b8b0b441 100644
--- a/deps/v8/src/strings/string-builder-inl.h
+++ b/deps/v8/src/strings/string-builder-inl.h
@@ -126,7 +126,7 @@ class IncrementalStringBuilder {
     if (encoding_ == String::ONE_BYTE_ENCODING) {
       Append<uint8_t, uint8_t>(c);
     } else {
-      Append<uint8_t, uc16>(c);
+      Append<uint8_t, base::uc16>(c);
     }
   }
 
@@ -135,22 +135,22 @@ class IncrementalStringBuilder {
     if (encoding_ == String::ONE_BYTE_ENCODING) {
       while (*u != '\0') Append<uint8_t, uint8_t>(*(u++));
     } else {
-      while (*u != '\0') Append<uint8_t, uc16>(*(u++));
+      while (*u != '\0') Append<uint8_t, base::uc16>(*(u++));
     }
   }
 
-  V8_INLINE void AppendCString(const uc16* s) {
+  V8_INLINE void AppendCString(const base::uc16* s) {
     if (encoding_ == String::ONE_BYTE_ENCODING) {
-      while (*s != '\0') Append<uc16, uint8_t>(*(s++));
+      while (*s != '\0') Append<base::uc16, uint8_t>(*(s++));
     } else {
-      while (*s != '\0') Append<uc16, uc16>(*(s++));
+      while (*s != '\0') Append<base::uc16, base::uc16>(*(s++));
     }
   }
 
   V8_INLINE void AppendInt(int i) {
     char buffer[kIntToCStringBufferSize];
     const char* str =
-        IntToCString(i, Vector<char>(buffer, kIntToCStringBufferSize));
+        IntToCString(i, base::Vector<char>(buffer, kIntToCStringBufferSize));
     AppendCString(str);
   }
 
diff --git a/deps/v8/src/strings/string-builder.cc b/deps/v8/src/strings/string-builder.cc
index 5faf8aff4d..71534d635f 100644
--- a/deps/v8/src/strings/string-builder.cc
+++ b/deps/v8/src/strings/string-builder.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/strings/string-builder-inl.h"
-
+#include "src/base/strings.h"
 #include "src/execution/isolate-inl.h"
 #include "src/objects/fixed-array-inl.h"
 #include "src/objects/js-array-inl.h"
+#include "src/strings/string-builder-inl.h"
 
 namespace v8 {
 namespace internal {
@@ -49,9 +49,10 @@ template void StringBuilderConcatHelper<uint8_t>(String special, uint8_t* sink,
                                                  FixedArray fixed_array,
                                                  int array_length);
 
-template void StringBuilderConcatHelper<uc16>(String special, uc16* sink,
-                                              FixedArray fixed_array,
-                                              int array_length);
+template void StringBuilderConcatHelper<base::uc16>(String special,
+                                                    base::uc16* sink,
+                                                    FixedArray fixed_array,
+                                                    int array_length);
 
 int StringBuilderConcatLength(int special_length, FixedArray fixed_array,
                               int array_length, bool* one_byte) {
@@ -213,7 +214,7 @@ MaybeHandle<String> ReplacementStringBuilder::ToString() {
         String);
 
     DisallowGarbageCollection no_gc;
-    uc16* char_buffer = seq->GetChars(no_gc);
+    base::uc16* char_buffer = seq->GetChars(no_gc);
     StringBuilderConcatHelper(*subject_, char_buffer, *array_builder_.array(),
                               array_builder_.length());
     joined_string = Handle<String>::cast(seq);
diff --git a/deps/v8/src/strings/string-hasher-inl.h b/deps/v8/src/strings/string-hasher-inl.h
index cac574637b..0d943b783d 100644
--- a/deps/v8/src/strings/string-hasher-inl.h
+++ b/deps/v8/src/strings/string-hasher-inl.h
@@ -7,10 +7,12 @@
 
 #include "src/strings/string-hasher.h"
 
+// Comment inserted to prevent header reordering.
 #include <type_traits>
 
+#include "src/objects/name-inl.h"
 #include "src/objects/objects.h"
-#include "src/objects/string-inl.h"
+#include "src/objects/string.h"
 #include "src/strings/char-predicates-inl.h"
 #include "src/utils/utils-inl.h"
 
diff --git a/deps/v8/src/strings/string-hasher.h b/deps/v8/src/strings/string-hasher.h
index 839fbc46a2..c26fe79426 100644
--- a/deps/v8/src/strings/string-hasher.h
+++ b/deps/v8/src/strings/string-hasher.h
@@ -8,10 +8,13 @@
 #include "src/common/globals.h"
 
 namespace v8 {
-namespace internal {
 
+namespace base {
 template <typename T>
 class Vector;
+}  // namespace base
+
+namespace internal {
 
 // Helper class for incrementally calculating string hashes in a form suitable
 // for storing into Name::raw_hash_field.
diff --git a/deps/v8/src/strings/string-search.h b/deps/v8/src/strings/string-search.h
index 410e078daa..529501dd31 100644
--- a/deps/v8/src/strings/string-search.h
+++ b/deps/v8/src/strings/string-search.h
@@ -5,8 +5,9 @@
 #ifndef V8_STRINGS_STRING_SEARCH_H_
 #define V8_STRINGS_STRING_SEARCH_H_
 
+#include "src/base/strings.h"
+#include "src/base/vector.h"
 #include "src/execution/isolate.h"
-#include "src/utils/vector.h"
 
 namespace v8 {
 namespace internal {
@@ -40,11 +41,11 @@ class StringSearchBase {
   // to compensate for the algorithmic overhead compared to simple brute force.
   static const int kBMMinPatternLength = 7;
 
-  static inline bool IsOneByteString(Vector<const uint8_t> string) {
+  static inline bool IsOneByteString(base::Vector<const uint8_t> string) {
     return true;
   }
 
-  static inline bool IsOneByteString(Vector<const uc16> string) {
+  static inline bool IsOneByteString(base::Vector<const base::uc16> string) {
     return String::IsOneByte(string.begin(), string.length());
   }
 
@@ -54,7 +55,7 @@ class StringSearchBase {
 template <typename PatternChar, typename SubjectChar>
 class StringSearch : private StringSearchBase {
  public:
-  StringSearch(Isolate* isolate, Vector<const PatternChar> pattern)
+  StringSearch(Isolate* isolate, base::Vector<const PatternChar> pattern)
       : isolate_(isolate),
         pattern_(pattern),
         start_(std::max(0, pattern.length() - kBMMaxShift)) {
@@ -76,7 +77,7 @@ class StringSearch : private StringSearchBase {
     strategy_ = &InitialSearch;
   }
 
-  int Search(Vector<const SubjectChar> subject, int index) {
+  int Search(base::Vector<const SubjectChar> subject, int index) {
     return strategy_(this, subject, index);
   }
 
@@ -93,29 +94,31 @@ class StringSearch : private StringSearchBase {
 
  private:
   using SearchFunction = int (*)(StringSearch<PatternChar, SubjectChar>*,
-                                 Vector<const SubjectChar>, int);
+                                 base::Vector<const SubjectChar>, int);
 
   static int FailSearch(StringSearch<PatternChar, SubjectChar>*,
-                        Vector<const SubjectChar>, int) {
+                        base::Vector<const SubjectChar>, int) {
     return -1;
   }
 
   static int SingleCharSearch(StringSearch<PatternChar, SubjectChar>* search,
-                              Vector<const SubjectChar> subject,
+                              base::Vector<const SubjectChar> subject,
                               int start_index);
 
   static int LinearSearch(StringSearch<PatternChar, SubjectChar>* search,
-                          Vector<const SubjectChar> subject, int start_index);
+                          base::Vector<const SubjectChar> subject,
+                          int start_index);
 
   static int InitialSearch(StringSearch<PatternChar, SubjectChar>* search,
-                           Vector<const SubjectChar> subject, int start_index);
+                           base::Vector<const SubjectChar> subject,
+                           int start_index);
 
   static int BoyerMooreHorspoolSearch(
       StringSearch<PatternChar, SubjectChar>* search,
-      Vector<const SubjectChar> subject, int start_index);
+      base::Vector<const SubjectChar> subject, int start_index);
 
   static int BoyerMooreSearch(StringSearch<PatternChar, SubjectChar>* search,
-                              Vector<const SubjectChar> subject,
+                              base::Vector<const SubjectChar> subject,
                               int start_index);
 
   void PopulateBoyerMooreHorspoolTable();
@@ -139,7 +142,8 @@ class StringSearch : private StringSearchBase {
       }
       return bad_char_occurrence[static_cast<unsigned int>(char_code)];
     }
-    // Both pattern and subject are UC16. Reduce character to equivalence class.
+    // Both pattern and subject are UC16. Reduce character to equivalence
+    // class.
     int equiv_class = char_code % kUC16AlphabetSize;
     return bad_char_occurrence[equiv_class];
   }
@@ -170,7 +174,7 @@ class StringSearch : private StringSearchBase {
 
   Isolate* isolate_;
   // The pattern to search for.
-  Vector<const PatternChar> pattern_;
+  base::Vector<const PatternChar> pattern_;
   // Pointer to implementation of the search.
   SearchFunction strategy_;
   // Cache value of max(0, pattern_length() - kBMMaxShift)
@@ -183,7 +187,7 @@ inline T AlignDown(T value, U alignment) {
       (reinterpret_cast<uintptr_t>(value) & ~(alignment - 1)));
 }
 
-inline uint8_t GetHighestValueByte(uc16 character) {
+inline uint8_t GetHighestValueByte(base::uc16 character) {
   return std::max(static_cast<uint8_t>(character & 0xFF),
                   static_cast<uint8_t>(character >> 8));
 }
@@ -191,8 +195,9 @@ inline uint8_t GetHighestValueByte(uc16 character) {
 inline uint8_t GetHighestValueByte(uint8_t character) { return character; }
 
 template <typename PatternChar, typename SubjectChar>
-inline int FindFirstCharacter(Vector<const PatternChar> pattern,
-                              Vector<const SubjectChar> subject, int index) {
+inline int FindFirstCharacter(base::Vector<const PatternChar> pattern,
+                              base::Vector<const SubjectChar> subject,
+                              int index) {
   const PatternChar pattern_first_char = pattern[0];
   const int max_n = (subject.length() - pattern.length() + 1);
 
@@ -229,7 +234,7 @@ inline int FindFirstCharacter(Vector<const PatternChar> pattern,
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::SingleCharSearch(
     StringSearch<PatternChar, SubjectChar>* search,
-    Vector<const SubjectChar> subject, int index) {
+    base::Vector<const SubjectChar> subject, int index) {
   DCHECK_EQ(1, search->pattern_.length());
   PatternChar pattern_first_char = search->pattern_[0];
   if (sizeof(PatternChar) > sizeof(SubjectChar)) {
@@ -262,8 +267,8 @@ inline bool CharCompare(const PatternChar* pattern, const SubjectChar* subject,
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::LinearSearch(
     StringSearch<PatternChar, SubjectChar>* search,
-    Vector<const SubjectChar> subject, int index) {
-  Vector<const PatternChar> pattern = search->pattern_;
+    base::Vector<const SubjectChar> subject, int index) {
+  base::Vector<const PatternChar> pattern = search->pattern_;
   DCHECK_GT(pattern.length(), 1);
   int pattern_length = pattern.length();
   int i = index;
@@ -290,8 +295,8 @@ int StringSearch<PatternChar, SubjectChar>::LinearSearch(
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::BoyerMooreSearch(
     StringSearch<PatternChar, SubjectChar>* search,
-    Vector<const SubjectChar> subject, int start_index) {
-  Vector<const PatternChar> pattern = search->pattern_;
+    base::Vector<const SubjectChar> subject, int start_index) {
+  base::Vector<const PatternChar> pattern = search->pattern_;
   int subject_length = subject.length();
   int pattern_length = pattern.length();
   // Only preprocess at most kBMMaxShift last characters of pattern.
@@ -409,8 +414,8 @@ void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreTable() {
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::BoyerMooreHorspoolSearch(
     StringSearch<PatternChar, SubjectChar>* search,
-    Vector<const SubjectChar> subject, int start_index) {
-  Vector<const PatternChar> pattern = search->pattern_;
+    base::Vector<const SubjectChar> subject, int start_index) {
+  base::Vector<const PatternChar> pattern = search->pattern_;
   int subject_length = subject.length();
   int pattern_length = pattern.length();
   int* char_occurrences = search->bad_char_table();
@@ -491,8 +496,8 @@ void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreHorspoolTable() {
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::InitialSearch(
     StringSearch<PatternChar, SubjectChar>* search,
-    Vector<const SubjectChar> subject, int index) {
-  Vector<const PatternChar> pattern = search->pattern_;
+    base::Vector<const SubjectChar> subject, int index) {
+  base::Vector<const PatternChar> pattern = search->pattern_;
   int pattern_length = pattern.length();
   // Badness is a count of how much work we have done.  When we have
   // done enough work we decide it's probably worth switching to a better
@@ -532,8 +537,8 @@ int StringSearch<PatternChar, SubjectChar>::InitialSearch(
 // object should be constructed once and the Search function then called
 // for each search.
 template <typename SubjectChar, typename PatternChar>
-int SearchString(Isolate* isolate, Vector<const SubjectChar> subject,
-                 Vector<const PatternChar> pattern, int start_index) {
+int SearchString(Isolate* isolate, base::Vector<const SubjectChar> subject,
+                 base::Vector<const PatternChar> pattern, int start_index) {
   StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
   return search.Search(subject, start_index);
 }
@@ -546,8 +551,8 @@ intptr_t SearchStringRaw(Isolate* isolate, const SubjectChar* subject_ptr,
                          int subject_length, const PatternChar* pattern_ptr,
                          int pattern_length, int start_index) {
   DisallowGarbageCollection no_gc;
-  Vector<const SubjectChar> subject(subject_ptr, subject_length);
-  Vector<const PatternChar> pattern(pattern_ptr, pattern_length);
+  base::Vector<const SubjectChar> subject(subject_ptr, subject_length);
+  base::Vector<const PatternChar> pattern(pattern_ptr, pattern_length);
   return SearchString(isolate, subject, pattern, start_index);
 }
 
diff --git a/deps/v8/src/strings/string-stream.cc b/deps/v8/src/strings/string-stream.cc
index ed1939ae0f..67e361963d 100644
--- a/deps/v8/src/strings/string-stream.cc
+++ b/deps/v8/src/strings/string-stream.cc
@@ -6,12 +6,12 @@
 
 #include <memory>
 
+#include "src/base/vector.h"
 #include "src/handles/handles-inl.h"
 #include "src/logging/log.h"
 #include "src/objects/js-array-inl.h"
 #include "src/objects/objects-inl.h"
 #include "src/objects/prototype.h"
-#include "src/utils/vector.h"
 
 namespace v8 {
 namespace internal {
@@ -85,7 +85,8 @@ static bool IsControlChar(char c) {
   }
 }
 
-void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
+void StringStream::Add(base::Vector<const char> format,
+                       base::Vector<FmtElm> elms) {
   // If we already ran out of space then return immediately.
   if (full()) return;
   int offset = 0;
@@ -97,7 +98,7 @@ void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
       continue;
     }
     // Read this formatting directive into a temporary buffer
-    EmbeddedVector<char, 24> temp;
+    base::EmbeddedVector<char, 24> temp;
     int format_length = 0;
     // Skip over the whole control character sequence until the
     // format element type
@@ -119,7 +120,7 @@ void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
       }
       case 'w': {
         DCHECK_EQ(FmtElm::LC_STR, current.type_);
-        Vector<const uc16> value = *current.data_.u_lc_str_;
+        base::Vector<const base::uc16> value = *current.data_.u_lc_str_;
         for (int i = 0; i < value.length(); i++)
           Put(static_cast<char>(value[i]));
         break;
@@ -149,9 +150,9 @@ void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
       case 'c':
       case 'X': {
         int value = current.data_.u_int_;
-        EmbeddedVector<char, 24> formatted;
+        base::EmbeddedVector<char, 24> formatted;
         int length = SNPrintF(formatted, temp.begin(), value);
-        Add(Vector<const char>(formatted.begin(), length));
+        Add(base::Vector<const char>(formatted.begin(), length));
         break;
       }
       case 'f':
@@ -168,7 +169,7 @@ void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
         } else if (std::isnan(value)) {
           Add("nan");
         } else {
-          EmbeddedVector<char, 28> formatted;
+          base::EmbeddedVector<char, 28> formatted;
           SNPrintF(formatted, temp.begin(), value);
           Add(formatted.begin());
         }
@@ -176,7 +177,7 @@ void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
       }
       case 'p': {
         void* value = current.data_.u_pointer_;
-        EmbeddedVector<char, 20> formatted;
+        base::EmbeddedVector<char, 20> formatted;
         SNPrintF(formatted, temp.begin(), value);
         Add(formatted.begin());
         break;
@@ -248,7 +249,7 @@ void StringStream::OutputToFile(FILE* out) {
 
 Handle<String> StringStream::ToString(Isolate* isolate) {
   return isolate->factory()
-      ->NewStringFromUtf8(Vector<const char>(buffer_, length_))
+      ->NewStringFromUtf8(base::Vector<const char>(buffer_, length_))
       .ToHandleChecked();
 }
 
diff --git a/deps/v8/src/strings/string-stream.h b/deps/v8/src/strings/string-stream.h
index d0624abb6e..65fab8be1c 100644
--- a/deps/v8/src/strings/string-stream.h
+++ b/deps/v8/src/strings/string-stream.h
@@ -8,10 +8,11 @@
 #include <memory>
 
 #include "src/base/small-vector.h"
+#include "src/base/strings.h"
+#include "src/base/vector.h"
 #include "src/handles/handles.h"
 #include "src/objects/heap-object.h"
 #include "src/utils/allocation.h"
-#include "src/utils/vector.h"
 
 namespace v8 {
 namespace internal {
@@ -98,7 +99,8 @@ class StringStream final {
     FmtElm(const char* value) : FmtElm(C_STR) {  // NOLINT
       data_.u_c_str_ = value;
     }
-    FmtElm(const Vector<const uc16>& value) : FmtElm(LC_STR) {  // NOLINT
+    FmtElm(const base::Vector<const base::uc16>& value)  // NOLINT
+        : FmtElm(LC_STR) {
       data_.u_lc_str_ = &value;
     }
     FmtElm(Object value) : FmtElm(OBJ) {  // NOLINT
@@ -126,7 +128,7 @@ class StringStream final {
       int u_int_;
       double u_double_;
       const char* u_c_str_;
-      const Vector<const uc16>* u_lc_str_;
+      const base::Vector<const base::uc16>* u_lc_str_;
       Address u_obj_;
       Address* u_handle_;
       void* u_pointer_;
@@ -148,18 +150,20 @@ class StringStream final {
   bool Put(char c);
   bool Put(String str);
   bool Put(String str, int start, int end);
-  void Add(const char* format) { Add(CStrVector(format)); }
-  void Add(Vector<const char> format) { Add(format, Vector<FmtElm>()); }
+  void Add(const char* format) { Add(base::CStrVector(format)); }
+  void Add(base::Vector<const char> format) {
+    Add(format, base::Vector<FmtElm>());
+  }
 
   template <typename... Args>
   void Add(const char* format, Args... args) {
-    Add(CStrVector(format), args...);
+    Add(base::CStrVector(format), args...);
   }
 
   template <typename... Args>
-  void Add(Vector<const char> format, Args... args) {
+  void Add(base::Vector<const char> format, Args... args) {
     FmtElm elems[]{args...};
-    Add(format, ArrayVector(elems));
+    Add(format, base::ArrayVector(elems));
   }
 
   // Getting the message out.
@@ -196,7 +200,7 @@ class StringStream final {
   static const int kInitialCapacity = 16;
 
  private:
-  void Add(Vector<const char> format, Vector<FmtElm> elms);
+  void Add(base::Vector<const char> format, base::Vector<FmtElm> elms);
   void PrintObject(Object obj);
 
   StringAllocator* allocator_;
diff --git a/deps/v8/src/strings/unicode-decoder.cc b/deps/v8/src/strings/unicode-decoder.cc
index b8d3c3e8ba..b4cc7b9b55 100644
--- a/deps/v8/src/strings/unicode-decoder.cc
+++ b/deps/v8/src/strings/unicode-decoder.cc
@@ -10,7 +10,7 @@
 namespace v8 {
 namespace internal {
 
-Utf8Decoder::Utf8Decoder(const Vector<const uint8_t>& chars)
+Utf8Decoder::Utf8Decoder(const base::Vector<const uint8_t>& chars)
     : encoding_(Encoding::kAscii),
       non_ascii_start_(NonAsciiStart(chars.begin(), chars.length())),
       utf16_length_(non_ascii_start_) {
@@ -43,7 +43,7 @@ Utf8Decoder::Utf8Decoder(const Vector<const uint8_t>& chars)
 }
 
 template <typename Char>
-void Utf8Decoder::Decode(Char* out, const Vector<const uint8_t>& data) {
+void Utf8Decoder::Decode(Char* out, const base::Vector<const uint8_t>& data) {
   CopyChars(out, data.begin(), non_ascii_start_);
 
   out += non_ascii_start_;
@@ -72,10 +72,10 @@ void Utf8Decoder::Decode(Char* out, const Vector<const uint8_t>& data) {
 }
 
 template V8_EXPORT_PRIVATE void Utf8Decoder::Decode(
-    uint8_t* out, const Vector<const uint8_t>& data);
+    uint8_t* out, const base::Vector<const uint8_t>& data);
 
 template V8_EXPORT_PRIVATE void Utf8Decoder::Decode(
-    uint16_t* out, const Vector<const uint8_t>& data);
+    uint16_t* out, const base::Vector<const uint8_t>& data);
 
 }  // namespace internal
 }  // namespace v8
diff --git a/deps/v8/src/strings/unicode-decoder.h b/deps/v8/src/strings/unicode-decoder.h
index e35d176770..464869351b 100644
--- a/deps/v8/src/strings/unicode-decoder.h
+++ b/deps/v8/src/strings/unicode-decoder.h
@@ -5,8 +5,8 @@
 #ifndef V8_STRINGS_UNICODE_DECODER_H_
 #define V8_STRINGS_UNICODE_DECODER_H_
 
+#include "src/base/vector.h"
 #include "src/strings/unicode.h"
-#include "src/utils/vector.h"
 
 namespace v8 {
 namespace internal {
@@ -52,7 +52,7 @@ class V8_EXPORT_PRIVATE Utf8Decoder final {
  public:
   enum class Encoding : uint8_t { kAscii, kLatin1, kUtf16 };
 
-  explicit Utf8Decoder(const Vector<const uint8_t>& chars);
+  explicit Utf8Decoder(const base::Vector<const uint8_t>& chars);
 
   bool is_ascii() const { return encoding_ == Encoding::kAscii; }
   bool is_one_byte() const { return encoding_ <= Encoding::kLatin1; }
@@ -60,7 +60,8 @@ class V8_EXPORT_PRIVATE Utf8Decoder final {
   int non_ascii_start() const { return non_ascii_start_; }
 
   template <typename Char>
-  V8_EXPORT_PRIVATE void Decode(Char* out, const Vector<const uint8_t>& data);
+  V8_EXPORT_PRIVATE void Decode(Char* out,
+                                const base::Vector<const uint8_t>& data);
 
  private:
   Encoding encoding_;
diff --git a/deps/v8/src/strings/uri.cc b/deps/v8/src/strings/uri.cc
index 925a5fca72..460ca586b9 100644
--- a/deps/v8/src/strings/uri.cc
+++ b/deps/v8/src/strings/uri.cc
@@ -15,7 +15,7 @@ namespace v8 {
 namespace internal {
 
 namespace {  // anonymous namespace for DecodeURI helper functions
-bool IsReservedPredicate(uc16 c) {
+bool IsReservedPredicate(base::uc16 c) {
   switch (c) {
     case '#':
     case '$':
@@ -45,15 +45,16 @@ bool IsReplacementCharacter(const uint8_t* octets, int length) {
 }
 
 bool DecodeOctets(const uint8_t* octets, int length,
-                  std::vector<uc16>* buffer) {
+                  std::vector<base::uc16>* buffer) {
   size_t cursor = 0;
-  uc32 value = unibrow::Utf8::ValueOf(octets, length, &cursor);
+  base::uc32 value = unibrow::Utf8::ValueOf(octets, length, &cursor);
   if (value == unibrow::Utf8::kBadChar &&
       !IsReplacementCharacter(octets, length)) {
     return false;
   }
 
-  if (value <= static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
+  if (value <=
+      static_cast<base::uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
     buffer->push_back(value);
   } else {
     buffer->push_back(unibrow::Utf16::LeadSurrogate(value));
@@ -62,23 +63,23 @@ bool DecodeOctets(const uint8_t* octets, int length,
   return true;
 }
 
-int TwoDigitHex(uc16 character1, uc16 character2) {
+int TwoDigitHex(base::uc16 character1, base::uc16 character2) {
   if (character1 > 'f') return -1;
-  int high = HexValue(character1);
+  int high = base::HexValue(character1);
   if (high == -1) return -1;
   if (character2 > 'f') return -1;
-  int low = HexValue(character2);
+  int low = base::HexValue(character2);
   if (low == -1) return -1;
   return (high << 4) + low;
 }
 
 template <typename T>
-void AddToBuffer(uc16 decoded, String::FlatContent* uri_content, int index,
-                 bool is_uri, std::vector<T>* buffer) {
+void AddToBuffer(base::uc16 decoded, String::FlatContent* uri_content,
+                 int index, bool is_uri, std::vector<T>* buffer) {
   if (is_uri && IsReservedPredicate(decoded)) {
     buffer->push_back('%');
-    uc16 first = uri_content->Get(index + 1);
-    uc16 second = uri_content->Get(index + 2);
+    base::uc16 first = uri_content->Get(index + 1);
+    base::uc16 second = uri_content->Get(index + 2);
     DCHECK_GT(std::numeric_limits<T>::max(), first);
     DCHECK_GT(std::numeric_limits<T>::max(), second);
 
@@ -90,9 +91,10 @@ void AddToBuffer(uc16 decoded, String::FlatContent* uri_content, int index,
 }
 
 bool IntoTwoByte(int index, bool is_uri, int uri_length,
-                 String::FlatContent* uri_content, std::vector<uc16>* buffer) {
+                 String::FlatContent* uri_content,
+                 std::vector<base::uc16>* buffer) {
   for (int k = index; k < uri_length; k++) {
-    uc16 code = uri_content->Get(k);
+    base::uc16 code = uri_content->Get(k);
     if (code == '%') {
       int two_digits;
       if (k + 2 >= uri_length ||
@@ -101,7 +103,7 @@ bool IntoTwoByte(int index, bool is_uri, int uri_length,
         return false;
       }
       k += 2;
-      uc16 decoded = static_cast<uc16>(two_digits);
+      base::uc16 decoded = static_cast<base::uc16>(two_digits);
       if (decoded > unibrow::Utf8::kMaxOneByteChar) {
         uint8_t octets[unibrow::Utf8::kMaxEncodedSize];
         octets[0] = decoded;
@@ -117,7 +119,7 @@ bool IntoTwoByte(int index, bool is_uri, int uri_length,
             return false;
           }
           k += 2;
-          uc16 continuation_byte = static_cast<uc16>(two_digits);
+          base::uc16 continuation_byte = static_cast<base::uc16>(two_digits);
           octets[number_of_continuation_bytes] = continuation_byte;
         }
 
@@ -136,13 +138,13 @@ bool IntoTwoByte(int index, bool is_uri, int uri_length,
 
 bool IntoOneAndTwoByte(Handle<String> uri, bool is_uri,
                        std::vector<uint8_t>* one_byte_buffer,
-                       std::vector<uc16>* two_byte_buffer) {
+                       std::vector<base::uc16>* two_byte_buffer) {
   DisallowGarbageCollection no_gc;
   String::FlatContent uri_content = uri->GetFlatContent(no_gc);
 
   int uri_length = uri->length();
   for (int k = 0; k < uri_length; k++) {
-    uc16 code = uri_content.Get(k);
+    base::uc16 code = uri_content.Get(k);
     if (code == '%') {
       int two_digits;
       if (k + 2 >= uri_length ||
@@ -151,7 +153,7 @@ bool IntoOneAndTwoByte(Handle<String> uri, bool is_uri,
         return false;
       }
 
-      uc16 decoded = static_cast<uc16>(two_digits);
+      base::uc16 decoded = static_cast<base::uc16>(two_digits);
       if (decoded > unibrow::Utf8::kMaxOneByteChar) {
         return IntoTwoByte(k, is_uri, uri_length, &uri_content,
                            two_byte_buffer);
@@ -176,14 +178,14 @@ MaybeHandle<String> Uri::Decode(Isolate* isolate, Handle<String> uri,
                                 bool is_uri) {
   uri = String::Flatten(isolate, uri);
   std::vector<uint8_t> one_byte_buffer;
-  std::vector<uc16> two_byte_buffer;
+  std::vector<base::uc16> two_byte_buffer;
 
   if (!IntoOneAndTwoByte(uri, is_uri, &one_byte_buffer, &two_byte_buffer)) {
     THROW_NEW_ERROR(isolate, NewURIError(), String);
   }
 
   if (two_byte_buffer.empty()) {
-    return isolate->factory()->NewStringFromOneByte(Vector<const uint8_t>(
+    return isolate->factory()->NewStringFromOneByte(base::Vector<const uint8_t>(
         one_byte_buffer.data(), static_cast<int>(one_byte_buffer.size())));
   }
 
@@ -195,7 +197,7 @@ MaybeHandle<String> Uri::Decode(Isolate* isolate, Handle<String> uri,
       String);
 
   DisallowGarbageCollection no_gc;
-  uc16* chars = result->GetChars(no_gc);
+  base::uc16* chars = result->GetChars(no_gc);
   if (!one_byte_buffer.empty()) {
     CopyChars(chars, one_byte_buffer.data(), one_byte_buffer.size());
     chars += one_byte_buffer.size();
@@ -208,7 +210,7 @@ MaybeHandle<String> Uri::Decode(Isolate* isolate, Handle<String> uri,
 }
 
 namespace {  // anonymous namespace for EncodeURI helper functions
-bool IsUnescapePredicateInUriComponent(uc16 c) {
+bool IsUnescapePredicateInUriComponent(base::uc16 c) {
   if (IsAlphaNumeric(c)) {
     return true;
   }
@@ -229,7 +231,7 @@ bool IsUnescapePredicateInUriComponent(uc16 c) {
   }
 }
 
-bool IsUriSeparator(uc16 c) {
+bool IsUriSeparator(base::uc16 c) {
   switch (c) {
     case '#':
     case ':':
@@ -250,11 +252,11 @@ bool IsUriSeparator(uc16 c) {
 
 void AddEncodedOctetToBuffer(uint8_t octet, std::vector<uint8_t>* buffer) {
   buffer->push_back('%');
-  buffer->push_back(HexCharOfValue(octet >> 4));
-  buffer->push_back(HexCharOfValue(octet & 0x0F));
+  buffer->push_back(base::HexCharOfValue(octet >> 4));
+  buffer->push_back(base::HexCharOfValue(octet & 0x0F));
 }
 
-void EncodeSingle(uc16 c, std::vector<uint8_t>* buffer) {
+void EncodeSingle(base::uc16 c, std::vector<uint8_t>* buffer) {
   char s[4] = {};
   int number_of_bytes;
   number_of_bytes =
@@ -264,7 +266,7 @@ void EncodeSingle(uc16 c, std::vector<uint8_t>* buffer) {
   }
 }
 
-void EncodePair(uc16 cc1, uc16 cc2, std::vector<uint8_t>* buffer) {
+void EncodePair(base::uc16 cc1, base::uc16 cc2, std::vector<uint8_t>* buffer) {
   char s[4] = {};
   int number_of_bytes =
       unibrow::Utf8::Encode(s, unibrow::Utf16::CombineSurrogatePair(cc1, cc2),
@@ -288,11 +290,11 @@ MaybeHandle<String> Uri::Encode(Isolate* isolate, Handle<String> uri,
     String::FlatContent uri_content = uri->GetFlatContent(no_gc);
 
     for (int k = 0; k < uri_length; k++) {
-      uc16 cc1 = uri_content.Get(k);
+      base::uc16 cc1 = uri_content.Get(k);
       if (unibrow::Utf16::IsLeadSurrogate(cc1)) {
         k++;
         if (k < uri_length) {
-          uc16 cc2 = uri->Get(k);
+          base::uc16 cc2 = uri->Get(k);
           if (unibrow::Utf16::IsTrailSurrogate(cc2)) {
             EncodePair(cc1, cc2, &buffer);
             continue;
@@ -313,13 +315,14 @@ MaybeHandle<String> Uri::Encode(Isolate* isolate, Handle<String> uri,
     }
   }
 
-  return isolate->factory()->NewStringFromOneByte(VectorOf(buffer));
+  return isolate->factory()->NewStringFromOneByte(base::VectorOf(buffer));
 }
 
 namespace {  // Anonymous namespace for Escape and Unescape
 
 template <typename Char>
-int UnescapeChar(Vector<const Char> vector, int i, int length, int* step) {
+int UnescapeChar(base::Vector<const Char> vector, int i, int length,
+                 int* step) {
   uint16_t character = vector[i];
   int32_t hi = 0;
   int32_t lo = 0;
@@ -347,7 +350,7 @@ MaybeHandle<String> UnescapeSlow(Isolate* isolate, Handle<String> string,
   int unescaped_length = 0;
   {
     DisallowGarbageCollection no_gc;
-    Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
+    base::Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
     for (int i = start_index; i < length; unescaped_length++) {
       int step;
       if (UnescapeChar(vector, i, length, &step) >
@@ -370,7 +373,7 @@ MaybeHandle<String> UnescapeSlow(Isolate* isolate, Handle<String> string,
                                         ->NewRawOneByteString(unescaped_length)
                                         .ToHandleChecked();
     DisallowGarbageCollection no_gc;
-    Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
+    base::Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
     for (int i = start_index; i < length; dest_position++) {
       int step;
       dest->SeqOneByteStringSet(dest_position,
@@ -383,7 +386,7 @@ MaybeHandle<String> UnescapeSlow(Isolate* isolate, Handle<String> string,
                                         ->NewRawTwoByteString(unescaped_length)
                                         .ToHandleChecked();
     DisallowGarbageCollection no_gc;
-    Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
+    base::Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
     for (int i = start_index; i < length; dest_position++) {
       int step;
       dest->SeqTwoByteStringSet(dest_position,
@@ -420,7 +423,7 @@ static MaybeHandle<String> UnescapePrivate(Isolate* isolate,
   int index;
   {
     DisallowGarbageCollection no_gc;
-    StringSearch<uint8_t, Char> search(isolate, StaticOneByteVector("%"));
+    StringSearch<uint8_t, Char> search(isolate, base::StaticOneByteVector("%"));
     index = search.Search(source->GetCharVector<Char>(no_gc), 0);
     if (index < 0) return source;
   }
@@ -436,7 +439,7 @@ static MaybeHandle<String> EscapePrivate(Isolate* isolate,
 
   {
     DisallowGarbageCollection no_gc;
-    Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
+    base::Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
     for (int i = 0; i < length; i++) {
       uint16_t c = vector[i];
       if (c >= 256) {
@@ -464,26 +467,30 @@ static MaybeHandle<String> EscapePrivate(Isolate* isolate,
 
   {
     DisallowGarbageCollection no_gc;
-    Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
+    base::Vector<const Char> vector = string->GetCharVector<Char>(no_gc);
     for (int i = 0; i < length; i++) {
       uint16_t c = vector[i];
       if (c >= 256) {
         dest->SeqOneByteStringSet(dest_position, '%');
         dest->SeqOneByteStringSet(dest_position + 1, 'u');
-        dest->SeqOneByteStringSet(dest_position + 2, HexCharOfValue(c >> 12));
+        dest->SeqOneByteStringSet(dest_position + 2,
+                                  base::HexCharOfValue(c >> 12));
         dest->SeqOneByteStringSet(dest_position + 3,
-                                  HexCharOfValue((c >> 8) & 0xF));
+                                  base::HexCharOfValue((c >> 8) & 0xF));
         dest->SeqOneByteStringSet(dest_position + 4,
-                                  HexCharOfValue((c >> 4) & 0xF));
-        dest->SeqOneByteStringSet(dest_position + 5, HexCharOfValue(c & 0xF));
+                                  base::HexCharOfValue((c >> 4) & 0xF));
+        dest->SeqOneByteStringSet(dest_position + 5,
+                                  base::HexCharOfValue(c & 0xF));
         dest_position += 6;
       } else if (IsNotEscaped(c)) {
         dest->SeqOneByteStringSet(dest_position, c);
         dest_position++;
       } else {
         dest->SeqOneByteStringSet(dest_position, '%');
-        dest->SeqOneByteStringSet(dest_position + 1, HexCharOfValue(c >> 4));
-        dest->SeqOneByteStringSet(dest_position + 2, HexCharOfValue(c & 0xF));
+        dest->SeqOneByteStringSet(dest_position + 1,
+                                  base::HexCharOfValue(c >> 4));
+        dest->SeqOneByteStringSet(dest_position + 2,
+                                  base::HexCharOfValue(c & 0xF));
         dest_position += 3;
       }
     }
@@ -499,7 +506,7 @@ MaybeHandle<String> Uri::Escape(Isolate* isolate, Handle<String> string) {
   string = String::Flatten(isolate, string);
   return String::IsOneByteRepresentationUnderneath(*string)
              ? EscapePrivate<uint8_t>(isolate, string)
-             : EscapePrivate<uc16>(isolate, string);
+             : EscapePrivate<base::uc16>(isolate, string);
 }
 
 MaybeHandle<String> Uri::Unescape(Isolate* isolate, Handle<String> string) {
@@ -507,7 +514,7 @@ MaybeHandle<String> Uri::Unescape(Isolate* isolate, Handle<String> string) {
   string = String::Flatten(isolate, string);
   return String::IsOneByteRepresentationUnderneath(*string)
              ? UnescapePrivate<uint8_t>(isolate, string)
-             : UnescapePrivate<uc16>(isolate, string);
+             : UnescapePrivate<base::uc16>(isolate, string);
 }
 
 }  // namespace internal