../deps/v8/src/objects/intl-objects.cc

Bug Summary

File:	out/../deps/v8/src/objects/intl-objects.cc
Warning:	line 2860, column 3 The left operand of '!=' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name intl-objects.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_STATIC -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/inspector-generated-output-root -I ../deps/v8/third_party/inspector_protocol -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/v8/third_party/zlib -I ../deps/v8/third_party/zlib/google -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/objects/intl-objects.cc
1// Copyright 2013 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.

5#ifndef V8_INTL_SUPPORT1
6#error Internationalization is expected to be enabled.
7#endif  // V8_INTL_SUPPORT

9#include "src/objects/intl-objects.h"

11#include <algorithm>
12#include <memory>
13#include <string>
14#include <vector>

16#include "src/api/api-inl.h"
17#include "src/base/strings.h"
18#include "src/date/date.h"
19#include "src/execution/isolate.h"
20#include "src/execution/local-isolate.h"
21#include "src/handles/global-handles.h"
22#include "src/heap/factory.h"
23#include "src/objects/js-collator-inl.h"
24#include "src/objects/js-date-time-format-inl.h"
25#include "src/objects/js-locale-inl.h"
26#include "src/objects/js-locale.h"
27#include "src/objects/js-number-format-inl.h"
28#include "src/objects/managed-inl.h"
29#include "src/objects/objects-inl.h"
30#include "src/objects/option-utils.h"
31#include "src/objects/property-descriptor.h"
32#include "src/objects/smi.h"
33#include "src/objects/string.h"
34#include "src/strings/string-case.h"
35#include "unicode/basictz.h"
36#include "unicode/brkiter.h"
37#include "unicode/calendar.h"
38#include "unicode/coll.h"
39#include "unicode/datefmt.h"
40#include "unicode/decimfmt.h"
41#include "unicode/formattedvalue.h"
42#include "unicode/localebuilder.h"
43#include "unicode/localematcher.h"
44#include "unicode/locid.h"
45#include "unicode/normalizer2.h"
46#include "unicode/numberformatter.h"
47#include "unicode/numfmt.h"
48#include "unicode/numsys.h"
49#include "unicode/timezone.h"
50#include "unicode/ures.h"
51#include "unicode/ustring.h"
52#include "unicode/uvernum.h"  // U_ICU_VERSION_MAJOR_NUM

54#define XSTR(s) STR(s)
55#define STR(s) #s
56static_assert(
  V8_MINIMUM_ICU_VERSION69 <= U_ICU_VERSION_MAJOR_NUM71,
  "v8 is required to build with ICU " XSTR(V8_MINIMUM_ICU_VERSION69) " and up");
59#undef STR
60#undef XSTR

62namespace v8 {
63namespace internal {

65namespace {

67constexpr uint8_t kToLower[256] = {
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
  0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
  0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
  0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73,
  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
  0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B,
  0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83,
  0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B,
  0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
  0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
  0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
  0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB,
  0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xD7,
  0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3,
  0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
  0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB,
  0xFC, 0xFD, 0xFE, 0xFF,
90};

92inline constexpr uint16_t ToLatin1Lower(uint16_t ch) {
return static_cast<uint16_t>(kToLower[ch]);
94}

96// Does not work for U+00DF (sharp-s), U+00B5 (micron), U+00FF.
97inline constexpr uint16_t ToLatin1Upper(uint16_t ch) {
DCHECK(ch != 0xDF && ch != 0xB5 && ch != 0xFF)((void) 0);
return ch &
       ~((IsAsciiLower(ch) || (((ch & 0xE0) == 0xE0) && ch != 0xF7)) << 5);
101}

103template <typename Char>
104bool ToUpperFastASCII(const base::Vector<const Char>& src,
                    Handle<SeqOneByteString> result) {
// Do a faster loop for the case where all the characters are ASCII.
uint16_t ored = 0;
int32_t index = 0;
for (auto it = src.begin(); it != src.end(); ++it) {
  uint16_t ch = static_cast<uint16_t>(*it);
  ored |= ch;
  result->SeqOneByteStringSet(index++, ToAsciiUpper(ch));
}
return !(ored & ~0x7F);
115}

117const uint16_t sharp_s = 0xDF;

119template <typename Char>
120bool ToUpperOneByte(const base::Vector<const Char>& src, uint8_t* dest,
                  int* sharp_s_count) {
// Still pretty-fast path for the input with non-ASCII Latin-1 characters.

// There are two special cases.
//  1. U+00B5 and U+00FF are mapped to a character beyond U+00FF.
//  2. Lower case sharp-S converts to "SS" (two characters)
*sharp_s_count = 0;
for (auto it = src.begin(); it != src.end(); ++it) {
  uint16_t ch = static_cast<uint16_t>(*it);
  if (V8_UNLIKELY(ch == sharp_s)(__builtin_expect(!!(ch == sharp_s), 0))) {
    ++(*sharp_s_count);
    continue;
  }
  if (V8_UNLIKELY(ch == 0xB5 || ch == 0xFF)(__builtin_expect(!!(ch == 0xB5 || ch == 0xFF), 0))) {
    // Since this upper-cased character does not fit in an 8-bit string, we
    // need to take the 16-bit path.
    return false;
  }
  *dest++ = ToLatin1Upper(ch);
}

return true;
143}

145template <typename Char>
146void ToUpperWithSharpS(const base::Vector<const Char>& src,
                     Handle<SeqOneByteString> result) {
int32_t dest_index = 0;
for (auto it = src.begin(); it != src.end(); ++it) {
  uint16_t ch = static_cast<uint16_t>(*it);
  if (ch == sharp_s) {
    result->SeqOneByteStringSet(dest_index++, 'S');
    result->SeqOneByteStringSet(dest_index++, 'S');
  } else {
    result->SeqOneByteStringSet(dest_index++, ToLatin1Upper(ch));
  }
}
158}

160inline int FindFirstUpperOrNonAscii(String s, int length) {
for (int index = 0; index < length; ++index) {
  uint16_t ch = s.Get(index);
  if (V8_UNLIKELY(IsAsciiUpper(ch) || ch & ~0x7F)(__builtin_expect(!!(IsAsciiUpper(ch) || ch & ~0x7F), 0))) {
    return index;
  }
}
return length;
168}

170const UChar* GetUCharBufferFromFlat(const String::FlatContent& flat,
                                  std::unique_ptr<base::uc16[]>* dest,
                                  int32_t length) {
DCHECK(flat.IsFlat())((void) 0);
if (flat.IsOneByte()) {
  if (!*dest) {
    dest->reset(NewArray<base::uc16>(length));
    CopyChars(dest->get(), flat.ToOneByteVector().begin(), length);
  }
  return reinterpret_cast<const UChar*>(dest->get());
} else {
  return reinterpret_cast<const UChar*>(flat.ToUC16Vector().begin());
}
183}

185template <typename T>
186MaybeHandle<T> New(Isolate* isolate, Handle<JSFunction> constructor,
                 Handle<Object> locales, Handle<Object> options,
                 const char* method_name) {
Handle<Map> map;
ASSIGN_RETURN_ON_EXCEPTION(do { if (!(JSFunction::GetDerivedMap(isolate, constructor, constructor
)).ToHandle(&map)) { ((void) 0); return MaybeHandle<T>
(); } } while (false)
    isolate, map,do { if (!(JSFunction::GetDerivedMap(isolate, constructor, constructor
)).ToHandle(&map)) { ((void) 0); return MaybeHandle<T>
(); } } while (false)
    JSFunction::GetDerivedMap(isolate, constructor, constructor), T)do { if (!(JSFunction::GetDerivedMap(isolate, constructor, constructor
)).ToHandle(&map)) { ((void) 0); return MaybeHandle<T>
(); } } while (false);
return T::New(isolate, map, locales, options, method_name);
194}
195}  // namespace

197const uint8_t* Intl::ToLatin1LowerTable() { return &kToLower[0]; }

199icu::UnicodeString Intl::ToICUUnicodeString(Isolate* isolate,
                                          Handle<String> string, int offset) {
DCHECK(string->IsFlat())((void) 0);
DisallowGarbageCollection no_gc;
std::unique_ptr<base::uc16[]> sap;
// Short one-byte strings can be expanded on the stack to avoid allocating a
// temporary buffer.
constexpr int kShortStringSize = 80;
UChar short_string_buffer[kShortStringSize];
const UChar* uchar_buffer = nullptr;
const String::FlatContent& flat = string->GetFlatContent(no_gc);
int32_t length = string->length();
DCHECK_LE(offset, length)((void) 0);
if (flat.IsOneByte() && length <= kShortStringSize) {
  CopyChars(short_string_buffer, flat.ToOneByteVector().begin(), length);
  uchar_buffer = short_string_buffer;
} else {
  uchar_buffer = GetUCharBufferFromFlat(flat, &sap, length);
}
return icu::UnicodeString(uchar_buffer + offset, length - offset);
219}

221namespace {

223icu::StringPiece ToICUStringPiece(Isolate* isolate, Handle<String> string,
                                int offset = 0) {
DCHECK(string->IsFlat())((void) 0);
DisallowGarbageCollection no_gc;

const String::FlatContent& flat = string->GetFlatContent(no_gc);
if (!flat.IsOneByte()) return icu::StringPiece();

int32_t length = string->length();
DCHECK_LT(offset, length)((void) 0);
const char* char_buffer =
    reinterpret_cast<const char*>(flat.ToOneByteVector().begin());
if (!String::IsAscii(char_buffer, length)) {
  return icu::StringPiece();
}

return icu::StringPiece(char_buffer + offset, length - offset);
240}

242MaybeHandle<String> LocaleConvertCase(Isolate* isolate, Handle<String> s,
                                    bool is_to_upper, const char* lang) {
auto case_converter = is_to_upper ? u_strToUpperu_strToUpper_71 : u_strToLoweru_strToLower_71;
int32_t src_length = s->length();
int32_t dest_length = src_length;
UErrorCode status;
Handle<SeqTwoByteString> result;
std::unique_ptr<base::uc16[]> sap;

if (dest_length == 0) return ReadOnlyRoots(isolate).empty_string_handle();

// This is not a real loop. It'll be executed only once (no overflow) or
// twice (overflow).
for (int i = 0; i < 2; ++i) {
  // Case conversion can increase the string length (e.g. sharp-S => SS) so
  // that we have to handle RangeError exceptions here.
  ASSIGN_RETURN_ON_EXCEPTION(do { if (!(isolate->factory()->NewRawTwoByteString(dest_length
)).ToHandle(&result)) { ((void) 0); return MaybeHandle<
String>(); } } while (false)
      isolate, result, isolate->factory()->NewRawTwoByteString(dest_length),do { if (!(isolate->factory()->NewRawTwoByteString(dest_length
)).ToHandle(&result)) { ((void) 0); return MaybeHandle<
String>(); } } while (false)
      String)do { if (!(isolate->factory()->NewRawTwoByteString(dest_length
)).ToHandle(&result)) { ((void) 0); return MaybeHandle<
String>(); } } while (false);
  DisallowGarbageCollection no_gc;
  DCHECK(s->IsFlat())((void) 0);
  String::FlatContent flat = s->GetFlatContent(no_gc);
  const UChar* src = GetUCharBufferFromFlat(flat, &sap, src_length);
  status = U_ZERO_ERROR;
  dest_length =
      case_converter(reinterpret_cast<UChar*>(result->GetChars(no_gc)),
                     dest_length, src, src_length, lang, &status);
  if (status != U_BUFFER_OVERFLOW_ERROR) break;
}

// In most cases, the output will fill the destination buffer completely
// leading to an unterminated string (U_STRING_NOT_TERMINATED_WARNING).
// Only in rare cases, it'll be shorter than the destination buffer and
// |result| has to be truncated.
DCHECK(U_SUCCESS(status))((void) 0);
if (V8_LIKELY(status == U_STRING_NOT_TERMINATED_WARNING)(__builtin_expect(!!(status == U_STRING_NOT_TERMINATED_WARNING
), 1))) {
  DCHECK(dest_length == result->length())((void) 0);
  return result;
}
DCHECK(dest_length < result->length())((void) 0);
return SeqString::Truncate(result, dest_length);
283}

285}  // namespace

287// A stripped-down version of ConvertToLower that can only handle flat one-byte
288// strings and does not allocate. Note that {src} could still be, e.g., a
289// one-byte sliced string with a two-byte parent string.
290// Called from TF builtins.
291String Intl::ConvertOneByteToLower(String src, String dst) {
DCHECK_EQ(src.length(), dst.length())((void) 0);
DCHECK(src.IsOneByteRepresentation())((void) 0);
DCHECK(src.IsFlat())((void) 0);
DCHECK(dst.IsSeqOneByteString())((void) 0);

DisallowGarbageCollection no_gc;

const int length = src.length();
String::FlatContent src_flat = src.GetFlatContent(no_gc);
uint8_t* dst_data = SeqOneByteString::cast(dst).GetChars(no_gc);

if (src_flat.IsOneByte()) {
  const uint8_t* src_data = src_flat.ToOneByteVector().begin();

  bool has_changed_character = false;
  int index_to_first_unprocessed =
      FastAsciiConvert<true>(reinterpret_cast<char*>(dst_data),
                             reinterpret_cast<const char*>(src_data), length,
                             &has_changed_character);

  if (index_to_first_unprocessed == length) {
    return has_changed_character ? dst : src;
  }

  // If not ASCII, we keep the result up to index_to_first_unprocessed and
  // process the rest.
  for (int index = index_to_first_unprocessed; index < length; ++index) {
    dst_data[index] = ToLatin1Lower(static_cast<uint16_t>(src_data[index]));
  }
} else {
  DCHECK(src_flat.IsTwoByte())((void) 0);
  int index_to_first_unprocessed = FindFirstUpperOrNonAscii(src, length);
  if (index_to_first_unprocessed == length) return src;

  const uint16_t* src_data = src_flat.ToUC16Vector().begin();
  CopyChars(dst_data, src_data, index_to_first_unprocessed);
  for (int index = index_to_first_unprocessed; index < length; ++index) {
    dst_data[index] = ToLatin1Lower(static_cast<uint16_t>(src_data[index]));
  }
}

return dst;
334}

336MaybeHandle<String> Intl::ConvertToLower(Isolate* isolate, Handle<String> s) {
if (!s->IsOneByteRepresentation()) {
  // Use a slower implementation for strings with characters beyond U+00FF.
  return LocaleConvertCase(isolate, s, false, "");
}

int length = s->length();

// We depend here on the invariant that the length of a Latin1
// string is invariant under ToLowerCase, and the result always
// fits in the Latin1 range in the *root locale*. It does not hold
// for ToUpperCase even in the root locale.

// Scan the string for uppercase and non-ASCII characters for strings
// shorter than a machine-word without any memory allocation overhead.
// TODO(jshin): Apply this to a longer input by breaking FastAsciiConvert()
// to two parts, one for scanning the prefix with no change and the other for
// handling ASCII-only characters.

bool is_short = length < static_cast<int>(sizeof(uintptr_t));
if (is_short) {
  bool is_lower_ascii = FindFirstUpperOrNonAscii(*s, length) == length;
  if (is_lower_ascii) return s;
}

Handle<SeqOneByteString> result =
    isolate->factory()->NewRawOneByteString(length).ToHandleChecked();

return Handle<String>(Intl::ConvertOneByteToLower(*s, *result), isolate);
365}

367MaybeHandle<String> Intl::ConvertToUpper(Isolate* isolate, Handle<String> s) {
int32_t length = s->length();
if (s->IsOneByteRepresentation() && length > 0) {
  Handle<SeqOneByteString> result =
      isolate->factory()->NewRawOneByteString(length).ToHandleChecked();

  DCHECK(s->IsFlat())((void) 0);
  int sharp_s_count;
  bool is_result_single_byte;
  {
    DisallowGarbageCollection no_gc;
    String::FlatContent flat = s->GetFlatContent(no_gc);
    uint8_t* dest = result->GetChars(no_gc);
    if (flat.IsOneByte()) {
      base::Vector<const uint8_t> src = flat.ToOneByteVector();
      bool has_changed_character = false;
      int index_to_first_unprocessed = FastAsciiConvert<false>(
          reinterpret_cast<char*>(result->GetChars(no_gc)),
          reinterpret_cast<const char*>(src.begin()), length,
          &has_changed_character);
      if (index_to_first_unprocessed == length) {
        return has_changed_character ? result : s;
      }
      // If not ASCII, we keep the result up to index_to_first_unprocessed and
      // process the rest.
      is_result_single_byte =
          ToUpperOneByte(src.SubVector(index_to_first_unprocessed, length),
                         dest + index_to_first_unprocessed, &sharp_s_count);
    } else {
      DCHECK(flat.IsTwoByte())((void) 0);
      base::Vector<const uint16_t> src = flat.ToUC16Vector();
      if (ToUpperFastASCII(src, result)) return result;
      is_result_single_byte = ToUpperOneByte(src, dest, &sharp_s_count);
    }
  }

  // Go to the full Unicode path if there are characters whose uppercase
  // is beyond the Latin-1 range (cannot be represented in OneByteString).
  if (V8_UNLIKELY(!is_result_single_byte)(__builtin_expect(!!(!is_result_single_byte), 0))) {
    return LocaleConvertCase(isolate, s, true, "");
  }

  if (sharp_s_count == 0) return result;

  // We have sharp_s_count sharp-s characters, but the result is still
  // in the Latin-1 range.
  ASSIGN_RETURN_ON_EXCEPTION(do { if (!(isolate->factory()->NewRawOneByteString(length
 + sharp_s_count)).ToHandle(&result)) { ((void) 0); return
 MaybeHandle<String>(); } } while (false)
      isolate, result,do { if (!(isolate->factory()->NewRawOneByteString(length
 + sharp_s_count)).ToHandle(&result)) { ((void) 0); return
 MaybeHandle<String>(); } } while (false)
      isolate->factory()->NewRawOneByteString(length + sharp_s_count),do { if (!(isolate->factory()->NewRawOneByteString(length
 + sharp_s_count)).ToHandle(&result)) { ((void) 0); return
 MaybeHandle<String>(); } } while (false)
      String)do { if (!(isolate->factory()->NewRawOneByteString(length
 + sharp_s_count)).ToHandle(&result)) { ((void) 0); return
 MaybeHandle<String>(); } } while (false);
  DisallowGarbageCollection no_gc;
  String::FlatContent flat = s->GetFlatContent(no_gc);
  if (flat.IsOneByte()) {
    ToUpperWithSharpS(flat.ToOneByteVector(), result);
  } else {
    ToUpperWithSharpS(flat.ToUC16Vector(), result);
  }

  return result;
}

return LocaleConvertCase(isolate, s, true, "");
429}

431std::string Intl::GetNumberingSystem(const icu::Locale& icu_locale) {
// Ugly hack. ICU doesn't expose numbering system in any way, so we have
// to assume that for given locale NumberingSystem constructor produces the
// same digits as NumberFormat/Calendar would.
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::NumberingSystem> numbering_system(
    icu::NumberingSystem::createInstance(icu_locale, status));
if (U_SUCCESS(status) && !numbering_system->isAlgorithmic()) {
  return numbering_system->getName();
}
return "latn";
442}

444namespace {

446Maybe<icu::Locale> CreateICULocale(const std::string& bcp47_locale) {
DisallowGarbageCollection no_gc;

// Convert BCP47 into ICU locale format.
UErrorCode status = U_ZERO_ERROR;

icu::Locale icu_locale = icu::Locale::forLanguageTag(bcp47_locale, status);
DCHECK(U_SUCCESS(status))((void) 0);
if (icu_locale.isBogus()) {
  return Nothing<icu::Locale>();
}

return Just(icu_locale);
459}

461}  // anonymous namespace

463// static

465MaybeHandle<String> Intl::ToString(Isolate* isolate,
                                 const icu::UnicodeString& string) {
return isolate->factory()->NewStringFromTwoByte(base::Vector<const uint16_t>(
    reinterpret_cast<const uint16_t*>(string.getBuffer()), string.length()));
469}

471MaybeHandle<String> Intl::ToString(Isolate* isolate,
                                 const icu::UnicodeString& string,
                                 int32_t begin, int32_t end) {
return Intl::ToString(isolate, string.tempSubStringBetween(begin, end));
475}

477namespace {

479Handle<JSObject> InnerAddElement(Isolate* isolate, Handle<JSArray> array,
                               int index, Handle<String> field_type_string,
                               Handle<String> value) {
// let element = $array[$index] = {
//   type: $field_type_string,
//   value: $value
// }
// return element;
Factory* factory = isolate->factory();
Handle<JSObject> element = factory->NewJSObject(isolate->object_function());
JSObject::AddProperty(isolate, element, factory->type_string(),
                      field_type_string, NONE);

JSObject::AddProperty(isolate, element, factory->value_string(), value, NONE);
// TODO(victorgomes): Temporarily forcing a fatal error here in case of
// overflow, until Intl::AddElement can handle exceptions.
if (JSObject::AddDataElement(array, index, element, NONE).IsNothing()) {
  FATAL("Fatal JavaScript invalid size error when adding element")V8_Fatal("Fatal JavaScript invalid size error when adding element"
);
  UNREACHABLE()V8_Fatal("unreachable code");
}
return element;
500}

502}  // namespace

504void Intl::AddElement(Isolate* isolate, Handle<JSArray> array, int index,
                    Handle<String> field_type_string, Handle<String> value) {
// Same as $array[$index] = {type: $field_type_string, value: $value};
InnerAddElement(isolate, array, index, field_type_string, value);
508}

510void Intl::AddElement(Isolate* isolate, Handle<JSArray> array, int index,
                    Handle<String> field_type_string, Handle<String> value,
                    Handle<String> additional_property_name,
                    Handle<String> additional_property_value) {
// Same as $array[$index] = {
//   type: $field_type_string, value: $value,
//   $additional_property_name: $additional_property_value
// }
Handle<JSObject> element =
    InnerAddElement(isolate, array, index, field_type_string, value);
JSObject::AddProperty(isolate, element, additional_property_name,
                      additional_property_value, NONE);
522}

524namespace {

526// Build the shortened locale; eg, convert xx_Yyyy_ZZ  to xx_ZZ.
527//
528// If locale has a script tag then return true and the locale without the
529// script else return false and an empty string.
530bool RemoveLocaleScriptTag(const std::string& icu_locale,
                         std::string* locale_less_script) {
icu::Locale new_locale = icu::Locale::createCanonical(icu_locale.c_str());
const char* icu_script = new_locale.getScript();
if (icu_script == nullptr || strlen(icu_script) == 0) {
  *locale_less_script = std::string();
  return false;
}

const char* icu_language = new_locale.getLanguage();
const char* icu_country = new_locale.getCountry();
icu::Locale short_locale = icu::Locale(icu_language, icu_country);
*locale_less_script = short_locale.getName();
return true;
544}

546bool ValidateResource(const icu::Locale locale, const char* path,
                    const char* key) {
bool result = false;
UErrorCode status = U_ZERO_ERROR;
UResourceBundle* bundle = ures_openures_open_71(path, locale.getName(), &status);
if (bundle != nullptr && status == U_ZERO_ERROR) {
  if (key == nullptr) {
    result = true;
  } else {
    UResourceBundle* key_bundle =
        ures_getByKeyures_getByKey_71(bundle, key, nullptr, &status);
    result = key_bundle != nullptr && (status == U_ZERO_ERROR);
    ures_closeures_close_71(key_bundle);
  }
}
ures_closeures_close_71(bundle);
if (!result) {
  if ((locale.getCountry()[0] != '\0') && (locale.getScript()[0] != '\0')) {
    // Fallback to try without country.
    std::string without_country(locale.getLanguage());
    without_country = without_country.append("-").append(locale.getScript());
    return ValidateResource(without_country.c_str(), path, key);
  } else if ((locale.getCountry()[0] != '\0') ||
             (locale.getScript()[0] != '\0')) {
    // Fallback to try with only language.
    std::string language(locale.getLanguage());
    return ValidateResource(language.c_str(), path, key);
  }
}
return result;
576}

578}  // namespace

580std::set<std::string> Intl::BuildLocaleSet(
  const std::vector<std::string>& icu_available_locales, const char* path,
  const char* validate_key) {
std::set<std::string> locales;
for (const std::string& locale : icu_available_locales) {
  if (path != nullptr || validate_key != nullptr) {
    if (!ValidateResource(icu::Locale(locale.c_str()), path, validate_key)) {
      // FIXME(chromium:1215606) Find a beter fix for nb->no fallback
      if (locale != "nb") {
        continue;
      }
      // Try no for nb
      if (!ValidateResource(icu::Locale("no"), path, validate_key)) {
        continue;
      }
    }
  }
  locales.insert(locale);
  std::string shortened_locale;
  if (RemoveLocaleScriptTag(locale, &shortened_locale)) {
    std::replace(shortened_locale.begin(), shortened_locale.end(), '_', '-');
    locales.insert(shortened_locale);
  }
}
return locales;
605}

607Maybe<std::string> Intl::ToLanguageTag(const icu::Locale& locale) {
UErrorCode status = U_ZERO_ERROR;
std::string res = locale.toLanguageTag<std::string>(status);
if (U_FAILURE(status)) {
  return Nothing<std::string>();
}
DCHECK(U_SUCCESS(status))((void) 0);
return Just(res);
615}

617// See ecma402/#legacy-constructor.
618MaybeHandle<Object> Intl::LegacyUnwrapReceiver(Isolate* isolate,
                                             Handle<JSReceiver> receiver,
                                             Handle<JSFunction> constructor,
                                             bool has_initialized_slot) {
Handle<Object> obj_ordinary_has_instance;
ASSIGN_RETURN_ON_EXCEPTION(do { if (!(Object::OrdinaryHasInstance(isolate, constructor, receiver
)).ToHandle(&obj_ordinary_has_instance)) { ((void) 0); return
 MaybeHandle<Object>(); } } while (false)
    isolate, obj_ordinary_has_instance,do { if (!(Object::OrdinaryHasInstance(isolate, constructor, receiver
)).ToHandle(&obj_ordinary_has_instance)) { ((void) 0); return
 MaybeHandle<Object>(); } } while (false)
    Object::OrdinaryHasInstance(isolate, constructor, receiver), Object)do { if (!(Object::OrdinaryHasInstance(isolate, constructor, receiver
)).ToHandle(&obj_ordinary_has_instance)) { ((void) 0); return
 MaybeHandle<Object>(); } } while (false);
bool ordinary_has_instance = obj_ordinary_has_instance->BooleanValue(isolate);

// 2. If receiver does not have an [[Initialized...]] internal slot
//    and ? OrdinaryHasInstance(constructor, receiver) is true, then
if (!has_initialized_slot && ordinary_has_instance) {
  // 2. a. Let new_receiver be ? Get(receiver, %Intl%.[[FallbackSymbol]]).
  Handle<Object> new_receiver;
  ASSIGN_RETURN_ON_EXCEPTION(do { if (!(JSReceiver::GetProperty(isolate, receiver, isolate
->factory()->intl_fallback_symbol())).ToHandle(&new_receiver
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
      isolate, new_receiver,do { if (!(JSReceiver::GetProperty(isolate, receiver, isolate
->factory()->intl_fallback_symbol())).ToHandle(&new_receiver
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
      JSReceiver::GetProperty(isolate, receiver,do { if (!(JSReceiver::GetProperty(isolate, receiver, isolate
->factory()->intl_fallback_symbol())).ToHandle(&new_receiver
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
                              isolate->factory()->intl_fallback_symbol()),do { if (!(JSReceiver::GetProperty(isolate, receiver, isolate
->factory()->intl_fallback_symbol())).ToHandle(&new_receiver
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
      Object)do { if (!(JSReceiver::GetProperty(isolate, receiver, isolate
->factory()->intl_fallback_symbol())).ToHandle(&new_receiver
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false);
  return new_receiver;
}

return receiver;
642}

644namespace {

646bool IsTwoLetterLanguage(const std::string& locale) {
// Two letters, both in range 'a'-'z'...
return locale.length() == 2 && IsAsciiLower(locale[0]) &&
       IsAsciiLower(locale[1]);
650}

652bool IsDeprecatedOrLegacyLanguage(const std::string& locale) {
//  Check if locale is one of the deprecated language tags:
return locale == "in" || locale == "iw" || locale == "ji" || locale == "jw" ||
       locale == "mo" ||
       //  Check if locale is one of the legacy language tags:
       locale == "sh" || locale == "tl" || locale == "no";
658}

660bool IsStructurallyValidLanguageTag(const std::string& tag) {
return JSLocale::StartsWithUnicodeLanguageId(tag);
662}

664// Canonicalize the locale.
665// https://tc39.github.io/ecma402/#sec-canonicalizelanguagetag,
666// including type check and structural validity check.
667Maybe<std::string> CanonicalizeLanguageTag(Isolate* isolate,
                                         const std::string& locale_in) {
std::string locale = locale_in;

if (locale.length() == 0 ||
    !String::IsAscii(locale.data(), static_cast<int>(locale.length()))) {
  THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      NewRangeError(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          MessageTemplate::kInvalidLanguageTag,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          isolate->factory()->NewStringFromAsciiChecked(locale.c_str())),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
);
}

// Optimize for the most common case: a 2-letter language code in the
// canonical form/lowercase that is not one of the deprecated codes
// (in, iw, ji, jw). Don't check for ~70 of 3-letter deprecated language
// codes. Instead, let them be handled by ICU in the slow path. However,
// fast-track 'fil' (3-letter canonical code).
if ((IsTwoLetterLanguage(locale) && !IsDeprecatedOrLegacyLanguage(locale)) ||
    locale == "fil") {
  return Just(locale);
}

// Because per BCP 47 2.1.1 language tags are case-insensitive, lowercase
// the input before any more check.
std::transform(locale.begin(), locale.end(), locale.begin(), ToAsciiLower);

// // ECMA 402 6.2.3
// TODO(jshin): uloc_{for,to}TanguageTag can fail even for a structually valid
// language tag if it's too long (much longer than 100 chars). Even if we
// allocate a longer buffer, ICU will still fail if it's too long. Either
// propose to Ecma 402 to put a limit on the locale length or change ICU to
// handle long locale names better. See
// https://unicode-org.atlassian.net/browse/ICU-13417
UErrorCode error = U_ZERO_ERROR;
// uloc_forLanguageTag checks the structrual validity. If the input BCP47
// language tag is parsed all the way to the end, it indicates that the input
// is structurally valid. Due to a couple of bugs, we can't use it
// without Chromium patches or ICU 62 or earlier.
icu::Locale icu_locale = icu::Locale::forLanguageTag(locale.c_str(), error);

if (U_FAILURE(error) || icu_locale.isBogus()) {
  THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      NewRangeError(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          MessageTemplate::kInvalidLanguageTag,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          isolate->factory()->NewStringFromAsciiChecked(locale.c_str())),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
);
}

// Use LocaleBuilder to validate locale.
icu_locale = icu::LocaleBuilder().setLocale(icu_locale).build(error);
icu_locale.canonicalize(error);
if (U_FAILURE(error) || icu_locale.isBogus()) {
  THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      NewRangeError(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          MessageTemplate::kInvalidLanguageTag,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          isolate->factory()->NewStringFromAsciiChecked(locale.c_str())),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
);
}
Maybe<std::string> maybe_to_language_tag = Intl::ToLanguageTag(icu_locale);
if (maybe_to_language_tag.IsNothing()) {
  THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      NewRangeError(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          MessageTemplate::kInvalidLanguageTag,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
          isolate->factory()->NewStringFromAsciiChecked(locale.c_str())),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
)
      Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalidLanguageTag
, isolate->factory()->NewStringFromAsciiChecked(locale.
c_str()))); return Nothing<std::string>(); } while (false
);
}

return maybe_to_language_tag;
740}

742Maybe<std::string> CanonicalizeLanguageTag(Isolate* isolate,
                                         Handle<Object> locale_in) {
Handle<String> locale_str;
// This does part of the validity checking spec'ed in CanonicalizeLocaleList:
// 7c ii. If Type(kValue) is not String or Object, throw a TypeError
// exception.
// 7c iii. Let tag be ? ToString(kValue).
// 7c iv. If IsStructurallyValidLanguageTag(tag) is false, throw a
// RangeError exception.

if (locale_in->IsString()) {
  locale_str = Handle<String>::cast(locale_in);
} else if (locale_in->IsJSReceiver()) {
  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, locale_str,do { if (!(Object::ToString(isolate, locale_in)).ToHandle(&
locale_str)) { ((void) 0); return Nothing<std::string>(
); } } while (false)
                                   Object::ToString(isolate, locale_in),do { if (!(Object::ToString(isolate, locale_in)).ToHandle(&
locale_str)) { ((void) 0); return Nothing<std::string>(
); } } while (false)
                                   Nothing<std::string>())do { if (!(Object::ToString(isolate, locale_in)).ToHandle(&
locale_str)) { ((void) 0); return Nothing<std::string>(
); } } while (false);
} else {
  THROW_NEW_ERROR_RETURN_VALUE(isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewTypeError(MessageTemplate::kLanguageID)
); return Nothing<std::string>(); } while (false)
                               NewTypeError(MessageTemplate::kLanguageID),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewTypeError(MessageTemplate::kLanguageID)
); return Nothing<std::string>(); } while (false)
                               Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewTypeError(MessageTemplate::kLanguageID)
); return Nothing<std::string>(); } while (false);
}
std::string locale(locale_str->ToCString().get());

if (!IsStructurallyValidLanguageTag(locale)) {
  THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kLocaleBadParameters
)); return Nothing<std::string>(); } while (false)
      isolate, NewRangeError(MessageTemplate::kLocaleBadParameters),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kLocaleBadParameters
)); return Nothing<std::string>(); } while (false)
      Nothing<std::string>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kLocaleBadParameters
)); return Nothing<std::string>(); } while (false);
}
return CanonicalizeLanguageTag(isolate, locale);
771}

773}  // anonymous namespace

775Maybe<std::vector<std::string>> Intl::CanonicalizeLocaleList(
  Isolate* isolate, Handle<Object> locales, bool only_return_one_result) {
// 1. If locales is undefined, then
if (locales->IsUndefined(isolate)) {
  // 1a. Return a new empty List.
  return Just(std::vector<std::string>());
}
// 2. Let seen be a new empty List.
std::vector<std::string> seen;
// 3. If Type(locales) is String or locales has an [[InitializedLocale]]
// internal slot,  then
if (locales->IsJSLocale()) {
  // Since this value came from JSLocale, which is already went though the
  // CanonializeLanguageTag process once, therefore there are no need to
  // call CanonializeLanguageTag again.
  seen.push_back(JSLocale::ToString(Handle<JSLocale>::cast(locales)));
  return Just(seen);
}
if (locales->IsString()) {
  // 3a. Let O be CreateArrayFromList(« locales »).
  // Instead of creating a one-element array and then iterating over it,
  // we inline the body of the iteration:
  std::string canonicalized_tag;
  if (!CanonicalizeLanguageTag(isolate, locales).To(&canonicalized_tag)) {
    return Nothing<std::vector<std::string>>();
  }
  seen.push_back(canonicalized_tag);
  return Just(seen);
}
// 4. Else,
// 4a. Let O be ? ToObject(locales).
Handle<JSReceiver> o;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, o,do { if (!(Object::ToObject(isolate, locales)).ToHandle(&
o)) { ((void) 0); return Nothing<std::vector<std::string
>>(); } } while (false)
                                 Object::ToObject(isolate, locales),do { if (!(Object::ToObject(isolate, locales)).ToHandle(&
o)) { ((void) 0); return Nothing<std::vector<std::string
>>(); } } while (false)
                                 Nothing<std::vector<std::string>>())do { if (!(Object::ToObject(isolate, locales)).ToHandle(&
o)) { ((void) 0); return Nothing<std::vector<std::string
>>(); } } while (false);
// 5. Let len be ? ToLength(? Get(O, "length")).
Handle<Object> length_obj;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, length_obj,do { if (!(Object::GetLengthFromArrayLike(isolate, o)).ToHandle
(&length_obj)) { ((void) 0); return Nothing<std::vector
<std::string>>(); } } while (false)
                                 Object::GetLengthFromArrayLike(isolate, o),do { if (!(Object::GetLengthFromArrayLike(isolate, o)).ToHandle
(&length_obj)) { ((void) 0); return Nothing<std::vector
<std::string>>(); } } while (false)
                                 Nothing<std::vector<std::string>>())do { if (!(Object::GetLengthFromArrayLike(isolate, o)).ToHandle
(&length_obj)) { ((void) 0); return Nothing<std::vector
<std::string>>(); } } while (false);
// TODO(jkummerow): Spec violation: strictly speaking, we have to iterate
// up to 2^53-1 if {length_obj} says so. Since cases above 2^32 probably
// don't happen in practice (and would be very slow if they do), we'll keep
// the code simple for now by using a saturating to-uint32 conversion.
double raw_length = length_obj->Number();
uint32_t len =
    raw_length >= kMaxUInt32 ? kMaxUInt32 : static_cast<uint32_t>(raw_length);
// 6. Let k be 0.
// 7. Repeat, while k < len
for (uint32_t k = 0; k < len; k++) {
  // 7a. Let Pk be ToString(k).
  // 7b. Let kPresent be ? HasProperty(O, Pk).
  LookupIterator it(isolate, o, k);
  Maybe<bool> maybe_found = JSReceiver::HasProperty(&it);
  MAYBE_RETURN(maybe_found, Nothing<std::vector<std::string>>())do { if ((maybe_found).IsNothing()) return Nothing<std::vector
<std::string>>(); } while (false);
  // 7c. If kPresent is true, then
  if (!maybe_found.FromJust()) continue;
  // 7c i. Let kValue be ? Get(O, Pk).
  Handle<Object> k_value;
  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, k_value, Object::GetProperty(&it),do { if (!(Object::GetProperty(&it)).ToHandle(&k_value
)) { ((void) 0); return Nothing<std::vector<std::string
>>(); } } while (false)
                                   Nothing<std::vector<std::string>>())do { if (!(Object::GetProperty(&it)).ToHandle(&k_value
)) { ((void) 0); return Nothing<std::vector<std::string
>>(); } } while (false);
  // 7c ii. If Type(kValue) is not String or Object, throw a TypeError
  // exception.
  // 7c iii. If Type(kValue) is Object and kValue has an [[InitializedLocale]]
  // internal slot, then
  std::string canonicalized_tag;
  if (k_value->IsJSLocale()) {
    // 7c iii. 1. Let tag be kValue.[[Locale]].
    canonicalized_tag = JSLocale::ToString(Handle<JSLocale>::cast(k_value));
    // 7c iv. Else,
  } else {
    // 7c iv 1. Let tag be ? ToString(kValue).
    // 7c v. If IsStructurallyValidLanguageTag(tag) is false, throw a
    // RangeError exception.
    // 7c vi. Let canonicalizedTag be CanonicalizeLanguageTag(tag).
    if (!CanonicalizeLanguageTag(isolate, k_value).To(&canonicalized_tag)) {
      return Nothing<std::vector<std::string>>();
    }
  }
  // 7c vi. If canonicalizedTag is not an element of seen, append
  // canonicalizedTag as the last element of seen.
  if (std::find(seen.begin(), seen.end(), canonicalized_tag) == seen.end()) {
    seen.push_back(canonicalized_tag);
  }
  // 7d. Increase k by 1. (See loop header.)
  // Optimization: some callers only need one result.
  if (only_return_one_result) return Just(seen);
}
// 8. Return seen.
return Just(seen);
865}

867// ecma402 #sup-string.prototype.tolocalelowercase
868// ecma402 #sup-string.prototype.tolocaleuppercase
869MaybeHandle<String> Intl::StringLocaleConvertCase(Isolate* isolate,
                                                Handle<String> s,
                                                bool to_upper,
                                                Handle<Object> locales) {
std::vector<std::string> requested_locales;
if (!CanonicalizeLocaleList(isolate, locales, true).To(&requested_locales)) {
  return MaybeHandle<String>();
}
std::string requested_locale = requested_locales.size() == 0
                                   ? isolate->DefaultLocale()
                                   : requested_locales[0];
size_t dash = requested_locale.find('-');
if (dash != std::string::npos) {
  requested_locale = requested_locale.substr(0, dash);
}

// Primary language tag can be up to 8 characters long in theory.
// https://tools.ietf.org/html/bcp47#section-2.2.1
DCHECK_LE(requested_locale.length(), 8)((void) 0);
s = String::Flatten(isolate, s);

// All the languages requiring special-handling have two-letter codes.
// Note that we have to check for '!= 2' here because private-use language
// tags (x-foo) or grandfathered irregular tags (e.g. i-enochian) would have
// only 'x' or 'i' when they get here.
if (V8_UNLIKELY(requested_locale.length() != 2)(__builtin_expect(!!(requested_locale.length() != 2), 0))) {
  if (to_upper) {
    return ConvertToUpper(isolate, s);
  }
  return ConvertToLower(isolate, s);
}
// TODO(jshin): Consider adding a fast path for ASCII or Latin-1. The fastpath
// in the root locale needs to be adjusted for az, lt and tr because even case
// mapping of ASCII range characters are different in those locales.
// Greek (el) does not require any adjustment.
if (V8_UNLIKELY((requested_locale == "tr") || (requested_locale == "el") ||(__builtin_expect(!!((requested_locale == "tr") || (requested_locale
 == "el") || (requested_locale == "lt") || (requested_locale ==
 "az")), 0))
                (requested_locale == "lt") || (requested_locale == "az"))(__builtin_expect(!!((requested_locale == "tr") || (requested_locale
 == "el") || (requested_locale == "lt") || (requested_locale ==
 "az")), 0))) {
  return LocaleConvertCase(isolate, s, to_upper, requested_locale.c_str());
} else {
  if (to_upper) {
    return ConvertToUpper(isolate, s);
  }
  return ConvertToLower(isolate, s);
}
913}

915// static
916template <class IsolateT>
917Intl::CompareStringsOptions Intl::CompareStringsOptionsFor(
  IsolateT* isolate, Handle<Object> locales, Handle<Object> options) {
if (!options->IsUndefined(isolate)) {
  return CompareStringsOptions::kNone;
}

// Lists all of the available locales that are statically known to fulfill
// fast path conditions. See the StringLocaleCompareFastPath test as a
// starting point to update this list.
//
// Locale entries are roughly sorted s.t. common locales come first.
//
// The actual conditions are verified in debug builds in
// CollatorAllowsFastComparison.
static const char* const kFastLocales[] = {
    "en-US", "en", "fr", "es",    "de",    "pt",    "it", "ca",
    "de-AT", "fi", "id", "id-ID", "ms",    "nl",    "pl", "ro",
    "sl",    "sv", "sw", "vi",    "en-DE", "en-GB",
};

if (locales->IsUndefined(isolate)) {
  const std::string& default_locale = isolate->DefaultLocale();
  for (const char* fast_locale : kFastLocales) {
    if (strcmp(fast_locale, default_locale.c_str()) == 0) {
      return CompareStringsOptions::kTryFastPath;
    }
  }

  return CompareStringsOptions::kNone;
}

if (!locales->IsString()) return CompareStringsOptions::kNone;

Handle<String> locales_string = Handle<String>::cast(locales);
for (const char* fast_locale : kFastLocales) {
  if (locales_string->IsEqualTo(base::CStrVector(fast_locale), isolate)) {
    return CompareStringsOptions::kTryFastPath;
  }
}

return CompareStringsOptions::kNone;
958}

960// Instantiations.
961template Intl::CompareStringsOptions Intl::CompareStringsOptionsFor(
  Isolate*, Handle<Object>, Handle<Object>);
963template Intl::CompareStringsOptions Intl::CompareStringsOptionsFor(
  LocalIsolate*, Handle<Object>, Handle<Object>);

966base::Optional<int> Intl::StringLocaleCompare(
  Isolate* isolate, Handle<String> string1, Handle<String> string2,
  Handle<Object> locales, Handle<Object> options, const char* method_name) {
// We only cache the instance when locales is a string/undefined and
// options is undefined, as that is the only case when the specified
// side-effects of examining those arguments are unobservable.
const bool can_cache =
    (locales->IsString() || locales->IsUndefined(isolate)) &&
    options->IsUndefined(isolate);
// We may be able to take the fast path, depending on the `locales` and
// `options` arguments.
const CompareStringsOptions compare_strings_options =
    CompareStringsOptionsFor(isolate, locales, options);
if (can_cache) {
  // Both locales and options are undefined, check the cache.
  icu::Collator* cached_icu_collator =
      static_cast<icu::Collator*>(isolate->get_cached_icu_object(
          Isolate::ICUObjectCacheType::kDefaultCollator, locales));
  // We may use the cached icu::Collator for a fast path.
  if (cached_icu_collator != nullptr) {
    return Intl::CompareStrings(isolate, *cached_icu_collator, string1,
                                string2, compare_strings_options);
  }
}

Handle<JSFunction> constructor = Handle<JSFunction>(
    JSFunction::cast(
        isolate->context().native_context().intl_collator_function()),
    isolate);

Handle<JSCollator> collator;
MaybeHandle<JSCollator> maybe_collator =
    New<JSCollator>(isolate, constructor, locales, options, method_name);
if (!maybe_collator.ToHandle(&collator)) return {};
if (can_cache) {
  isolate->set_icu_object_in_cache(
      Isolate::ICUObjectCacheType::kDefaultCollator, locales,
      std::static_pointer_cast<icu::UMemory>(collator->icu_collator().get()));
}
icu::Collator* icu_collator = collator->icu_collator().raw();
return Intl::CompareStrings(isolate, *icu_collator, string1, string2,
                            compare_strings_options);
1008}

1010namespace {

1012// Weights for the Unicode Collation Algorithm for charcodes [0x00,0x7F].
1013// https://unicode.org/reports/tr10/.
1014//
1015// Generated from:
1016//
1017// $ wget http://www.unicode.org/Public/UCA/latest/allkeys.txt
1018// $ cat ~/allkeys.txt | grep '^00[0-7].  ;' | sort | sed 's/[*.]/ /g' |\
1019//   sed 's/.*\[ \(.*\)\].*/\1/' | python ~/gen_weights.py
1020//
1021// Where gen_weights.py does an ordinal rank s.t. weights fit in a uint8_t:
1022//
1023//   import sys
1024//
1025//   def to_ordinal(ws):
1026//       weight_map = {}
1027//       weights_uniq_sorted = sorted(set(ws))
1028//       for i in range(0, len(weights_uniq_sorted)):
1029//           weight_map[weights_uniq_sorted[i]] = i
1030//       return [weight_map[x] for x in ws]
1031//
1032//   def print_weight_list(array_name, ws):
1033//       print("constexpr uint8_t %s[256] = {" % array_name, end = "")
1034//       i = 0
1035//       for w in ws:
1036//           if (i % 16) == 0:
1037//               print("\n  ", end = "")
1038//           print("%3d," % w, end = "")
1039//           i += 1
1040//       print("\n};\n")
1041//
1042//   if __name__ == "__main__":
1043//       l1s = []
1044//       l3s = []
1045//       for line in sys.stdin:
1046//           weights = line.split()
1047//           l1s.append(int(weights[0], 16))
1048//           l3s.append(int(weights[2], 16))
1049//       print_weight_list("kCollationWeightsL1", to_ordinal(l1s))
1050//       print_weight_list("kCollationWeightsL3", to_ordinal(l3s))

1052// clang-format off
1053constexpr uint8_t kCollationWeightsL1[256] = {
  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  5,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  6, 12, 16, 28, 38, 29, 27, 15, 17, 18, 24, 32,  9,  8, 14, 25,
 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 11, 10, 33, 34, 35, 13,
 23, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 19, 26, 20, 31,  7,
 30, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 21, 36, 22, 37,  0,
1062};
1063constexpr uint8_t kCollationWeightsL3[256] = {
  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  1,  1,  1,  1,  1,
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,
1072};
1073constexpr int kCollationWeightsLength = arraysize(kCollationWeightsL1)(sizeof(ArraySizeHelper(kCollationWeightsL1)));
1074STATIC_ASSERT(kCollationWeightsLength == arraysize(kCollationWeightsL3))static_assert(kCollationWeightsLength == (sizeof(ArraySizeHelper
(kCollationWeightsL3))), "kCollationWeightsLength == arraysize(kCollationWeightsL3)"
);
1075// clang-format on

1077// Normalize a comparison delta (usually `lhs - rhs`) to UCollationResult
1078// values.
1079constexpr UCollationResult ToUCollationResult(int delta) {
return delta < 0 ? UCollationResult::UCOL_LESS
                 : (delta > 0 ? UCollationResult::UCOL_GREATER
                              : UCollationResult::UCOL_EQUAL);
1083}

1085struct FastCompareStringsData {
UCollationResult l1_result = UCollationResult::UCOL_EQUAL;
UCollationResult l3_result = UCollationResult::UCOL_EQUAL;
int processed_until = 0;
int first_diff_at = 0;  // The first relevant diff (L1 if exists, else L3).
bool has_diff = false;

base::Optional<UCollationResult> FastCompareFailed(
    int* processed_until_out) const {
  if (has_diff) {
    // Found some difference, continue there to ensure the generic algorithm
    // picks it up.
    *processed_until_out = first_diff_at;
  } else {
    // No difference found, reprocess the last processed character since it
    // may be followed by a unicode combining character (which alters it's
    // meaning).
    *processed_until_out = std::max(processed_until - 1, 0);
  }
  return {};
}
1106};

1108template <class CharT>
1109constexpr bool CanFastCompare(CharT c) {
return c < kCollationWeightsLength && kCollationWeightsL1[c] != 0;
1111}

1113template <class Char1T, class Char2T>
1114bool FastCompareFlatString(const Char1T* lhs, const Char2T* rhs, int length,
                         FastCompareStringsData* d) {
for (int i = 0; i < length; i++) {
  const Char1T l = lhs[i];
  const Char2T r = rhs[i];
  if (!CanFastCompare(l) || !CanFastCompare(r)) {
    d->processed_until = i;
    return false;
  }
  UCollationResult l1_result =
      ToUCollationResult(kCollationWeightsL1[l] - kCollationWeightsL1[r]);
  if (l1_result != UCollationResult::UCOL_EQUAL) {
    d->has_diff = true;
    d->first_diff_at = i;
    d->processed_until = i;
    d->l1_result = l1_result;
    return true;
  }
  if (l != r && d->l3_result == UCollationResult::UCOL_EQUAL) {
    // Collapse the two-pass algorithm into one: if we find a difference in
    // L1 weights, that is our result. If not, use the first L3 weight
    // difference.
    UCollationResult l3_result =
        ToUCollationResult(kCollationWeightsL3[l] - kCollationWeightsL3[r]);
    d->l3_result = l3_result;
    if (!d->has_diff) {
      d->has_diff = true;
      d->first_diff_at = i;
    }
  }
}
d->processed_until = length;
return true;
1147}

1149bool FastCompareStringFlatContent(const String::FlatContent& lhs,
                                const String::FlatContent& rhs, int length,
                                FastCompareStringsData* d) {
if (lhs.IsOneByte()) {
  base::Vector<const uint8_t> l = lhs.ToOneByteVector();
  if (rhs.IsOneByte()) {
    base::Vector<const uint8_t> r = rhs.ToOneByteVector();
    return FastCompareFlatString(l.data(), r.data(), length, d);
  } else {
    base::Vector<const uint16_t> r = rhs.ToUC16Vector();
    return FastCompareFlatString(l.data(), r.data(), length, d);
  }
} else {
  base::Vector<const uint16_t> l = lhs.ToUC16Vector();
  if (rhs.IsOneByte()) {
    base::Vector<const uint8_t> r = rhs.ToOneByteVector();
    return FastCompareFlatString(l.data(), r.data(), length, d);
  } else {
    base::Vector<const uint16_t> r = rhs.ToUC16Vector();
    return FastCompareFlatString(l.data(), r.data(), length, d);
  }
}
UNREACHABLE()V8_Fatal("unreachable code");
1172}

1174bool CharIsAsciiOrOutOfBounds(const String::FlatContent& string,
                            int string_length, int index) {
DCHECK_EQ(string.length(), string_length)((void) 0);
return index >= string_length || isascii(string.Get(index));
1178}

1180bool CharCanFastCompareOrOutOfBounds(const String::FlatContent& string,
                                   int string_length, int index) {
DCHECK_EQ(string.length(), string_length)((void) 0);
return index >= string_length || CanFastCompare(string.Get(index));
1184}

1186#ifdef DEBUG
1187bool USetContainsAllAsciiItem(USet* set) {
static constexpr int kBufferSize = 64;
UChar buffer[kBufferSize];

const int length = uset_getItemCountuset_getItemCount_71(set);
for (int i = 0; i < length; i++) {
  UChar32 start, end;
  UErrorCode status = U_ZERO_ERROR;
  const int item_length =
      uset_getItemuset_getItem_71(set, i, &start, &end, buffer, kBufferSize, &status);
  CHECK(U_SUCCESS(status))do { if ((__builtin_expect(!!(!(U_SUCCESS(status))), 0))) { V8_Fatal
("Check failed: %s.", "U_SUCCESS(status)"); } } while (false);
  DCHECK_GE(item_length, 0)((void) 0);

  if (item_length == 0) {
    // Empty string or a range.
    if (isascii(start)) return true;
  } else {
    // A non-empty string.
    bool all_ascii = true;
    for (int j = 0; j < item_length; j++) {
      if (!isascii(buffer[j])) {
        all_ascii = false;
        break;
      }
    }

    if (all_ascii) return true;
  }
}

return false;
1218}

1220bool CollatorAllowsFastComparison(const icu::Collator& icu_collator) {
UErrorCode status = U_ZERO_ERROR;

icu::Locale icu_locale(icu_collator.getLocale(ULOC_VALID_LOCALE, status));
DCHECK(U_SUCCESS(status))((void) 0);

static constexpr int kBufferSize = 64;
char buffer[kBufferSize];
const int collation_keyword_length =
    icu_locale.getKeywordValue("collation", buffer, kBufferSize, status);
DCHECK(U_SUCCESS(status))((void) 0);
if (collation_keyword_length != 0) return false;

// These attributes must be set to the expected value for fast comparisons.
static constexpr struct {
  UColAttribute attribute;
  UColAttributeValue legal_value;
} kAttributeChecks[] = {
    {UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE},
    {UCOL_CASE_FIRST, UCOL_OFF},
    {UCOL_CASE_LEVEL, UCOL_OFF},
    {UCOL_FRENCH_COLLATION, UCOL_OFF},
    {UCOL_NUMERIC_COLLATION, UCOL_OFF},
    {UCOL_STRENGTH, UCOL_TERTIARY},
};

for (const auto& check : kAttributeChecks) {
  if (icu_collator.getAttribute(check.attribute, status) !=
      check.legal_value) {
    return false;
  }
  DCHECK(U_SUCCESS(status))((void) 0);
}

// No reordering codes are allowed.
int num_reorder_codes =
    ucol_getReorderCodesucol_getReorderCodes_71(icu_collator.toUCollator(), nullptr, 0, &status);
if (num_reorder_codes != 0) return false;
DCHECK(U_SUCCESS(status))((void) 0);  // Must check *after* num_reorder_codes != 0.

// No tailored rules are allowed.
int32_t rules_length = 0;
ucol_getRulesucol_getRules_71(icu_collator.toUCollator(), &rules_length);
if (rules_length != 0) return false;

USet* tailored_set = ucol_getTailoredSetucol_getTailoredSet_71(icu_collator.toUCollator(), &status);
DCHECK(U_SUCCESS(status))((void) 0);
if (USetContainsAllAsciiItem(tailored_set)) return false;
uset_closeuset_close_71(tailored_set);

// No ASCII contractions or expansions are allowed.
USet* contractions = uset_openEmptyuset_openEmpty_71();
USet* expansions = uset_openEmptyuset_openEmpty_71();
ucol_getContractionsAndExpansionsucol_getContractionsAndExpansions_71(icu_collator.toUCollator(), contractions,
                                  expansions, true, &status);
if (USetContainsAllAsciiItem(contractions)) return false;
if (USetContainsAllAsciiItem(expansions)) return false;
DCHECK(U_SUCCESS(status))((void) 0);
uset_closeuset_close_71(contractions);
uset_closeuset_close_71(expansions);

return true;
1282}
1283#endif  // DEBUG

1285// Fast comparison is implemented for charcodes for which the L1 collation
1286// weight (see kCollactionWeightsL1 above) is not 0.
1287//
1288// Note it's possible to partially process strings as long as their leading
1289// characters all satisfy the above criteria. In that case, and if the L3
1290// result is EQUAL, we set `processed_until_out` to the first non-processed
1291// index - future processing can begin at that offset.
1292//
1293// This fast path looks somewhat complex; mostly because it combines multiple
1294// passes into one. The pseudo-code for simplified multi-pass algorithm is:
1295//
1296// {
1297//   // We can only fast-compare a certain subset of the ASCII range.
1298//   // Additionally, unicode characters can change the meaning of preceding
1299//   // characters, for example: "o\u0308" is treated like "ö".
1300//   //
1301//   // Note, in the actual single-pass algorithm below, we tolerate non-ASCII
1302//   // contents outside the relevant range.
1303//   for (int i = 0; i < string1.length; i++) {
1304//     if (!CanFastCompare(string1[i])) return {};
1305//   }
1306//   for (int i = 0; i < string2.length; i++) {
1307//     if (!CanFastCompare(string2[i])) return {};
1308//   }
1309//
1310//   // Apply L1 weights.
1311//   for (int i = 0; i < common_length; i++) {
1312//     Char1T c1 = string1[i];
1313//     Char2T c2 = string2[i];
1314//     if (L1Weight[c1] != L1Weight[c2]) {
1315//       return L1Weight[c1] - L1Weight[c2];
1316//     }
1317//   }
1318//
1319//   // Strings are L1-equal up to the common length; if lengths differ, the
1320//   // longer string is treated as 'greater'.
1321//   if (string1.length != string2.length) string1.length - string2.length;
1322//
1323//   // Apply L3 weights.
1324//   for (int i = 0; i < common_length; i++) {
1325//     Char1T c1 = string1[i];
1326//     Char2T c2 = string2[i];
1327//     if (L3Weight[c1] != L3Weight[c2]) {
1328//       return L3Weight[c1] - L3Weight[c2];
1329//     }
1330//   }
1331//
1332//   return UCOL_EQUAL;
1333// }
1334base::Optional<UCollationResult> TryFastCompareStrings(
  Isolate* isolate, const icu::Collator& icu_collator, Handle<String> string1,
  Handle<String> string2, int* processed_until_out) {
// TODO(jgruber): We could avoid the flattening (done by the caller) as well
// by implementing comparison through string iteration. This has visible
// performance benefits (e.g. 7% on CDJS) but complicates the code. Consider
// doing this in the future.
DCHECK(string1->IsFlat())((void) 0);
DCHECK(string2->IsFlat())((void) 0);

*processed_until_out = 0;

1346#ifdef DEBUG
// Checked by the caller, see CompareStringsOptionsFor.
SLOW_DCHECK(CollatorAllowsFastComparison(icu_collator))((void)0);
USE(CollatorAllowsFastComparison)do { ::v8::base::Use unused_tmp_array_for_use_macro[]{CollatorAllowsFastComparison
}; (void)unused_tmp_array_for_use_macro; } while (false);
1350#endif  // DEBUG

DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*string1))((void) 0);
DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*string2))((void) 0);

const int length1 = string1->length();
const int length2 = string2->length();
int common_length = std::min(length1, length2);

FastCompareStringsData d;
DisallowGarbageCollection no_gc;
const String::FlatContent& flat1 = string1->GetFlatContent(no_gc);
const String::FlatContent& flat2 = string2->GetFlatContent(no_gc);
if (!FastCompareStringFlatContent(flat1, flat2, common_length, &d)) {
  DCHECK_EQ(d.l1_result, UCollationResult::UCOL_EQUAL)((void) 0);
  return d.FastCompareFailed(processed_until_out);
}

// The result is only valid if the last processed character is not followed
// by a unicode combining character (we are overly strict and restrict to
// ASCII).
if (!CharIsAsciiOrOutOfBounds(flat1, length1, d.processed_until + 1) ||
    !CharIsAsciiOrOutOfBounds(flat2, length2, d.processed_until + 1)) {
  return d.FastCompareFailed(processed_until_out);
}

if (d.l1_result != UCollationResult::UCOL_EQUAL) {
  return d.l1_result;
}

// Strings are L1-equal up to their common length, length differences win.
UCollationResult length_result = ToUCollationResult(length1 - length2);
if (length_result != UCollationResult::UCOL_EQUAL) {
  // Strings of different lengths may still compare as equal if the longer
  // string has a fully ignored suffix, e.g. "a" vs. "a\u{1}".
  if (!CharCanFastCompareOrOutOfBounds(flat1, length1, common_length) ||
      !CharCanFastCompareOrOutOfBounds(flat2, length2, common_length)) {
    return d.FastCompareFailed(processed_until_out);
  }
  return length_result;
}

// L1-equal and same length, the L3 result wins.
return d.l3_result;
1394}

1396}  // namespace

1398// static
1399const uint8_t* Intl::AsciiCollationWeightsL1() {
return &kCollationWeightsL1[0];
1401}

1403// static
1404const uint8_t* Intl::AsciiCollationWeightsL3() {
return &kCollationWeightsL3[0];
1406}

1408// static
1409const int Intl::kAsciiCollationWeightsLength = kCollationWeightsLength;

1411// ecma402/#sec-collator-comparestrings
1412int Intl::CompareStrings(Isolate* isolate, const icu::Collator& icu_collator,
                       Handle<String> string1, Handle<String> string2,
                       CompareStringsOptions compare_strings_options) {
// Early return for identical strings.
if (string1.is_identical_to(string2)) {
  return UCollationResult::UCOL_EQUAL;
}

// Early return for empty strings.
if (string1->length() == 0 || string2->length() == 0) {
  return ToUCollationResult(string1->length() - string2->length());
}

string1 = String::Flatten(isolate, string1);
string2 = String::Flatten(isolate, string2);

int processed_until = 0;
if (compare_strings_options == CompareStringsOptions::kTryFastPath) {
  base::Optional<int> maybe_result = TryFastCompareStrings(
      isolate, icu_collator, string1, string2, &processed_until);
  if (maybe_result.has_value()) return maybe_result.value();
}

UCollationResult result;
UErrorCode status = U_ZERO_ERROR;
icu::StringPiece string_piece1 =
    ToICUStringPiece(isolate, string1, processed_until);
if (!string_piece1.empty()) {
  icu::StringPiece string_piece2 =
      ToICUStringPiece(isolate, string2, processed_until);
  if (!string_piece2.empty()) {
    result = icu_collator.compareUTF8(string_piece1, string_piece2, status);
    DCHECK(U_SUCCESS(status))((void) 0);
    return result;
  }
}

icu::UnicodeString string_val1 =
    Intl::ToICUUnicodeString(isolate, string1, processed_until);
icu::UnicodeString string_val2 =
    Intl::ToICUUnicodeString(isolate, string2, processed_until);
result = icu_collator.compare(string_val1, string_val2, status);
DCHECK(U_SUCCESS(status))((void) 0);
return result;
1456}

1458// ecma402/#sup-properties-of-the-number-prototype-object
1459MaybeHandle<String> Intl::NumberToLocaleString(Isolate* isolate,
                                             Handle<Object> num,
                                             Handle<Object> locales,
                                             Handle<Object> options,
                                             const char* method_name) {
Handle<Object> numeric_obj;
ASSIGN_RETURN_ON_EXCEPTION(isolate, numeric_obj,do { if (!(Object::ToNumeric(isolate, num)).ToHandle(&numeric_obj
)) { ((void) 0); return MaybeHandle<String>(); } } while
 (false)
                           Object::ToNumeric(isolate, num), String)do { if (!(Object::ToNumeric(isolate, num)).ToHandle(&numeric_obj
)) { ((void) 0); return MaybeHandle<String>(); } } while
 (false);

// We only cache the instance when locales is a string/undefined and
// options is undefined, as that is the only case when the specified
// side-effects of examining those arguments are unobservable.
bool can_cache = (locales->IsString() || locales->IsUndefined(isolate)) &&
                 options->IsUndefined(isolate);
if (can_cache) {
  icu::number::LocalizedNumberFormatter* cached_number_format =
      static_cast<icu::number::LocalizedNumberFormatter*>(
          isolate->get_cached_icu_object(
              Isolate::ICUObjectCacheType::kDefaultNumberFormat, locales));
  // We may use the cached icu::NumberFormat for a fast path.
  if (cached_number_format != nullptr) {
    return JSNumberFormat::FormatNumeric(isolate, *cached_number_format,
                                         numeric_obj);
  }
}

Handle<JSFunction> constructor = Handle<JSFunction>(
    JSFunction::cast(
        isolate->context().native_context().intl_number_format_function()),
    isolate);
Handle<JSNumberFormat> number_format;
// 2. Let numberFormat be ? Construct(%NumberFormat%, « locales, options »).
ASSIGN_RETURN_ON_EXCEPTION(do { if (!(New<JSNumberFormat>(isolate, constructor, locales
, options, method_name)).ToHandle(&number_format)) { ((void
) 0); return MaybeHandle<String>(); } } while (false)
    isolate, number_format,do { if (!(New<JSNumberFormat>(isolate, constructor, locales
, options, method_name)).ToHandle(&number_format)) { ((void
) 0); return MaybeHandle<String>(); } } while (false)
    New<JSNumberFormat>(isolate, constructor, locales, options, method_name),do { if (!(New<JSNumberFormat>(isolate, constructor, locales
, options, method_name)).ToHandle(&number_format)) { ((void
) 0); return MaybeHandle<String>(); } } while (false)
    String)do { if (!(New<JSNumberFormat>(isolate, constructor, locales
, options, method_name)).ToHandle(&number_format)) { ((void
) 0); return MaybeHandle<String>(); } } while (false);

if (can_cache) {
  isolate->set_icu_object_in_cache(
      Isolate::ICUObjectCacheType::kDefaultNumberFormat, locales,
      std::static_pointer_cast<icu::UMemory>(
          number_format->icu_number_formatter().get()));
}

// Return FormatNumber(numberFormat, x).
icu::number::LocalizedNumberFormatter* icu_number_format =
    number_format->icu_number_formatter().raw();
return JSNumberFormat::FormatNumeric(isolate, *icu_number_format,
                                     numeric_obj);
1508}

1510Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
  Isolate* isolate, Handle<JSReceiver> options, int mnfd_default,
  int mxfd_default, bool notation_is_compact) {
Factory* factory = isolate->factory();
Intl::NumberFormatDigitOptions digit_options;

// 5. Let mnid be ? GetNumberOption(options, "minimumIntegerDigits,", 1, 21,
// 1).
int mnid = 1;
if (!GetNumberOption(isolate, options, factory->minimumIntegerDigits_string(),
                     1, 21, 1)
         .To(&mnid)) {
  return Nothing<NumberFormatDigitOptions>();
}

// 6. Let mnfd be ? Get(options, "minimumFractionDigits").
Handle<Object> mnfd_obj;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumFractionDigits_string())).ToHandle(&mnfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    isolate, mnfd_obj,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumFractionDigits_string())).ToHandle(&mnfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    JSReceiver::GetProperty(isolate, options,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumFractionDigits_string())).ToHandle(&mnfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
                            factory->minimumFractionDigits_string()),do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumFractionDigits_string())).ToHandle(&mnfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    Nothing<NumberFormatDigitOptions>())do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumFractionDigits_string())).ToHandle(&mnfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false);

// 7. Let mxfd be ? Get(options, "maximumFractionDigits").
Handle<Object> mxfd_obj;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumFractionDigits_string())).ToHandle(&mxfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    isolate, mxfd_obj,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumFractionDigits_string())).ToHandle(&mxfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    JSReceiver::GetProperty(isolate, options,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumFractionDigits_string())).ToHandle(&mxfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
                            factory->maximumFractionDigits_string()),do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumFractionDigits_string())).ToHandle(&mxfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false)
    Nothing<NumberFormatDigitOptions>())do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumFractionDigits_string())).ToHandle(&mxfd_obj)) { (
(void) 0); return Nothing<NumberFormatDigitOptions>(); }
 } while (false);

// 8.  Let mnsd be ? Get(options, "minimumSignificantDigits").
Handle<Object> mnsd_obj;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumSignificantDigits_string())).ToHandle(&mnsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    isolate, mnsd_obj,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumSignificantDigits_string())).ToHandle(&mnsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    JSReceiver::GetProperty(isolate, options,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumSignificantDigits_string())).ToHandle(&mnsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
                            factory->minimumSignificantDigits_string()),do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumSignificantDigits_string())).ToHandle(&mnsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    Nothing<NumberFormatDigitOptions>())do { if (!(JSReceiver::GetProperty(isolate, options, factory->
minimumSignificantDigits_string())).ToHandle(&mnsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false);

// 9. Let mxsd be ? Get(options, "maximumSignificantDigits").
Handle<Object> mxsd_obj;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumSignificantDigits_string())).ToHandle(&mxsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    isolate, mxsd_obj,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumSignificantDigits_string())).ToHandle(&mxsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    JSReceiver::GetProperty(isolate, options,do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumSignificantDigits_string())).ToHandle(&mxsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
                            factory->maximumSignificantDigits_string()),do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumSignificantDigits_string())).ToHandle(&mxsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false)
    Nothing<NumberFormatDigitOptions>())do { if (!(JSReceiver::GetProperty(isolate, options, factory->
maximumSignificantDigits_string())).ToHandle(&mxsd_obj)) {
 ((void) 0); return Nothing<NumberFormatDigitOptions>()
; } } while (false);

digit_options.rounding_priority = RoundingPriority::kAuto;
digit_options.minimum_significant_digits = 0;
digit_options.maximum_significant_digits = 0;

// 10. Set intlObj.[[MinimumIntegerDigits]] to mnid.
digit_options.minimum_integer_digits = mnid;

if (FLAG_harmony_intl_number_format_v3) {
  // 11. Let roundingPriority be ? GetOption(options, "roundingPriority",
  // "string", « "auto", "morePrecision", "lessPrecision" », "auto").

  Maybe<RoundingPriority> maybe_rounding_priority =
      GetStringOption<RoundingPriority>(
          isolate, options, "roundingPriority", "SetNumberFormatDigitOptions",
          {"auto", "morePrecision", "lessPrecision"},
          {RoundingPriority::kAuto, RoundingPriority::kMorePrecision,
           RoundingPriority::kLessPrecision},
          RoundingPriority::kAuto);
  MAYBE_RETURN(maybe_rounding_priority, Nothing<NumberFormatDigitOptions>())do { if ((maybe_rounding_priority).IsNothing()) return Nothing
<NumberFormatDigitOptions>(); } while (false);
  digit_options.rounding_priority = maybe_rounding_priority.FromJust();
}

// 12. If mnsd is not undefined or mxsd is not undefined, then
// a. Set hasSd to true.
// 13. Else,
// a. Set hasSd to false.
bool has_sd =
    (!mnsd_obj->IsUndefined(isolate)) || (!mxsd_obj->IsUndefined(isolate));

// 14. If mnfd is not undefined or mxfd is not undefined, then
// a. Set hasFd to true.
// 15. Else,
// a. Set hasFd to false.
bool has_fd =
    (!mnfd_obj->IsUndefined(isolate)) || (!mxfd_obj->IsUndefined(isolate));

// 17. If hasSd or roundingPriority is not "auto", set needSd to true; else,
// set needSd to false.
bool need_sd =
    has_sd || (RoundingPriority::kAuto != digit_options.rounding_priority);

// 18. If ( not hasSd and (hasFd or notation is not "compact") ) or
// roundingPriority is not "auto", then a. Set needFd to true.
// 19. Else,
// a. Set needFd to false.
bool need_fd = ((!has_sd) && (has_fd || !notation_is_compact)) ||
               (RoundingPriority::kAuto != digit_options.rounding_priority);

// 20. If needSd, then
if (need_sd) {
  // 20.b If hasSd, then
  if (has_sd) {
    // 20.b.i Let mnsd be ? DefaultNumberOption(mnsd, 1, 21, 1).
    int mnsd;
    if (!DefaultNumberOption(isolate, mnsd_obj, 1, 21, 1,
                             factory->minimumSignificantDigits_string())
             .To(&mnsd)) {
      return Nothing<NumberFormatDigitOptions>();
    }
    // 20.b.ii Let mxsd be ? DefaultNumberOption(mxsd, mnsd, 21, 21).
    int mxsd;
    if (!DefaultNumberOption(isolate, mxsd_obj, mnsd, 21, 21,
                             factory->maximumSignificantDigits_string())
             .To(&mxsd)) {
      return Nothing<NumberFormatDigitOptions>();
    }
    // 20.b.iii Set intlObj.[[MinimumSignificantDigits]] to mnsd.
    digit_options.minimum_significant_digits = mnsd;
    // 20.b.iv Set intlObj.[[MaximumSignificantDigits]] to mxsd.
    digit_options.maximum_significant_digits = mxsd;
  } else {
    // 20.c Else
    // 20.c.i Set intlObj.[[MinimumSignificantDigits]] to 1.
    digit_options.minimum_significant_digits = 1;
    // 20.c.ii Set intlObj.[[MaximumSignificantDigits]] to 21.
    digit_options.maximum_significant_digits = 21;
  }
}

// 21. If needFd, then
if (need_fd) {
  // 21.a If hasFd, then
  if (has_fd) {
    Handle<String> mnfd_str = factory->minimumFractionDigits_string();
    Handle<String> mxfd_str = factory->maximumFractionDigits_string();
    // 21.a.i Let mnfd be ? DefaultNumberOption(mnfd, 0, 20, undefined).
    int mnfd;
    if (!DefaultNumberOption(isolate, mnfd_obj, 0, 20, -1, mnfd_str)
             .To(&mnfd)) {
      return Nothing<NumberFormatDigitOptions>();
    }
    // 21.a.ii Let mxfd be ? DefaultNumberOption(mxfd, 0, 20, undefined).
    int mxfd;
    if (!DefaultNumberOption(isolate, mxfd_obj, 0, 20, -1, mxfd_str)
             .To(&mxfd)) {
      return Nothing<NumberFormatDigitOptions>();
    }
    // 21.a.iii If mnfd is undefined, set mnfd to min(mnfdDefault, mxfd).
    if (mnfd_obj->IsUndefined(isolate)) {
      mnfd = std::min(mnfd_default, mxfd);
    } else if (mxfd_obj->IsUndefined(isolate)) {
      // 21.a.iv Else if mxfd is undefined, set mxfd to max(mxfdDefault,
      // mnfd).
      mxfd = std::max(mxfd_default, mnfd);
    } else if (mnfd > mxfd) {
      // 21.a.v Else if mnfd is greater than mxfd, throw a RangeError
      // exception.
      THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kPropertyValueOutOfRange
, mxfd_str)); return Nothing<NumberFormatDigitOptions>(
); } while (false)
          isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kPropertyValueOutOfRange
, mxfd_str)); return Nothing<NumberFormatDigitOptions>(
); } while (false)
          NewRangeError(MessageTemplate::kPropertyValueOutOfRange, mxfd_str),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kPropertyValueOutOfRange
, mxfd_str)); return Nothing<NumberFormatDigitOptions>(
); } while (false)
          Nothing<NumberFormatDigitOptions>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError(MessageTemplate::kPropertyValueOutOfRange
, mxfd_str)); return Nothing<NumberFormatDigitOptions>(
); } while (false);
    }
    // 21.a.vi Set intlObj.[[MinimumFractionDigits]] to mnfd.
    digit_options.minimum_fraction_digits = mnfd;
    // 21.a.vii Set intlObj.[[MaximumFractionDigits]] to mxfd.
    digit_options.maximum_fraction_digits = mxfd;
  } else {  // 17.b Else
    // 21.b.i Set intlObj.[[MinimumFractionDigits]] to mnfdDefault.
    digit_options.minimum_fraction_digits = mnfd_default;
    // 21.b.ii Set intlObj.[[MaximumFractionDigits]] to mxfdDefault.
    digit_options.maximum_fraction_digits = mxfd_default;
  }
}

// 22. If needSd or needFd, then
if (need_sd || need_fd) {
  // a. If roundingPriority is "morePrecision", then
  if (digit_options.rounding_priority == RoundingPriority::kMorePrecision) {
    // i. Set intlObj.[[RoundingType]] to morePrecision.
    digit_options.rounding_type = RoundingType::kMorePrecision;
    // b. Else if roundingPriority is "lessPrecision", then
  } else if (digit_options.rounding_priority ==
             RoundingPriority::kLessPrecision) {
    // i. Set intlObj.[[RoundingType]] to lessPrecision.
    digit_options.rounding_type = RoundingType::kLessPrecision;
    // c. Else if hasSd, then
  } else if (has_sd) {
    // i. Set intlObj.[[RoundingType]] to significantDigits.
    digit_options.rounding_type = RoundingType::kSignificantDigits;
    // d. Else,
  } else {
    // i.Set intlObj.[[RoundingType]] to fractionDigits.
    digit_options.rounding_type = RoundingType::kFractionDigits;
  }
  // 23. Else
} else {
  // a. Set intlObj.[[RoundingType]] to morePrecision.
  digit_options.rounding_type = RoundingType::kMorePrecision;
  // b. Set intlObj.[[MinimumFractionDigits]] to 0.
  digit_options.minimum_fraction_digits = 0;
  // c. Set intlObj.[[MaximumFractionDigits]] to 0.
  digit_options.maximum_fraction_digits = 0;
  // d. Set intlObj.[[MinimumSignificantDigits]] to 1.
  digit_options.minimum_significant_digits = 1;
  // e. Set intlObj.[[MaximumSignificantDigits]] to 2.
  digit_options.maximum_significant_digits = 2;
}
return Just(digit_options);
1715}

1717namespace {

1719// ecma402/#sec-bestavailablelocale
1720std::string BestAvailableLocale(const std::set<std::string>& available_locales,
                              const std::string& locale) {
// 1. Let candidate be locale.
std::string candidate = locale;

// 2. Repeat,
while (true) {
  // 2.a. If availableLocales contains an element equal to candidate, return
  //      candidate.
  if (available_locales.find(candidate) != available_locales.end()) {
    return candidate;
  }

  // 2.b. Let pos be the character index of the last occurrence of "-"
  //      (U+002D) within candidate. If that character does not occur, return
  //      undefined.
  size_t pos = candidate.rfind('-');
  if (pos == std::string::npos) {
    return std::string();
  }

  // 2.c. If pos ≥ 2 and the character "-" occurs at index pos-2 of candidate,
  //      decrease pos by 2.
  if (pos >= 2 && candidate[pos - 2] == '-') {
    pos -= 2;
  }

  // 2.d. Let candidate be the substring of candidate from position 0,
  //      inclusive, to position pos, exclusive.
  candidate = candidate.substr(0, pos);
}
1751}

1753struct ParsedLocale {
std::string no_extensions_locale;
std::string extension;
1756};

1758// Returns a struct containing a bcp47 tag without unicode extensions
1759// and the removed unicode extensions.
1760//
1761// For example, given 'en-US-u-co-emoji' returns 'en-US' and
1762// 'u-co-emoji'.
1763ParsedLocale ParseBCP47Locale(const std::string& locale) {
size_t length = locale.length();
ParsedLocale parsed_locale;

// Privateuse or grandfathered locales have no extension sequences.
if ((length > 1) && (locale[1] == '-')) {
  // Check to make sure that this really is a grandfathered or
  // privateuse extension. ICU can sometimes mess up the
  // canonicalization.
  DCHECK(locale[0] == 'x' || locale[0] == 'i')((void) 0);
  parsed_locale.no_extensions_locale = locale;
  return parsed_locale;
}

size_t unicode_extension_start = locale.find("-u-");

// No unicode extensions found.
if (unicode_extension_start == std::string::npos) {
  parsed_locale.no_extensions_locale = locale;
  return parsed_locale;
}

size_t private_extension_start = locale.find("-x-");

// Unicode extensions found within privateuse subtags don't count.
if (private_extension_start != std::string::npos &&
    private_extension_start < unicode_extension_start) {
  parsed_locale.no_extensions_locale = locale;
  return parsed_locale;
}

const std::string beginning = locale.substr(0, unicode_extension_start);
size_t unicode_extension_end = length;
DCHECK_GT(length, 2)((void) 0);

// Find the end of the extension production as per the bcp47 grammar
// by looking for '-' followed by 2 chars and then another '-'.
for (size_t i = unicode_extension_start + 1; i < length - 2; i++) {
  if (locale[i] != '-') continue;

  if (locale[i + 2] == '-') {
    unicode_extension_end = i;
    break;
  }

  i += 2;
}

const std::string end = locale.substr(unicode_extension_end);
parsed_locale.no_extensions_locale = beginning + end;
parsed_locale.extension = locale.substr(
    unicode_extension_start, unicode_extension_end - unicode_extension_start);
return parsed_locale;
1816}

1818// ecma402/#sec-lookupsupportedlocales
1819std::vector<std::string> LookupSupportedLocales(
  const std::set<std::string>& available_locales,
  const std::vector<std::string>& requested_locales) {
// 1. Let subset be a new empty List.
std::vector<std::string> subset;

// 2. For each element locale of requestedLocales in List order, do
for (const std::string& locale : requested_locales) {
  // 2. a. Let noExtensionsLocale be the String value that is locale
  //       with all Unicode locale extension sequences removed.
  std::string no_extension_locale =
      ParseBCP47Locale(locale).no_extensions_locale;

  // 2. b. Let availableLocale be
  //       BestAvailableLocale(availableLocales, noExtensionsLocale).
  std::string available_locale =
      BestAvailableLocale(available_locales, no_extension_locale);

  // 2. c. If availableLocale is not undefined, append locale to the
  //       end of subset.
  if (!available_locale.empty()) {
    subset.push_back(locale);
  }
}

// 3. Return subset.
return subset;
1846}

1848icu::LocaleMatcher BuildLocaleMatcher(
  Isolate* isolate, const std::set<std::string>& available_locales,
  UErrorCode* status) {
icu::Locale default_locale =
    icu::Locale::forLanguageTag(isolate->DefaultLocale(), *status);
icu::LocaleMatcher::Builder builder;
if (U_FAILURE(*status)) {
  return builder.build(*status);
}
builder.setDefaultLocale(&default_locale);
for (auto it = available_locales.begin(); it != available_locales.end();
     ++it) {
  *status = U_ZERO_ERROR;
  icu::Locale l = icu::Locale::forLanguageTag(it->c_str(), *status);
  // skip invalid locale such as no-NO-NY
  if (U_SUCCESS(*status)) {
    builder.addSupportedLocale(l);
  }
}
return builder.build(*status);
1868}

1870class Iterator : public icu::Locale::Iterator {
public:
Iterator(std::vector<std::string>::const_iterator begin,
         std::vector<std::string>::const_iterator end)
    : iter_(begin), end_(end) {}
~Iterator() override = default;

UBool hasNext() const override { return iter_ != end_; }

const icu::Locale& next() override {
  UErrorCode status = U_ZERO_ERROR;
  locale_ = icu::Locale::forLanguageTag(iter_->c_str(), status);
  DCHECK(U_SUCCESS(status))((void) 0);
  ++iter_;
  return locale_;
}

private:
std::vector<std::string>::const_iterator iter_;
std::vector<std::string>::const_iterator end_;
icu::Locale locale_;
1891};

1893// ecma402/#sec-bestfitmatcher
1894// The BestFitMatcher abstract operation compares requestedLocales, which must
1895// be a List as returned by CanonicalizeLocaleList, against the locales in
1896// availableLocales and determines the best available language to meet the
1897// request. The algorithm is implementation dependent, but should produce
1898// results that a typical user of the requested locales would perceive
1899// as at least as good as those produced by the LookupMatcher abstract
1900// operation. Options specified through Unicode locale extension sequences must
1901// be ignored by the algorithm. Information about such subsequences is returned
1902// separately. The abstract operation returns a record with a [[locale]] field,
1903// whose value is the language tag of the selected locale, which must be an
1904// element of availableLocales. If the language tag of the request locale that
1905// led to the selected locale contained a Unicode locale extension sequence,
1906// then the returned record also contains an [[extension]] field whose value is
1907// the first Unicode locale extension sequence within the request locale
1908// language tag.
1909std::string BestFitMatcher(Isolate* isolate,
                         const std::set<std::string>& available_locales,
                         const std::vector<std::string>& requested_locales) {
UErrorCode status = U_ZERO_ERROR;
Iterator iter(requested_locales.cbegin(), requested_locales.cend());
std::string bestfit = BuildLocaleMatcher(isolate, available_locales, &status)
                          .getBestMatchResult(iter, status)
                          .makeResolvedLocale(status)
                          .toLanguageTag<std::string>(status);
DCHECK(U_SUCCESS(status))((void) 0);
return bestfit;
1920}

1922// ECMA 402 9.2.8 BestFitSupportedLocales(availableLocales, requestedLocales)
1923// https://tc39.github.io/ecma402/#sec-bestfitsupportedlocales
1924std::vector<std::string> BestFitSupportedLocales(
  Isolate* isolate, const std::set<std::string>& available_locales,
  const std::vector<std::string>& requested_locales) {
UErrorCode status = U_ZERO_ERROR;
icu::LocaleMatcher matcher =
    BuildLocaleMatcher(isolate, available_locales, &status);
std::vector<std::string> result;
if (U_SUCCESS(status)) {
  for (auto it = requested_locales.cbegin(); it != requested_locales.cend();
       it++) {
    status = U_ZERO_ERROR;
    icu::Locale desired = icu::Locale::forLanguageTag(it->c_str(), status);
    icu::LocaleMatcher::Result matched =
        matcher.getBestMatchResult(desired, status);
    if (U_FAILURE(status)) continue;
    if (matched.getSupportedIndex() < 0) continue;

    // The BestFitSupportedLocales abstract operation returns the *SUBSET* of
    // the provided BCP 47 language priority list requestedLocales for which
    // availableLocales has a matching locale when using the Best Fit Matcher
    // algorithm. Locales appear in the same order in the returned list as in
    // requestedLocales. The steps taken are implementation dependent.
    std::string bestfit = desired.toLanguageTag<std::string>(status);
    if (U_FAILURE(status)) continue;
    result.push_back(bestfit);
  }
}
return result;
1952}

1954// ecma262 #sec-createarrayfromlist
1955MaybeHandle<JSArray> CreateArrayFromList(Isolate* isolate,
                                       std::vector<std::string> elements,
                                       PropertyAttributes attr) {
Factory* factory = isolate->factory();
// Let array be ! ArrayCreate(0).
Handle<JSArray> array = factory->NewJSArray(0);

uint32_t length = static_cast<uint32_t>(elements.size());
// 3. Let n be 0.
// 4. For each element e of elements, do
for (uint32_t i = 0; i < length; i++) {
  // a. Let status be CreateDataProperty(array, ! ToString(n), e).
  const std::string& part = elements[i];
  Handle<String> value =
      factory->NewStringFromUtf8(base::CStrVector(part.c_str()))
          .ToHandleChecked();
  MAYBE_RETURN(JSObject::AddDataElement(array, i, value, attr),do { if ((JSObject::AddDataElement(array, i, value, attr)).IsNothing
()) return MaybeHandle<JSArray>(); } while (false)
               MaybeHandle<JSArray>())do { if ((JSObject::AddDataElement(array, i, value, attr)).IsNothing
()) return MaybeHandle<JSArray>(); } while (false);
}
// 5. Return array.
return MaybeHandle<JSArray>(array);
1976}

1978// ECMA 402 9.2.9 SupportedLocales(availableLocales, requestedLocales, options)
1979// https://tc39.github.io/ecma402/#sec-supportedlocales
1980MaybeHandle<JSObject> SupportedLocales(
  Isolate* isolate, const char* method_name,
  const std::set<std::string>& available_locales,
  const std::vector<std::string>& requested_locales, Handle<Object> options) {
std::vector<std::string> supported_locales;

// 1. Set options to ? CoerceOptionsToObject(options).
Handle<JSReceiver> options_obj;
ASSIGN_RETURN_ON_EXCEPTION(do { if (!(CoerceOptionsToObject(isolate, options, method_name
)).ToHandle(&options_obj)) { ((void) 0); return MaybeHandle
<JSObject>(); } } while (false)
    isolate, options_obj,do { if (!(CoerceOptionsToObject(isolate, options, method_name
)).ToHandle(&options_obj)) { ((void) 0); return MaybeHandle
<JSObject>(); } } while (false)
    CoerceOptionsToObject(isolate, options, method_name), JSObject)do { if (!(CoerceOptionsToObject(isolate, options, method_name
)).ToHandle(&options_obj)) { ((void) 0); return MaybeHandle
<JSObject>(); } } while (false);

// 2. Let matcher be ? GetOption(options, "localeMatcher", "string",
//       « "lookup", "best fit" », "best fit").
Maybe<Intl::MatcherOption> maybe_locale_matcher =
    Intl::GetLocaleMatcher(isolate, options_obj, method_name);
MAYBE_RETURN(maybe_locale_matcher, MaybeHandle<JSObject>())do { if ((maybe_locale_matcher).IsNothing()) return MaybeHandle
<JSObject>(); } while (false);
Intl::MatcherOption matcher = maybe_locale_matcher.FromJust();

// 3. If matcher is "best fit", then
//    a. Let supportedLocales be BestFitSupportedLocales(availableLocales,
//       requestedLocales).
if (matcher == Intl::MatcherOption::kBestFit &&
    FLAG_harmony_intl_best_fit_matcher) {
  supported_locales =
      BestFitSupportedLocales(isolate, available_locales, requested_locales);
} else {
  // 4. Else,
  //    a. Let supportedLocales be LookupSupportedLocales(availableLocales,
  //       requestedLocales).
  supported_locales =
      LookupSupportedLocales(available_locales, requested_locales);
}

// 5. Return CreateArrayFromList(supportedLocales).
return CreateArrayFromList(isolate, supported_locales,
                           PropertyAttributes::NONE);
2017}

2019}  // namespace

2021// ecma-402 #sec-intl.getcanonicallocales
2022MaybeHandle<JSArray> Intl::GetCanonicalLocales(Isolate* isolate,
                                             Handle<Object> locales) {
// 1. Let ll be ? CanonicalizeLocaleList(locales).
Maybe<std::vector<std::string>> maybe_ll =
    CanonicalizeLocaleList(isolate, locales, false);
MAYBE_RETURN(maybe_ll, MaybeHandle<JSArray>())do { if ((maybe_ll).IsNothing()) return MaybeHandle<JSArray
>(); } while (false);

// 2. Return CreateArrayFromList(ll).
return CreateArrayFromList(isolate, maybe_ll.FromJust(),
                           PropertyAttributes::NONE);
2032}

2034namespace {

2036MaybeHandle<JSArray> AvailableCollations(Isolate* isolate) {
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::StringEnumeration> enumeration(
    icu::Collator::getKeywordValues("collation", status));
if (U_FAILURE(status)) {
  THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false)
                  JSArray)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false);
}
return Intl::ToJSArray(isolate, "co", enumeration.get(),
                       Intl::RemoveCollation, true);
2046}

2048MaybeHandle<JSArray> VectorToJSArray(Isolate* isolate,
                                   const std::vector<std::string>& array) {
Factory* factory = isolate->factory();
Handle<FixedArray> fixed_array =
    factory->NewFixedArray(static_cast<int32_t>(array.size()));
int32_t index = 0;
for (std::string item : array) {
  Handle<String> str = factory->NewStringFromAsciiChecked(item.c_str());
  fixed_array->set(index++, *str);
}
return factory->NewJSArrayWithElements(fixed_array);
2059}

2061namespace {

2063class ResourceAvailableCurrencies {
public:
ResourceAvailableCurrencies() {
  UErrorCode status = U_ZERO_ERROR;
  UEnumeration* uenum =
      ucurr_openISOCurrenciesucurr_openISOCurrencies_71(UCURR_COMMON | UCURR_NON_DEPRECATED, &status);
  DCHECK(U_SUCCESS(status))((void) 0);
  const char* next = nullptr;
  while (U_SUCCESS(status) &&
         (next = uenum_nextuenum_next_71(uenum, nullptr, &status)) != nullptr) {
    // Work around the issue that we do not support VEF currency code
    // in DisplayNames by not reporting it.
    if (strcmp(next, "VEF") == 0) continue;
    AddIfAvailable(next);
  }
  // Work around the issue that we do support the following currency codes
  // in DisplayNames but the ICU API is not reporting it.
  AddIfAvailable("SVC");
  AddIfAvailable("XDR");
  AddIfAvailable("XSU");
  AddIfAvailable("ZWL");
  std::sort(list_.begin(), list_.end());
  uenum_closeuenum_close_71(uenum);
}

const std::vector<std::string>& Get() const { return list_; }

void AddIfAvailable(const char* currency) {
  icu::UnicodeString code(currency, -1, US_INVicu::UnicodeString::kInvariant);
  UErrorCode status = U_ZERO_ERROR;
  int32_t len = 0;
  const UChar* result =
      ucurr_getNameucurr_getName_71(code.getTerminatedBuffer(), "en", UCURR_LONG_NAME,
                    nullptr, &len, &status);
  if (U_SUCCESS(status) &&
      u_strcmpu_strcmp_71(result, code.getTerminatedBuffer()) != 0) {
    list_.push_back(currency);
  }
}

private:
std::vector<std::string> list_;
2105};

2107const std::vector<std::string>& GetAvailableCurrencies() {
static base::LazyInstance<ResourceAvailableCurrencies>::type
    available_currencies = LAZY_INSTANCE_INITIALIZER{ { 0 }, { {} } };
return available_currencies.Pointer()->Get();
2111}
2112}  // namespace

2114MaybeHandle<JSArray> AvailableCurrencies(Isolate* isolate) {
return VectorToJSArray(isolate, GetAvailableCurrencies());
2116}

2118MaybeHandle<JSArray> AvailableNumberingSystems(Isolate* isolate) {
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::StringEnumeration> enumeration(
    icu::NumberingSystem::getAvailableNames(status));
if (U_FAILURE(status)) {
  THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false)
                  JSArray)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false);
}
// Need to filter out isAlgorithmic
return Intl::ToJSArray(
    isolate, "nu", enumeration.get(),
    [](const char* value) {
      UErrorCode status = U_ZERO_ERROR;
      std::unique_ptr<icu::NumberingSystem> numbering_system(
          icu::NumberingSystem::createInstanceByName(value, status));
      // Skip algorithmic one since chrome filter out the resource.
      return U_FAILURE(status) || numbering_system->isAlgorithmic();
    },
    true);
2137}

2139MaybeHandle<JSArray> AvailableTimeZones(Isolate* isolate) {
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::StringEnumeration> enumeration(
    icu::TimeZone::createTimeZoneIDEnumeration(
        UCAL_ZONE_TYPE_CANONICAL_LOCATION, nullptr, nullptr, status));
if (U_FAILURE(status)) {
  THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false)
                  JSArray)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kIcuError)); } while (false);
}
return Intl::ToJSArray(isolate, nullptr, enumeration.get(), nullptr, true);
2149}

2151MaybeHandle<JSArray> AvailableUnits(Isolate* isolate) {
Factory* factory = isolate->factory();
std::set<std::string> sanctioned(Intl::SanctionedSimpleUnits());
Handle<FixedArray> fixed_array =
    factory->NewFixedArray(static_cast<int32_t>(sanctioned.size()));
int32_t index = 0;
for (std::string item : sanctioned) {
  Handle<String> str = factory->NewStringFromAsciiChecked(item.c_str());
  fixed_array->set(index++, *str);
}
return factory->NewJSArrayWithElements(fixed_array);
2162}

2164}  // namespace

2166// ecma-402 #sec-intl.supportedvaluesof
2167MaybeHandle<JSArray> Intl::SupportedValuesOf(Isolate* isolate,
                                           Handle<Object> key_obj) {
Factory* factory = isolate->factory();
// 1. 1. Let key be ? ToString(key).
Handle<String> key_str;
ASSIGN_RETURN_ON_EXCEPTION(isolate, key_str,do { if (!(Object::ToString(isolate, key_obj)).ToHandle(&
key_str)) { ((void) 0); return MaybeHandle<JSArray>(); }
 } while (false)
                           Object::ToString(isolate, key_obj), JSArray)do { if (!(Object::ToString(isolate, key_obj)).ToHandle(&
key_str)) { ((void) 0); return MaybeHandle<JSArray>(); }
 } while (false);
// 2. If key is "calendar", then
if (factory->calendar_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableCalendars( ).
  return Intl::AvailableCalendars(isolate);
}
// 3. Else if key is "collation", then
if (factory->collation_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableCollations( ).
  return AvailableCollations(isolate);
}
// 4. Else if key is "currency", then
if (factory->currency_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableCurrencies( ).
  return AvailableCurrencies(isolate);
}
// 5. Else if key is "numberingSystem", then
if (factory->numberingSystem_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableNumberingSystems( ).
  return AvailableNumberingSystems(isolate);
}
// 6. Else if key is "timeZone", then
if (factory->timeZone_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableTimeZones( ).
  return AvailableTimeZones(isolate);
}
// 7. Else if key is "unit", then
if (factory->unit_string()->Equals(*key_str)) {
  // a. Let list be ! AvailableUnits( ).
  return AvailableUnits(isolate);
}
// 8. Else,
// a. Throw a RangeError exception.
// 9. Return ! CreateArrayFromList( list ).

THROW_NEW_ERROR(do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kInvalid, factory->NewStringFromStaticChars
("key"), key_str)); } while (false)
    isolate,do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kInvalid, factory->NewStringFromStaticChars
("key"), key_str)); } while (false)
    NewRangeError(MessageTemplate::kInvalid,do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kInvalid, factory->NewStringFromStaticChars
("key"), key_str)); } while (false)
                  factory->NewStringFromStaticChars("key"), key_str),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kInvalid, factory->NewStringFromStaticChars
("key"), key_str)); } while (false)
    JSArray)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<JSArray>(__isolate__->factory()->NewRangeError
(MessageTemplate::kInvalid, factory->NewStringFromStaticChars
("key"), key_str)); } while (false);
2213}

2215// ECMA 402 Intl.*.supportedLocalesOf
2216MaybeHandle<JSObject> Intl::SupportedLocalesOf(
  Isolate* isolate, const char* method_name,
  const std::set<std::string>& available_locales, Handle<Object> locales,
  Handle<Object> options) {
// Let availableLocales be %Collator%.[[AvailableLocales]].

// Let requestedLocales be ? CanonicalizeLocaleList(locales).
Maybe<std::vector<std::string>> requested_locales =
    CanonicalizeLocaleList(isolate, locales, false);
MAYBE_RETURN(requested_locales, MaybeHandle<JSObject>())do { if ((requested_locales).IsNothing()) return MaybeHandle<
JSObject>(); } while (false);

// Return ? SupportedLocales(availableLocales, requestedLocales, options).
return SupportedLocales(isolate, method_name, available_locales,
                        requested_locales.FromJust(), options);
2230}

2232namespace {

2234template <typename T>
2235bool IsValidExtension(const icu::Locale& locale, const char* key,
                    const std::string& value) {
const char* legacy_type = uloc_toLegacyTypeuloc_toLegacyType_71(key, value.c_str());
if (legacy_type == nullptr) {
  return false;
}
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::StringEnumeration> enumeration(
    T::getKeywordValuesForLocale(key, icu::Locale(locale.getBaseName()),
                                 false, status));
if (U_FAILURE(status)) {
  return false;
}
int32_t length;
for (const char* item = enumeration->next(&length, status);
     U_SUCCESS(status) && item != nullptr;
     item = enumeration->next(&length, status)) {
  if (strcmp(legacy_type, item) == 0) {
    return true;
  }
}
return false;
2257}

2259}  // namespace

2261bool Intl::IsValidCollation(const icu::Locale& locale,
                          const std::string& value) {
std::set<std::string> invalid_values = {"standard", "search"};
if (invalid_values.find(value) != invalid_values.end()) return false;
return IsValidExtension<icu::Collator>(locale, "collation", value);
2266}

2268bool Intl::IsWellFormedCalendar(const std::string& value) {
return JSLocale::Is38AlphaNumList(value);
2270}

2272// ecma402/#sec-iswellformedcurrencycode
2273bool Intl::IsWellFormedCurrency(const std::string& currency) {
return JSLocale::Is3Alpha(currency);
2275}

2277bool Intl::IsValidCalendar(const icu::Locale& locale,
                         const std::string& value) {
return IsValidExtension<icu::Calendar>(locale, "calendar", value);
2280}

2282bool Intl::IsValidNumberingSystem(const std::string& value) {
std::set<std::string> invalid_values = {"native", "traditio", "finance"};
if (invalid_values.find(value) != invalid_values.end()) return false;
UErrorCode status = U_ZERO_ERROR;
std::unique_ptr<icu::NumberingSystem> numbering_system(
    icu::NumberingSystem::createInstanceByName(value.c_str(), status));
return U_SUCCESS(status) && numbering_system.get() != nullptr &&
       !numbering_system->isAlgorithmic();
2290}

2292namespace {

2294bool IsWellFormedNumberingSystem(const std::string& value) {
return JSLocale::Is38AlphaNumList(value);
2296}

2298std::map<std::string, std::string> LookupAndValidateUnicodeExtensions(
  icu::Locale* icu_locale, const std::set<std::string>& relevant_keys) {
std::map<std::string, std::string> extensions;

UErrorCode status = U_ZERO_ERROR;
icu::LocaleBuilder builder;
builder.setLocale(*icu_locale).clearExtensions();
std::unique_ptr<icu::StringEnumeration> keywords(
    icu_locale->createKeywords(status));
if (U_FAILURE(status)) return extensions;

if (!keywords) return extensions;
char value[ULOC_FULLNAME_CAPACITY157];

int32_t length;
status = U_ZERO_ERROR;
for (const char* keyword = keywords->next(&length, status);
     keyword != nullptr; keyword = keywords->next(&length, status)) {
  // Ignore failures in ICU and skip to the next keyword.
  //
  // This is fine.™
  if (U_FAILURE(status)) {
    status = U_ZERO_ERROR;
    continue;
  }

  icu_locale->getKeywordValue(keyword, value, ULOC_FULLNAME_CAPACITY157, status);

  // Ignore failures in ICU and skip to the next keyword.
  //
  // This is fine.™
  if (U_FAILURE(status)) {
    status = U_ZERO_ERROR;
    continue;
  }

  const char* bcp47_key = uloc_toUnicodeLocaleKeyuloc_toUnicodeLocaleKey_71(keyword);

  if (bcp47_key && (relevant_keys.find(bcp47_key) != relevant_keys.end())) {
    const char* bcp47_value = uloc_toUnicodeLocaleTypeuloc_toUnicodeLocaleType_71(bcp47_key, value);
    bool is_valid_value = false;
    // 8.h.ii.1.a If keyLocaleData contains requestedValue, then
    if (strcmp("ca", bcp47_key) == 0) {
      is_valid_value = Intl::IsValidCalendar(*icu_locale, bcp47_value);
    } else if (strcmp("co", bcp47_key) == 0) {
      is_valid_value = Intl::IsValidCollation(*icu_locale, bcp47_value);
    } else if (strcmp("hc", bcp47_key) == 0) {
      // https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml
      std::set<std::string> valid_values = {"h11", "h12", "h23", "h24"};
      is_valid_value = valid_values.find(bcp47_value) != valid_values.end();
    } else if (strcmp("lb", bcp47_key) == 0) {
      // https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/segmentation.xml
      std::set<std::string> valid_values = {"strict", "normal", "loose"};
      is_valid_value = valid_values.find(bcp47_value) != valid_values.end();
    } else if (strcmp("kn", bcp47_key) == 0) {
      // https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/collation.xml
      std::set<std::string> valid_values = {"true", "false"};
      is_valid_value = valid_values.find(bcp47_value) != valid_values.end();
    } else if (strcmp("kf", bcp47_key) == 0) {
      // https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/collation.xml
      std::set<std::string> valid_values = {"upper", "lower", "false"};
      is_valid_value = valid_values.find(bcp47_value) != valid_values.end();
    } else if (strcmp("nu", bcp47_key) == 0) {
      is_valid_value = Intl::IsValidNumberingSystem(bcp47_value);
    }
    if (is_valid_value) {
      extensions.insert(
          std::pair<std::string, std::string>(bcp47_key, bcp47_value));
      builder.setUnicodeLocaleKeyword(bcp47_key, bcp47_value);
    }
  }
}

status = U_ZERO_ERROR;
*icu_locale = builder.build(status);

return extensions;
2375}

2377// ecma402/#sec-lookupmatcher
2378std::string LookupMatcher(Isolate* isolate,
                        const std::set<std::string>& available_locales,
                        const std::vector<std::string>& requested_locales) {
// 1. Let result be a new Record.
std::string result;

// 2. For each element locale of requestedLocales in List order, do
for (const std::string& locale : requested_locales) {
  // 2. a. Let noExtensionsLocale be the String value that is locale
  //       with all Unicode locale extension sequences removed.
  ParsedLocale parsed_locale = ParseBCP47Locale(locale);
  std::string no_extensions_locale = parsed_locale.no_extensions_locale;

  // 2. b. Let availableLocale be
  //       BestAvailableLocale(availableLocales, noExtensionsLocale).
  std::string available_locale =
      BestAvailableLocale(available_locales, no_extensions_locale);

  // 2. c. If availableLocale is not undefined, append locale to the
  //       end of subset.
  if (!available_locale.empty()) {
    // Note: The following steps are not performed here because we
    // can use ICU to parse the unicode locale extension sequence
    // as part of Intl::ResolveLocale.
    //
    // There's no need to separate the unicode locale extensions
    // right here. Instead just return the available locale with the
    // extensions.
    //
    // 2. c. i. Set result.[[locale]] to availableLocale.
    // 2. c. ii. If locale and noExtensionsLocale are not the same
    // String value, then
    // 2. c. ii. 1. Let extension be the String value consisting of
    // the first substring of locale that is a Unicode locale
    // extension sequence.
    // 2. c. ii. 2. Set result.[[extension]] to extension.
    // 2. c. iii. Return result.
    return available_locale + parsed_locale.extension;
  }
}

// 3. Let defLocale be DefaultLocale();
// 4. Set result.[[locale]] to defLocale.
// 5. Return result.
return isolate->DefaultLocale();
2423}

2425}  // namespace

2427// This function doesn't correspond exactly with the spec. Instead
2428// we use ICU to do all the string manipulations that the spec
2429// peforms.
2430//
2431// The spec uses this function to normalize values for various
2432// relevant extension keys (such as disallowing "search" for
2433// collation). Instead of doing this here, we let the callers of
2434// this method perform such normalization.
2435//
2436// ecma402/#sec-resolvelocale
2437Maybe<Intl::ResolvedLocale> Intl::ResolveLocale(
  Isolate* isolate, const std::set<std::string>& available_locales,
  const std::vector<std::string>& requested_locales, MatcherOption matcher,
  const std::set<std::string>& relevant_extension_keys) {
std::string locale;
if (matcher == Intl::MatcherOption::kBestFit &&
    FLAG_harmony_intl_best_fit_matcher) {
  locale = BestFitMatcher(isolate, available_locales, requested_locales);
} else {
  locale = LookupMatcher(isolate, available_locales, requested_locales);
}

Maybe<icu::Locale> maybe_icu_locale = CreateICULocale(locale);
MAYBE_RETURN(maybe_icu_locale, Nothing<Intl::ResolvedLocale>())do { if ((maybe_icu_locale).IsNothing()) return Nothing<Intl
::ResolvedLocale>(); } while (false);
icu::Locale icu_locale = maybe_icu_locale.FromJust();
std::map<std::string, std::string> extensions =
    LookupAndValidateUnicodeExtensions(&icu_locale, relevant_extension_keys);

std::string canonicalized_locale = Intl::ToLanguageTag(icu_locale).FromJust();

// TODO(gsathya): Remove privateuse subtags from extensions.

return Just(
    Intl::ResolvedLocale{canonicalized_locale, icu_locale, extensions});
2461}

2463Handle<Managed<icu::UnicodeString>> Intl::SetTextToBreakIterator(
  Isolate* isolate, Handle<String> text, icu::BreakIterator* break_iterator) {
text = String::Flatten(isolate, text);
icu::UnicodeString* u_text = static_cast<icu::UnicodeString*>(
    Intl::ToICUUnicodeString(isolate, text).clone());

Handle<Managed<icu::UnicodeString>> new_u_text =
    Managed<icu::UnicodeString>::FromRawPtr(isolate, 0, u_text);

break_iterator->setText(*u_text);
return new_u_text;
2474}

2476// ecma262 #sec-string.prototype.normalize
2477MaybeHandle<String> Intl::Normalize(Isolate* isolate, Handle<String> string,
                                  Handle<Object> form_input) {
const char* form_name;
UNormalization2Mode form_mode;
if (form_input->IsUndefined(isolate)) {
  // default is FNC
  form_name = "nfc";
  form_mode = UNORM2_COMPOSE;
} else {
  Handle<String> form;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, form,do { if (!(Object::ToString(isolate, form_input)).ToHandle(&
form)) { ((void) 0); return MaybeHandle<String>(); } } while
 (false)
                             Object::ToString(isolate, form_input), String)do { if (!(Object::ToString(isolate, form_input)).ToHandle(&
form)) { ((void) 0); return MaybeHandle<String>(); } } while
 (false);

  if (String::Equals(isolate, form, isolate->factory()->NFC_string())) {
    form_name = "nfc";
    form_mode = UNORM2_COMPOSE;
  } else if (String::Equals(isolate, form,
                            isolate->factory()->NFD_string())) {
    form_name = "nfc";
    form_mode = UNORM2_DECOMPOSE;
  } else if (String::Equals(isolate, form,
                            isolate->factory()->NFKC_string())) {
    form_name = "nfkc";
    form_mode = UNORM2_COMPOSE;
  } else if (String::Equals(isolate, form,
                            isolate->factory()->NFKD_string())) {
    form_name = "nfkc";
    form_mode = UNORM2_DECOMPOSE;
  } else {
    Handle<String> valid_forms =
        isolate->factory()->NewStringFromStaticChars("NFC, NFD, NFKC, NFKD");
    THROW_NEW_ERROR(do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewRangeError
(MessageTemplate::kNormalizationForm, valid_forms)); } while (
false)
        isolate,do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewRangeError
(MessageTemplate::kNormalizationForm, valid_forms)); } while (
false)
        NewRangeError(MessageTemplate::kNormalizationForm, valid_forms),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewRangeError
(MessageTemplate::kNormalizationForm, valid_forms)); } while (
false)
        String)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewRangeError
(MessageTemplate::kNormalizationForm, valid_forms)); } while (
false);
  }
}

int length = string->length();
string = String::Flatten(isolate, string);
icu::UnicodeString result;
std::unique_ptr<base::uc16[]> sap;
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString input = ToICUUnicodeString(isolate, string);
// Getting a singleton. Should not free it.
const icu::Normalizer2* normalizer =
    icu::Normalizer2::getInstance(nullptr, form_name, form_mode, status);
DCHECK(U_SUCCESS(status))((void) 0);
DCHECK_NOT_NULL(normalizer)((void) 0);
int32_t normalized_prefix_length =
    normalizer->spanQuickCheckYes(input, status);
// Quick return if the input is already normalized.
if (length == normalized_prefix_length) return string;
icu::UnicodeString unnormalized =
    input.tempSubString(normalized_prefix_length);
// Read-only alias of the normalized prefix.
result.setTo(false, input.getBuffer(), normalized_prefix_length);
// copy-on-write; normalize the suffix and append to |result|.
normalizer->normalizeSecondAndAppend(result, unnormalized, status);

if (U_FAILURE(status)) {
  THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), String)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewTypeError
(MessageTemplate::kIcuError)); } while (false);
}

return Intl::ToString(isolate, result);
2542}

2544// ICUTimezoneCache calls out to ICU for TimezoneCache
2545// functionality in a straightforward way.
2546class ICUTimezoneCache : public base::TimezoneCache {
public:
ICUTimezoneCache() : timezone_(nullptr) { Clear(TimeZoneDetection::kSkip); }

~ICUTimezoneCache() override { Clear(TimeZoneDetection::kSkip); }

const char* LocalTimezone(double time_ms) override;

double DaylightSavingsOffset(double time_ms) override;

double LocalTimeOffset(double time_ms, bool is_utc) override;

void Clear(TimeZoneDetection time_zone_detection) override;

private:
icu::TimeZone* GetTimeZone();

bool GetOffsets(double time_ms, bool is_utc, int32_t* raw_offset,
                int32_t* dst_offset);

icu::TimeZone* timezone_;

std::string timezone_name_;
std::string dst_timezone_name_;
2570};

2572const char* ICUTimezoneCache::LocalTimezone(double time_ms) {
bool is_dst = DaylightSavingsOffset(time_ms) != 0;
std::string* name = is_dst ? &dst_timezone_name_ : &timezone_name_;
if (name->empty()) {
  icu::UnicodeString result;
  GetTimeZone()->getDisplayName(is_dst, icu::TimeZone::LONG, result);
  result += '\0';

  icu::StringByteSink<std::string> byte_sink(name);
  result.toUTF8(byte_sink);
}
DCHECK(!name->empty())((void) 0);
return name->c_str();
2585}

2587icu::TimeZone* ICUTimezoneCache::GetTimeZone() {
if (timezone_ == nullptr) {
  timezone_ = icu::TimeZone::createDefault();
}
return timezone_;
2592}

2594bool ICUTimezoneCache::GetOffsets(double time_ms, bool is_utc,
                                int32_t* raw_offset, int32_t* dst_offset) {
UErrorCode status = U_ZERO_ERROR;
if (is_utc) {
  GetTimeZone()->getOffset(time_ms, false, *raw_offset, *dst_offset, status);
} else {
  // Note that casting TimeZone to BasicTimeZone is safe because we know that
  // icu::TimeZone used here is a BasicTimeZone.
  static_cast<const icu::BasicTimeZone*>(GetTimeZone())
      ->getOffsetFromLocal(time_ms, UCAL_TZ_LOCAL_FORMER,
                           UCAL_TZ_LOCAL_FORMER, *raw_offset, *dst_offset,
                           status);
}

return U_SUCCESS(status);
2609}

2611double ICUTimezoneCache::DaylightSavingsOffset(double time_ms) {
int32_t raw_offset, dst_offset;
if (!GetOffsets(time_ms, true, &raw_offset, &dst_offset)) return 0;
return dst_offset;
2615}

2617double ICUTimezoneCache::LocalTimeOffset(double time_ms, bool is_utc) {
int32_t raw_offset, dst_offset;
if (!GetOffsets(time_ms, is_utc, &raw_offset, &dst_offset)) return 0;
return raw_offset + dst_offset;
2621}

2623void ICUTimezoneCache::Clear(TimeZoneDetection time_zone_detection) {
delete timezone_;
timezone_ = nullptr;
timezone_name_.clear();
dst_timezone_name_.clear();
if (time_zone_detection == TimeZoneDetection::kRedetect) {
  icu::TimeZone::adoptDefault(icu::TimeZone::detectHostTimeZone());
}
2631}

2633base::TimezoneCache* Intl::CreateTimeZoneCache() {
return FLAG_icu_timezone_data ? new ICUTimezoneCache()
                              : base::OS::CreateTimezoneCache();
2636}

2638Maybe<Intl::MatcherOption> Intl::GetLocaleMatcher(Isolate* isolate,
                                                Handle<JSReceiver> options,
                                                const char* method_name) {
return GetStringOption<Intl::MatcherOption>(
    isolate, options, "localeMatcher", method_name, {"best fit", "lookup"},
    {Intl::MatcherOption::kBestFit, Intl::MatcherOption::kLookup},
    Intl::MatcherOption::kBestFit);
2645}

2647Maybe<bool> Intl::GetNumberingSystem(Isolate* isolate,
                                   Handle<JSReceiver> options,
                                   const char* method_name,
                                   std::unique_ptr<char[]>* result) {
const std::vector<const char*> empty_values = {};
Maybe<bool> maybe = GetStringOption(isolate, options, "numberingSystem",
                                    empty_values, method_name, result);
MAYBE_RETURN(maybe, Nothing<bool>())do { if ((maybe).IsNothing()) return Nothing<bool>(); }
 while (false);
if (maybe.FromJust() && *result != nullptr) {
  if (!IsWellFormedNumberingSystem(result->get())) {
    THROW_NEW_ERROR_RETURN_VALUE(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
        isolate,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
        NewRangeError(do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
            MessageTemplate::kInvalid,do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
            isolate->factory()->numberingSystem_string(),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
            isolate->factory()->NewStringFromAsciiChecked(result->get())),do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false)
        Nothing<bool>())do { auto* __isolate__ = (isolate); __isolate__->Throw(*__isolate__
->factory()->NewRangeError( MessageTemplate::kInvalid, isolate
->factory()->numberingSystem_string(), isolate->factory
()->NewStringFromAsciiChecked(result->get()))); return Nothing
<bool>(); } while (false);
  }
  return Just(true);
}
return Just(false);
2668}

2670const std::set<std::string>& Intl::GetAvailableLocales() {
static base::LazyInstance<Intl::AvailableLocales<>>::type available_locales =
    LAZY_INSTANCE_INITIALIZER{ { 0 }, { {} } };
return available_locales.Pointer()->Get();
2674}

2676namespace {

2678struct CheckCalendar {
static const char* key() { return "calendar"; }
static const char* path() { return nullptr; }
2681};

2683}  // namespace

2685const std::set<std::string>& Intl::GetAvailableLocalesForDateFormat() {
static base::LazyInstance<Intl::AvailableLocales<CheckCalendar>>::type
    available_locales = LAZY_INSTANCE_INITIALIZER{ { 0 }, { {} } };
return available_locales.Pointer()->Get();
2689}

2691constexpr uint16_t kInfinityChar = 0x221e;

2693Handle<String> Intl::NumberFieldToType(Isolate* isolate,
                                     const NumberFormatSpan& part,
                                     const icu::UnicodeString& text,
                                     bool is_nan) {
switch (static_cast<UNumberFormatFields>(part.field_id)) {
  case UNUM_INTEGER_FIELD:
    if (is_nan) return isolate->factory()->nan_string();
    if (text.charAt(part.begin_pos) == kInfinityChar ||
        // en-US-POSIX output "INF" for Infinity
        (part.end_pos - part.begin_pos == 3 &&
         text.tempSubString(part.begin_pos, 3) == "INF")) {
      return isolate->factory()->infinity_string();
    }
    return isolate->factory()->integer_string();
  case UNUM_FRACTION_FIELD:
    return isolate->factory()->fraction_string();
  case UNUM_DECIMAL_SEPARATOR_FIELD:
    return isolate->factory()->decimal_string();
  case UNUM_GROUPING_SEPARATOR_FIELD:
    return isolate->factory()->group_string();
  case UNUM_CURRENCY_FIELD:
    return isolate->factory()->currency_string();
  case UNUM_PERCENT_FIELD:
    return isolate->factory()->percentSign_string();
  case UNUM_SIGN_FIELD:
    return (text.charAt(part.begin_pos) == '+')
               ? isolate->factory()->plusSign_string()
               : isolate->factory()->minusSign_string();
  case UNUM_EXPONENT_SYMBOL_FIELD:
    return isolate->factory()->exponentSeparator_string();

  case UNUM_EXPONENT_SIGN_FIELD:
    return isolate->factory()->exponentMinusSign_string();

  case UNUM_EXPONENT_FIELD:
    return isolate->factory()->exponentInteger_string();

  case UNUM_PERMILL_FIELD:
    // We're not creating any permill formatter, and it's not even clear how
    // that would be possible with the ICU API.
    UNREACHABLE()V8_Fatal("unreachable code");

  case UNUM_COMPACT_FIELD:
    return isolate->factory()->compact_string();
  case UNUM_MEASURE_UNIT_FIELD:
    return isolate->factory()->unit_string();

  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}
2743}

2745// A helper function to convert the FormattedValue for several Intl objects.
2746MaybeHandle<String> Intl::FormattedToString(
  Isolate* isolate, const icu::FormattedValue& formatted) {
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString result = formatted.toString(status);
if (U_FAILURE(status)) {
  THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), String)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<String>(__isolate__->factory()->NewTypeError
(MessageTemplate::kIcuError)); } while (false);
}
return Intl::ToString(isolate, result);
2754}

2756MaybeHandle<JSArray> Intl::ToJSArray(
  Isolate* isolate, const char* unicode_key,
  icu::StringEnumeration* enumeration,
  const std::function<bool(const char*)>& removes, bool sort) {
UErrorCode status = U_ZERO_ERROR;
std::vector<std::string> array;
for (const char* item = enumeration->next(nullptr, status);
     U_SUCCESS(status) && item != nullptr;
     item = enumeration->next(nullptr, status)) {
  if (unicode_key != nullptr) {
    item = uloc_toUnicodeLocaleTypeuloc_toUnicodeLocaleType_71(unicode_key, item);
  }
  if (removes == nullptr || !(removes)(item)) {
    array.push_back(item);
  }
}

if (sort) {
  std::sort(array.begin(), array.end());
}
return VectorToJSArray(isolate, array);
2777}

2779bool Intl::RemoveCollation(const char* collation) {
return strcmp("standard", collation) == 0 || strcmp("search", collation) == 0;
2781}

2783// See the list in ecma402 #sec-issanctionedsimpleunitidentifier
2784std::set<std::string> Intl::SanctionedSimpleUnits() {
return std::set<std::string>({"acre",       "bit",        "byte",
                              "celsius",    "centimeter", "day",
                              "degree",     "fahrenheit", "fluid-ounce",
                              "foot",       "gallon",     "gigabit",
                              "gigabyte",   "gram",       "hectare",
                              "hour",       "inch",       "kilobit",
                              "kilobyte",   "kilogram",   "kilometer",
                              "liter",      "megabit",    "megabyte",
                              "meter",      "mile",       "mile-scandinavian",
                              "millimeter", "milliliter", "millisecond",
                              "minute",     "month",      "ounce",
                              "percent",    "petabyte",   "pound",
                              "second",     "stone",      "terabit",
                              "terabyte",   "week",       "yard",
                              "year"});
2800}

2802// ecma-402/#sec-isvalidtimezonename

2804namespace {
2805bool IsUnicodeStringValidTimeZoneName(const icu::UnicodeString& id) {
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString canonical;
icu::TimeZone::getCanonicalID(id, canonical, status);
return U_SUCCESS(status) &&
       canonical != icu::UnicodeString("Etc/Unknown", -1, US_INVicu::UnicodeString::kInvariant);
2811}
2812}  // namespace

2814MaybeHandle<String> Intl::CanonicalizeTimeZoneName(Isolate* isolate,
                                                 Handle<String> identifier) {
UErrorCode status = U_ZERO_ERROR;
std::string time_zone =
    JSDateTimeFormat::CanonicalizeTimeZoneID(identifier->ToCString().get());
icu::UnicodeString time_zone_ustring =
    icu::UnicodeString(time_zone.c_str(), -1, US_INVicu::UnicodeString::kInvariant);
icu::UnicodeString canonical;
icu::TimeZone::getCanonicalID(time_zone_ustring, canonical, status);
CHECK(U_SUCCESS(status))do { if ((__builtin_expect(!!(!(U_SUCCESS(status))), 0))) { V8_Fatal
("Check failed: %s.", "U_SUCCESS(status)"); } } while (false);
if (canonical == UNICODE_STRING_SIMPLE("Etc/UTC")icu::UnicodeString(true, u"Etc/UTC", -1) ||
    canonical == UNICODE_STRING_SIMPLE("Etc/GMT")icu::UnicodeString(true, u"Etc/GMT", -1)) {
  return isolate->factory()->UTC_string();
}
return Intl::ToString(isolate, canonical);
2829}

2831bool Intl::IsValidTimeZoneName(Isolate* isolate, Handle<String> id) {
std::string time_zone =
    JSDateTimeFormat::CanonicalizeTimeZoneID(id->ToCString().get());
icu::UnicodeString time_zone_ustring =
    icu::UnicodeString(time_zone.c_str(), -1, US_INVicu::UnicodeString::kInvariant);
return IsUnicodeStringValidTimeZoneName(time_zone_ustring);
2837}

2839bool Intl::IsValidTimeZoneName(const icu::TimeZone& tz) {
icu::UnicodeString id;
tz.getID(id);
return IsUnicodeStringValidTimeZoneName(id);
2843}

2845// Function to support Temporal
2846std::string Intl::TimeZoneIdFromIndex(int32_t index) {
if (index == 0) return "UTC";
1
Assuming 'index' is not equal to 0→
2
←
Taking false branch→
std::unique_ptr<icu::StringEnumeration> enumeration(
    icu::TimeZone::createEnumeration());
int32_t curr = 0;
const char* id;
3
←
'id' declared without an initial value→

UErrorCode status = U_ZERO_ERROR;
while (U_SUCCESS(status) && curr < index &&
4
←
Assuming 'curr' is >= 'index'→
       ((id = enumeration->next(nullptr, status)) != nullptr)) {
  CHECK(U_SUCCESS(status))do { if ((__builtin_expect(!!(!(U_SUCCESS(status))), 0))) { V8_Fatal
("Check failed: %s.", "U_SUCCESS(status)"); } } while (false);
  curr++;
}
CHECK(U_SUCCESS(status))do { if ((__builtin_expect(!!(!(U_SUCCESS(status))), 0))) { V8_Fatal
("Check failed: %s.", "U_SUCCESS(status)"); } } while (false);
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→
CHECK(id != nullptr)do { if ((__builtin_expect(!!(!(id != nullptr)), 0))) { V8_Fatal
("Check failed: %s.", "id != nullptr"); } } while (false);
7
←
The left operand of '!=' is a garbage value
return id;
2862}

2864Maybe<bool> Intl::GetTimeZoneIndex(Isolate* isolate, Handle<String> identifier,
                                 int32_t* index) {
if (identifier->Equals(*isolate->factory()->UTC_string())) {
  *index = 0;
  return Just(true);
}

std::string identifier_str(identifier->ToCString().get());
std::unique_ptr<icu::TimeZone> tz(
    icu::TimeZone::createTimeZone(identifier_str.c_str()));
if (!IsValidTimeZoneName(*tz)) {
  return Just(false);
}

std::unique_ptr<icu::StringEnumeration> enumeration(
    icu::TimeZone::createEnumeration());
int32_t curr = 0;
const char* id;

UErrorCode status = U_ZERO_ERROR;
while (U_SUCCESS(status) &&
       (id = enumeration->next(nullptr, status)) != nullptr) {
  if (identifier_str == id) {
    *index = curr + 1;
    return Just(true);
  }
  curr++;
}
CHECK(U_SUCCESS(status))do { if ((__builtin_expect(!!(!(U_SUCCESS(status))), 0))) { V8_Fatal
("Check failed: %s.", "U_SUCCESS(status)"); } } while (false);
// We should not reach here, the !IsValidTimeZoneName should return earlier
UNREACHABLE()V8_Fatal("unreachable code");
2895}

2897// #sec-tointlmathematicalvalue
2898MaybeHandle<Object> Intl::ToIntlMathematicalValueAsNumberBigIntOrString(
  Isolate* isolate, Handle<Object> input) {
if (input->IsNumber() || input->IsBigInt()) return input;  // Shortcut.
// TODO(ftang) revisit the following after the resolution of
// https://github.com/tc39/proposal-intl-numberformat-v3/pull/82
if (input->IsOddball()) {
  return Oddball::ToNumber(isolate, Handle<Oddball>::cast(input));
}
if (input->IsSymbol()) {
  THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kSymbolToNumber),do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<Object>(__isolate__->factory()->NewTypeError
(MessageTemplate::kSymbolToNumber)); } while (false)
                  Object)do { auto* __isolate__ = (isolate); return __isolate__->template
 Throw<Object>(__isolate__->factory()->NewTypeError
(MessageTemplate::kSymbolToNumber)); } while (false);
}
ASSIGN_RETURN_ON_EXCEPTION(do { if (!(JSReceiver::ToPrimitive(isolate, Handle<JSReceiver
>::cast(input), ToPrimitiveHint::kNumber)).ToHandle(&input
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
    isolate, input,do { if (!(JSReceiver::ToPrimitive(isolate, Handle<JSReceiver
>::cast(input), ToPrimitiveHint::kNumber)).ToHandle(&input
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
    JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(input),do { if (!(JSReceiver::ToPrimitive(isolate, Handle<JSReceiver
>::cast(input), ToPrimitiveHint::kNumber)).ToHandle(&input
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
                            ToPrimitiveHint::kNumber),do { if (!(JSReceiver::ToPrimitive(isolate, Handle<JSReceiver
>::cast(input), ToPrimitiveHint::kNumber)).ToHandle(&input
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false)
    Object)do { if (!(JSReceiver::ToPrimitive(isolate, Handle<JSReceiver
>::cast(input), ToPrimitiveHint::kNumber)).ToHandle(&input
)) { ((void) 0); return MaybeHandle<Object>(); } } while
 (false);
if (input->IsString()) UNIMPLEMENTED()V8_Fatal("unimplemented code");
return input;
2917}

2919Intl::FormatRangeSourceTracker::FormatRangeSourceTracker() {
start_[0] = start_[1] = limit_[0] = limit_[1] = 0;
2921}

2923void Intl::FormatRangeSourceTracker::Add(int32_t field, int32_t start,
                                       int32_t limit) {
DCHECK_LT(field, 2)((void) 0);
start_[field] = start;
limit_[field] = limit;
2928}

2930Intl::FormatRangeSource Intl::FormatRangeSourceTracker::GetSource(
  int32_t start, int32_t limit) const {
FormatRangeSource source = FormatRangeSource::kShared;
if (FieldContains(0, start, limit)) {
  source = FormatRangeSource::kStartRange;
} else if (FieldContains(1, start, limit)) {
  source = FormatRangeSource::kEndRange;
}
return source;
2939}

2941bool Intl::FormatRangeSourceTracker::FieldContains(int32_t field, int32_t start,
                                                 int32_t limit) const {
DCHECK_LT(field, 2)((void) 0);
return (start_[field] <= start) && (start <= limit_[field]) &&
       (start_[field] <= limit) && (limit <= limit_[field]);
2946}

2948Handle<String> Intl::SourceString(Isolate* isolate, FormatRangeSource source) {
switch (source) {
  case FormatRangeSource::kShared:
    return ReadOnlyRoots(isolate).shared_string_handle();
  case FormatRangeSource::kStartRange:
    return ReadOnlyRoots(isolate).startRange_string_handle();
  case FormatRangeSource::kEndRange:
    return ReadOnlyRoots(isolate).endRange_string_handle();
}
2957}

2959}  // namespace internal
2960}  // namespace v8