xref: /arkcompiler/ets_runtime/ecmascript/js_locale.h

/*
 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ECMASCRIPT_JSLOCALE_H
#define ECMASCRIPT_JSLOCALE_H

#include "ecmascript/ecma_macros.h"
#include "ecmascript/js_array.h"
#include "ecmascript/js_object.h"
#include "ecmascript/js_thread.h"
#include "ecmascript/mem/c_containers.h"

#include "ohos/init_data.h"
#include "unicode/basictz.h"
#include "unicode/brkiter.h"
#include "unicode/calendar.h"
#include "unicode/coll.h"
#include "unicode/datefmt.h"
#include "unicode/decimfmt.h"
#include "unicode/dtitvfmt.h"
#include "unicode/dtptngen.h"
#include "unicode/fieldpos.h"
#include "unicode/formattedvalue.h"
#include "unicode/gregocal.h"
#include "unicode/locid.h"
#include "unicode/normalizer2.h"
#include "unicode/numberformatter.h"
#include "unicode/numfmt.h"
#include "unicode/numsys.h"
#include "unicode/smpdtfmt.h"
#include "unicode/timezone.h"
#include "unicode/udat.h"
#include "unicode/unistr.h"
#include "unicode/ures.h"
#include "unicode/ustring.h"
#include "unicode/uvernum.h"
#include "unicode/uversion.h"

namespace panda::ecmascript {

enum class OptionType : uint8_t { STRING = 0x01, BOOLEAN };
enum class LocaleMatcherOption : uint8_t { LOOKUP = 0x01, BEST_FIT, EXCEPTION };
enum class FormatMatcherOption : uint8_t { BASIC = 0x01, BEST_FIT, EXCEPTION };
enum class LocaleType : uint8_t {
    LITERAL = 0x01,
    NUMBER,
    PLUS_SIGN,
    MINUS_SIGN,
    PERCENT_SIGN,
    UNIT_PREFIX,
    UNIT_SUFFIX,
    CURRENCY_CODE,
    CURRENCY_PREFIX,
    CURRENCY_SUFFIX,
};

enum class TypeOption : uint8_t { CARDINAL = 0x01, ORDINAL, EXCEPTION };
enum class RoundingType : uint8_t { FRACTIONDIGITS = 0x01, SIGNIFICANTDIGITS, COMPACTROUNDING, EXCEPTION };
enum class NotationOption : uint8_t { STANDARD = 0x01, SCIENTIFIC, ENGINEERING, COMPACT, EXCEPTION };

constexpr uint32_t MAX_DIGITS = 21;
constexpr uint32_t MAX_FRACTION_DIGITS = 20;
constexpr uint8_t INTL_INDEX_ZERO = 0;
constexpr uint8_t INTL_INDEX_ONE = 1;
constexpr uint8_t INTL_INDEX_TWO = 2;
constexpr uint8_t INTL_INDEX_THREE = 3;
constexpr uint8_t INTL_INDEX_FOUR = 4;
constexpr uint8_t INTL_INDEX_FIVE = 5;
constexpr uint8_t INTL_INDEX_EIGHT = 8;

class JSIntlIterator : public icu::Locale::Iterator {
public:
    JSIntlIterator(const JSHandle<TaggedArray> &data, uint32_t length) : length_(length), curIdx_(0)
    {
        for (uint32_t idx = 0; idx < length; idx++) {
            auto itor = data->Get(idx);
            std::string str = EcmaStringAccessor(itor).ToStdString();
            data_.emplace_back(str);
        }
    }

    ~JSIntlIterator() override = default;
    DEFAULT_COPY_SEMANTIC(JSIntlIterator);
    DEFAULT_MOVE_SEMANTIC(JSIntlIterator);

    UBool hasNext() const override
    {
        return static_cast<UBool>(curIdx_ < length_);
    }

    const icu::Locale &next() override
    {
        ASSERT(curIdx_ < length_);
        UErrorCode status = U_ZERO_ERROR;
        locale_ = icu::Locale::forLanguageTag(data_[curIdx_].c_str(), status);
        ASSERT(U_SUCCESS(status));
        curIdx_++;
        return locale_;
    }

    inline const std::string &operator[](size_t index) const noexcept
    {
        ASSERT(index < length_);
        return data_[index];
    }

private:
    std::vector<std::string> data_{};
    uint32_t length_{0};
    uint32_t curIdx_{0};
    icu::Locale locale_{};
};

struct ResolvedLocale {
    std::string locale {};
    icu::Locale localeData {};
    std::map<std::string, std::string> extensions {};
};

struct MatcherResult {
    std::string locale;
    std::string extension;
};

struct OptionData {
    std::string name;
    std::string key;
    std::vector<std::string> possibleValues;
    bool isBoolValue = false;
};

struct TagElements {
    JSHandle<JSTaggedValue> language;
    JSHandle<JSTaggedValue> script;
    JSHandle<JSTaggedValue> region;
};

class JSLocale : public JSObject {
public:
    static const std::set<std::string> WELL_NUMBER_SYSTEM;
    static const std::set<std::string> WELL_COLLATION;

    static const std::string LATN_STRING;

    static const std::vector<LocaleMatcherOption> LOCALE_MATCHER_OPTION;
    static const std::vector<std::string> LOCALE_MATCHER_OPTION_NAME;

    static const std::map<std::string, std::set<std::string>> LOCALE_MAP;

    static const std::vector<std::string> HOUR_CYCLE;
    static const std::vector<std::string> CASE_FIRST;
    static JSLocale *Cast(TaggedObject *object)
    {
        ASSERT(JSTaggedValue(object).IsJSLocale());
        return static_cast<JSLocale *>(object);
    }

    static constexpr size_t ICU_FIELD_OFFSET = JSObject::SIZE;
    // icu::Locale internal slot.
    ACCESSORS(IcuField, ICU_FIELD_OFFSET, SIZE)

    DECL_VISIT_OBJECT_FOR_JS_OBJECT(JSObject, ICU_FIELD_OFFSET, SIZE)
    DECL_DUMP()

    icu::Locale *GetIcuLocale() const
    {
        ASSERT(GetIcuField().IsJSNativePointer());
        auto result = JSNativePointer::Cast(GetIcuField().GetTaggedObject())->GetExternalPointer();
        return reinterpret_cast<icu::Locale *>(result);
    }

    static void FreeIcuLocale([[maybe_unused]] void *env, void *pointer, void *data)
    {
        if (pointer == nullptr) {
            return;
        }
        auto icuLocale = reinterpret_cast<icu::Locale *>(pointer);
        icuLocale->~Locale();
        if (data != nullptr) {
            reinterpret_cast<EcmaVM *>(data)->GetNativeAreaAllocator()->FreeBuffer(pointer);
        }
    }

    // 6.2.4 DefaultLocale ()
    static JSHandle<EcmaString> DefaultLocale(JSThread *thread);

    // 6.4.1 IsValidTimeZoneName ( timeZone )
    static bool IsValidTimeZoneName(const icu::TimeZone &tz);

    // 9.2.3 LookupMatcher ( availableLocales, requestedLocales )
    static JSHandle<EcmaString> LookupMatcher(JSThread *thread, const JSHandle<TaggedArray> &availableLocales,
                                              const JSHandle<TaggedArray> &requestedLocales);

    // 9.2.4 BestFitMatcher ( availableLocales, requestedLocales )
    static JSHandle<EcmaString> BestFitMatcher(JSThread *thread, const JSHandle<TaggedArray> &availableLocales,
                                               const JSHandle<TaggedArray> &requestedLocales);

    // 9.2.5 UnicodeExtensionValue ( extension, key )
    static std::string UnicodeExtensionValue(const std::string extension, const std::string key);

    // 9.2.7 ResolveLocale ( availableLocales, requestedLocales, options, relevantExtensionKeys, localeData )
    static ResolvedLocale ResolveLocale(JSThread *thread, const JSHandle<TaggedArray> &availableLocales,
                                        const JSHandle<TaggedArray> &requestedLocales,
                                        [[maybe_unused]] LocaleMatcherOption matcher,
                                        const std::set<std::string> &relevantExtensionKeys);

    // 9.2.8 LookupSupportedLocales ( availableLocales, requestedLocales )
    static JSHandle<TaggedArray> LookupSupportedLocales(JSThread *thread, const JSHandle<TaggedArray> &availableLocales,
                                                        const JSHandle<TaggedArray> &requestedLocales);

    // 9.2.9 BestFitSupportedLocales ( availableLocales, requestedLocales )
    static JSHandle<TaggedArray> BestFitSupportedLocales(JSThread *thread,
                                                         const JSHandle<TaggedArray> &availableLocales,
                                                         const JSHandle<TaggedArray> &requestedLocales);

    // 9.2.10 SupportedLocales ( availableLocales, requestedLocales, options )
    static JSHandle<JSArray> SupportedLocales(JSThread *thread, const JSHandle<TaggedArray> &availableLocales,
                                              const JSHandle<TaggedArray> &requestedLocales,
                                              const JSHandle<JSTaggedValue> &options);

    // 9.2.11 GetOption ( options, property, type, values, fallback )
    template<typename T>
    static T GetOptionOfString(JSThread *thread, const JSHandle<JSObject> &options,
                             const JSHandle<JSTaggedValue> &property, const std::vector<T> &enumValues,
                             const std::vector<std::string> &strValues, T fallback)
    {
        // 1. Let value be ? Get(options, property).
        OperationResult operationResult = JSObject::GetProperty(thread, options, property);
        RETURN_VALUE_IF_ABRUPT_COMPLETION(thread, T::EXCEPTION);
        JSHandle<JSTaggedValue> value = operationResult.GetValue();

        if (value->IsUndefined()) {
            return fallback;
        }

        // 2. If value is not undefined, then
        // d. If values is not undefined, then
        //   i. If values does not contain an element equal to value, throw a RangeError exception.
        JSHandle<EcmaString> valueEStr = JSTaggedValue::ToString(thread, value);
        RETURN_VALUE_IF_ABRUPT_COMPLETION(thread, T::EXCEPTION);
        std::string valueStr = std::string(ConvertToString(*valueEStr, StringConvertedUsage::LOGICOPERATION));
        int existIdx = -1;
        if (!enumValues.empty()) {
            size_t strValuesSize = strValues.size();
            for (size_t i = 0; i < strValuesSize; i++) {
                if (strValues[i] == valueStr) {
                    existIdx = static_cast<int>(i);
                }
            }
            if (existIdx == -1) {
                THROW_RANGE_ERROR_AND_RETURN(thread, "getStringOption failed", T::EXCEPTION);
            }
        }
        if (existIdx == -1) {
            LOG_ECMA(FATAL) << "this branch is unreachable";
            UNREACHABLE();
        }
        // e.Return value.
        return enumValues[existIdx];
    }

    static bool GetOptionOfBool(JSThread *thread, const JSHandle<JSObject> &options,
                              const JSHandle<JSTaggedValue> &property, bool fallback, bool *res);

    static JSHandle<JSTaggedValue> GetOption(JSThread *thread, const JSHandle<JSObject> &options,
                                             const JSHandle<JSTaggedValue> &property, OptionType type,
                                             const JSHandle<JSTaggedValue> &values,
                                             const JSHandle<JSTaggedValue> &fallback);

    static bool GetOptionOfString(JSThread *thread, const JSHandle<JSObject> &options,
                                const JSHandle<JSTaggedValue> &property, const std::vector<std::string> &values,
                                std::string *optionValue);

    // 9.2.12 DefaultNumberOption ( value, minimum, maximum, fallback )
    static int DefaultNumberOption(JSThread *thread, const JSHandle<JSTaggedValue> &value, int minimum, int maximum,
                                   int fallback);

    // 9.2.13 GetNumberOption ( options, property, minimum, maximum, fallback )
    static int GetNumberOption(JSThread *thread, const JSHandle<JSObject> &options,
                               const JSHandle<JSTaggedValue> &property, int minimum, int maximum, int fallback);

    static bool IsLanguageSubtag(const std::string &value)
    {
        return IsAlpha(value, INTL_INDEX_TWO, INTL_INDEX_THREE) || IsAlpha(value, INTL_INDEX_FIVE, INTL_INDEX_EIGHT);
    }

    static bool IsScriptSubtag(const std::string &value)
    {
        return IsAlpha(value, INTL_INDEX_FOUR, INTL_INDEX_FOUR);
    }

    static bool IsRegionSubtag(const std::string &value)
    {
        return IsAlpha(value, INTL_INDEX_TWO, INTL_INDEX_TWO) || IsDigit(value, INTL_INDEX_THREE, INTL_INDEX_THREE);
    }

    static bool IsVariantSubtag(const std::string &value)
    {
        return IsThirdDigitAlphanum(value) || IsAlphanum(value, INTL_INDEX_FIVE, INTL_INDEX_EIGHT);
    }

    static bool IsThirdDigitAlphanum(const std::string &value)
    {
        return InRange(value[0], '0', '9') && value.length() == INTL_INDEX_FOUR &&
               IsAlphanum(value.substr(INTL_INDEX_ONE), INTL_INDEX_THREE, INTL_INDEX_THREE);
    }

    static bool IsExtensionSingleton(const std::string &value)
    {
        return IsAlphanum(value, INTL_INDEX_ONE, INTL_INDEX_ONE);
    }

    static bool IsNormativeCalendar(const std::string &value)
    {
        return IsWellAlphaNumList(value);
    }

    static bool IsNormativeNumberingSystem(const std::string &value)
    {
        return IsWellAlphaNumList(value);
    }

    static bool IsWellNumberingSystem(const std::string &value)
    {
        if (JSLocale::WELL_NUMBER_SYSTEM.find(value) != JSLocale::WELL_NUMBER_SYSTEM.end()) {
            return false;
        }
        UErrorCode status = U_ZERO_ERROR;
        icu::NumberingSystem *numberingSystem = icu::NumberingSystem::createInstanceByName(value.c_str(), status);
        bool result = U_SUCCESS(status) != 0 && numberingSystem != nullptr;
        delete numberingSystem;
        numberingSystem = nullptr;
        return result;
    }

    static bool IsWellCollation(const icu::Locale &locale, const std::string &value)
    {
        if (JSLocale::WELL_COLLATION.find(value) != JSLocale::WELL_COLLATION.end()) {
            return false;
        }
        return IsWellExtension<icu::Collator>(locale, "collation", value);
    }

    static bool IsWellCalendar(const icu::Locale &locale, const std::string &value)
    {
        return IsWellExtension<icu::Calendar>(locale, "calendar", value);
    }

    template<typename T>
    static bool IsWellExtension(const icu::Locale &locale, const char *key, const std::string &value)
    {
        UErrorCode status = U_ZERO_ERROR;
        const char *outdatedType = uloc_toLegacyType(key, value.c_str());
        if (outdatedType == nullptr) {
            return false;
        }
        icu::StringEnumeration *sequence = T::getKeywordValuesForLocale(key, icu::Locale(locale.getBaseName()),
                                                                        false, status);
        if (U_FAILURE(status)) {
            delete sequence;
            sequence = nullptr;
            return false;
        }
        int32_t size = 0;
        const char *element = sequence->next(&size, status);
        while (U_SUCCESS(status) && element != nullptr) {
            if (strcmp(outdatedType, element) == 0) {
                delete sequence;
                sequence = nullptr;
                return true;
            }
            element = sequence->next(&size, status);
        }
        delete sequence;
        sequence = nullptr;
        return false;
    }

    static inline constexpr int AsciiAlphaToLower(uint32_t c)
    {
        constexpr uint32_t FLAG = 0x20;
        return static_cast<int>(c | FLAG);
    }

    static bool IsAsciiAlpha(char ch)
    {
        return InRange(ch, 'A', 'Z') || InRange(ch, 'a', 'z');
    }

    static char LocaleIndependentAsciiToUpper(char ch)
    {
        return (InRange(ch, 'a', 'z')) ? static_cast<char>((ch - 'a' + 'A')) : ch;
    }

    static char LocaleIndependentAsciiToLower(char ch)
    {
        return (InRange(ch, 'A', 'Z')) ? static_cast<char>((ch - 'A' + 'a')) : ch;
    }

    template<typename T, typename U>
    static bool InRange(T value, U start, U end)
    {
        ASSERT(start <= end);
        ASSERT(sizeof(T) >= sizeof(U));
        return (value >= static_cast<T>(start)) && (value <= static_cast<T>(end));
    }

    static bool IsWellAlphaNumList(const std::string &value)
    {
        if (value.length() < INTL_INDEX_THREE) {
            return false;
        }
        char lastChar = value[value.length() - 1];
        if (lastChar == '-') {
            return false;
        }
        std::vector<std::string> items;
        std::istringstream input(value);
        std::string temp;
        while (getline(input, temp, '-')) {
            items.push_back(temp);
        }
        for (auto &item : items) {
            if (!IsAlphanum(item, INTL_INDEX_THREE, INTL_INDEX_EIGHT)) {
                return false;
            }
        }
        return true;
    }

    static bool ValidateOtherTags(const icu::Locale &locale, const char *packageName, const char *key, bool &res)
    {
        const char *localeCountry = locale.getCountry();
        const char *localeScript = locale.getScript();
        std::string removeCountry;
        if (localeCountry[0] != '\0' && localeScript[0] != '\0') {
            removeCountry = locale.getLanguage();
            removeCountry.append("-");
            removeCountry.append(localeScript);
            return CheckLocales(removeCountry.c_str(), key, packageName, res);
        }
        if (localeCountry[0] != '\0' || localeScript[0] != '\0') {
            std::string language = locale.getLanguage();
            return CheckLocales(language.c_str(), key, packageName, res);
        }
        return res;
    }

    static bool CheckLocales(const icu::Locale &locale, const char *key, const char *packageName, bool &res)
    {
        res = false;
        UErrorCode status = U_ZERO_ERROR;
        const char *formalLocale = locale.getName();
        UResourceBundle *localeRes = ures_open(packageName, formalLocale, &status);
        if (localeRes != nullptr && status == U_ZERO_ERROR) {
            if (key == nullptr) {
                res = true;
            } else {
                UResourceBundle *keyRes = ures_getByKey(localeRes, key, nullptr, &status);
                if (keyRes != nullptr && status == U_ZERO_ERROR) {
                    res = true;
                }
                ures_close(keyRes);
            }
        }
        ures_close(localeRes);
        if (res) {
            return res;
        } else {
            ValidateOtherTags(locale, packageName, key, res);
        }
        return res;
    }

    static std::vector<std::string> GetAvailableStringLocales(JSThread *thread,
                                                              const JSHandle<TaggedArray> &availableLocales);

    static JSHandle<JSObject> PutElement(JSThread *thread, int index, const JSHandle<JSArray> &array,
                                         const JSHandle<JSTaggedValue> &fieldTypeString,
                                         const JSHandle<JSTaggedValue> &value);

    static std::string GetNumberingSystem(const icu::Locale &icuLocale);

    static bool IsWellFormedCurrencyCode(const std::string &currency);

    static bool IsWellFormedCalendarCode(const std::string& calendar);

    static JSHandle<JSTaggedValue> GetNumberFieldType(JSThread *thread, JSTaggedValue x, int32_t fieldId);

    static bool ApplyOptionsToTag(JSThread *thread, const JSHandle<EcmaString> &tag, const JSHandle<JSObject> &options,
                                  TagElements &tagElements);

    static JSHandle<JSLocale> InitializeLocale(JSThread *thread, const JSHandle<JSLocale> &locale,
                                               const JSHandle<EcmaString> &localeString,
                                               const JSHandle<JSObject> &options);

    static JSTaggedValue NormalizeKeywordValue(JSThread *thread, const JSHandle<JSLocale> &locale,
                                                    const std::string &key);

    static JSHandle<EcmaString> ToString(JSThread *thread, const JSHandle<JSLocale> &locale);

    // 12.1.1 SetNumberFormatDigitOptions ( intlObj, options, mnfdDefault, mxfdDefault, notation )
    template<typename T>
    static void SetNumberFormatDigitOptions(JSThread *thread, const JSHandle<T> &intlObj,
                                            const JSHandle<JSTaggedValue> &options, int mnfdDefault, int mxfdDefault,
                                            NotationOption notation)
    {
        // 1. Assert: Type(intlObj) is Object.
        // 2. Assert: Type(options) is Object.
        // 3. Assert: Type(mnfdDefault) is Number.
        // 4. Assert: Type(mxfdDefault) is Number.
        ASSERT(options->IsHeapObject());
        auto globalConst = thread->GlobalConstants();
        // Set intlObj.[[MinimumFractionDigits]] to 0.
        intlObj->SetMinimumFractionDigits(thread, JSTaggedValue(0));
        // Set intlObj.[[MaximumFractionDigits]] to 0.
        intlObj->SetMaximumFractionDigits(thread, JSTaggedValue(0));
        // Set intlObj.[[MinimumSignificantDigits]] to 0.
        intlObj->SetMinimumSignificantDigits(thread, JSTaggedValue(0));
        // Set intlObj.[[MaximumSignificantDigits]] to 0.
        intlObj->SetMaximumSignificantDigits(thread, JSTaggedValue(0));

        // 5. Let mnid be ? GetNumberOption(options, "minimumIntegerDigits,", 1, 21, 1).
        JSHandle<JSTaggedValue> mnidKey = globalConst->GetHandledMinimumIntegerDigitsString();
        int mnid = GetNumberOption(thread, JSHandle<JSObject>::Cast(options), mnidKey, 1, MAX_DIGITS, 1);
        // 6. Let mnfd be ? Get(options, "minimumFractionDigits").
        JSHandle<JSTaggedValue> mnfdKey = globalConst->GetHandledMinimumFractionDigitsString();
        JSHandle<JSTaggedValue> mnfd = JSTaggedValue::GetProperty(thread, options, mnfdKey).GetValue();
        intlObj->SetMinimumIntegerDigits(thread, JSTaggedValue(mnid));
        RETURN_IF_ABRUPT_COMPLETION(thread);
        // 7. Let mxfd be ? Get(options, "maximumFractionDigits").
        JSHandle<JSTaggedValue> mxfdKey = globalConst->GetHandledMaximumFractionDigitsString();
        JSHandle<JSTaggedValue> mxfd = JSTaggedValue::GetProperty(thread, options, mxfdKey).GetValue();
        RETURN_IF_ABRUPT_COMPLETION(thread);
        // 8. Let mnsd be ? Get(options, "minimumSignificantDigits").
        JSHandle<JSTaggedValue> mnsdKey = globalConst->GetHandledMinimumSignificantDigitsString();
        JSHandle<JSTaggedValue> mnsd = JSTaggedValue::GetProperty(thread, options, mnsdKey).GetValue();
        RETURN_IF_ABRUPT_COMPLETION(thread);
        // 9. Let mxsd be ? Get(options, "maximumSignificantDigits").
        JSHandle<JSTaggedValue> mxsdKey = globalConst->GetHandledMaximumSignificantDigitsString();
        JSHandle<JSTaggedValue> mxsd = JSTaggedValue::GetProperty(thread, options, mxsdKey).GetValue();
        RETURN_IF_ABRUPT_COMPLETION(thread);

        // 10. Set intlObj.[[MinimumIntegerDigits]] to mnid.
        // 11. If mnsd is not undefined or mxsd is not undefined, then
        if (!mnsd->IsUndefined() || !mxsd->IsUndefined()) {
            // a. Set intlObj.[[RoundingType]] to significantDigits.
            intlObj->SetRoundingType(RoundingType::SIGNIFICANTDIGITS);
            // b. Let mnsd be ? DefaultNumberOption(mnsd, 1, 21, 1).
            mnsd = JSHandle<JSTaggedValue>(
                thread, JSTaggedValue(JSLocale::DefaultNumberOption(thread, mnsd, 1, MAX_DIGITS, 1)));
            RETURN_IF_ABRUPT_COMPLETION(thread);
            // c. Let mxsd be ? DefaultNumberOption(mxsd, mnsd, 21, 21).
            mxsd = JSHandle<JSTaggedValue>(thread,
                JSTaggedValue(JSLocale::DefaultNumberOption(thread, mxsd, mnsd->GetInt(), MAX_DIGITS, MAX_DIGITS)));
            RETURN_IF_ABRUPT_COMPLETION(thread);
            // d. Set intlObj.[[MinimumSignificantDigits]] to mnsd.
            intlObj->SetMinimumSignificantDigits(thread, mnsd);
            // e. Set intlObj.[[MaximumSignificantDigits]] to mxsd.
            intlObj->SetMaximumSignificantDigits(thread, mxsd);
        } else {
            if (!mnfd->IsUndefined() || !mxfd->IsUndefined()) {
                // 12. Else if mnfd is not undefined or mxfd is not undefined, then
                // a. Set intlObj.[[RoundingType]] to fractionDigits.
                intlObj->SetRoundingType(RoundingType::FRACTIONDIGITS);
                if (!mxfd->IsUndefined()) {
                    JSTaggedValue mxfdValue =
                        JSTaggedValue(JSLocale::DefaultNumberOption(thread, mxfd, 0, MAX_FRACTION_DIGITS, mxfdDefault));
                    RETURN_IF_ABRUPT_COMPLETION(thread);
                    mxfd = JSHandle<JSTaggedValue>(thread, mxfdValue);
                    mnfdDefault = std::min(mnfdDefault, mxfd->GetInt());
                }
                // b. Let mnfd be ? DefaultNumberOption(mnfd, 0, 20, mnfdDefault).
                mnfd = JSHandle<JSTaggedValue>(
                    thread, JSTaggedValue(DefaultNumberOption(thread, mnfd, 0, MAX_FRACTION_DIGITS, mnfdDefault)));
                // c. Let mxfdActualDefault be max( mnfd, mxfdDefault ).
                int mxfdActualDefault = std::max(mnfd->GetInt(), mxfdDefault);
                // d. Let mxfd be ? DefaultNumberOption(mxfd, mnfd, 20, mxfdActualDefault).
                mxfd = JSHandle<JSTaggedValue>(
                    thread, JSTaggedValue(JSLocale::DefaultNumberOption(thread, mxfd, mnfd->GetInt(),
                                                                        MAX_FRACTION_DIGITS, mxfdActualDefault)));
                RETURN_IF_ABRUPT_COMPLETION(thread);
                // e. Set intlObj.[[MinimumFractionDigits]] to mnfd.
                intlObj->SetMinimumFractionDigits(thread, mnfd);
                // f. Set intlObj.[[MaximumFractionDigits]] to mxfd.
                intlObj->SetMaximumFractionDigits(thread, mxfd);
            } else if (notation == NotationOption::COMPACT) {
                // 13. Else if notation is "compact", then
                // a. Set intlObj.[[RoundingType]] to compactRounding.
                intlObj->SetRoundingType(RoundingType::COMPACTROUNDING);
            } else {
                // 14. else,
                // a.Set intlObj.[[RoundingType]] to fractionDigits.
                intlObj->SetRoundingType(RoundingType::FRACTIONDIGITS);
                // b.Set intlObj.[[MinimumFractionDigits]] to mnfdDefault.
                intlObj->SetMinimumFractionDigits(thread, JSTaggedValue(mnfdDefault));
                // c.Set intlObj.[[MaximumFractionDigits]] to mxfdDefault.
                intlObj->SetMaximumFractionDigits(thread, JSTaggedValue(mxfdDefault));
            }
        }
    }

    static JSHandle<TaggedArray> ConstructLocaleList(JSThread *thread,
                                                     const std::vector<std::string> &icuAvailableLocales);

    static bool CheckLocales(const icu::Locale &locale, const char *path, const char *key);

    static bool IsPrivateSubTag(std::string result, size_t len)
    {
        if ((len > INTL_INDEX_ONE) && (result[INTL_INDEX_ONE] == '-')) {
            ASSERT(result[INTL_INDEX_ZERO] == 'x' || result[INTL_INDEX_ZERO] == 'i');
            return true;
        }
        return false;
    }

private:
    static icu::Locale BuildICULocale(const std::string &bcp47Locale);

    static bool IsCheckRange(const std::string &str, size_t min, size_t max, bool(rangeCheckFunc)(char))
    {
        if (!InRange(str.length(), min, max)) {
            return false;
        }
        for (char i : str) {
            if (!rangeCheckFunc(i)) {
                return false;
            }
        }
        return true;
    }

    static bool IsAlpha(const std::string &str, size_t min, size_t max)
    {
        if (!InRange(str.length(), min, max)) {
            return false;
        }
        for (char c : str) {
            if (!IsAsciiAlpha(c)) {
                return false;
            }
        }
        return true;
    }

    static bool IsDigit(const std::string &str, size_t min, size_t max)
    {
        if (!InRange(str.length(), min, max)) {
            return false;
        }
        for (char i : str) {
            if (!InRange(i, '0', '9')) {
                return false;
            }
        }
        return true;
    }

    static bool IsAlphanum(const std::string &str, size_t min, size_t max)
    {
        if (!InRange(str.length(), min, max)) {
            return false;
        }
        for (char i : str) {
            if (!IsAsciiAlpha(i) && !InRange(i, '0', '9')) {
                return false;
            }
        }
        return true;
    }

    static bool IsAToZ(char ch)
    {
        int lowerCh = JSLocale::AsciiAlphaToLower(ch);
        return JSLocale::InRange(lowerCh, 'a', 'z');
    }
};
}  // namespace panda::ecmascript
#endif  // ECMASCRIPT_JSLOCALE_H