/*
 * Copyright (c) 2021 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.
 */
#include "js_url.h"
#include <cctype>
#include <regex>
#include <sstream>
#include "securec.h"
#include "utils/log.h"

namespace OHOS::Api {

    static std::map<std::string, int> g_head = {
        {"ftp:", 21}, {"file:", -1}, {"gopher:", 70}, {"http:", 80},
        {"https:", 443}, {"ws:", 80}, {"wss:", 443}
    };

    static std::vector<std::string> g_doubleSegment = {
        "..", ".%2e", ".%2E", "%2e.", "%2E.",
        "%2e%2e", "%2E%2E", "%2e%2E", "%2E%2e"
    };

    static std::vector<std::string> g_singlesegment = { ".", "%2e", "%2E" };

    static std::vector<char> g_specialcharacter = {
        '\0', '\t', '\n', '\r', ' ', '#', '%', '/', ':', '?',
        '@', '[', '\\', ']'
    };

    static void ReplaceSpecialSymbols(std::string& input, std::string& oldstr, std::string& newstr)
    {
        size_t oldlen = oldstr.size();
        while (true) {
            size_t pos = 0;
            if ((pos = input.find(oldstr)) != std::string::npos) {
                input.replace(pos, oldlen, newstr);
            } else {
                break;
            }
        }
    }

    template<typename T>
    bool IsASCIITabOrNewline(const T ch)
    {
        return (ch == '\t' || ch == '\n' || ch == '\r');
    }

    template<typename T>
    bool IsHexDigit(const T ch)
    {
        if (isdigit(ch) || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
            return true;
        }
        return false;
    }

    static unsigned AsciiToHex(const unsigned char pram)
    {
        if (pram >= '0' && pram <= '9') {
            return pram - '0';
        }
        if (pram >= 'A' && pram <= 'F') {
            return pram - 'A' + 10; // 10:Convert to hexadecimal
        }
        if (pram >= 'a' && pram <= 'f') {
            return pram - 'a' + 10; // 10:Convert to hexadecimal
        }
        return static_cast<unsigned>(-1);
    }

    static std::string DecodePercent(const char *input, size_t len)
    {
        std::string temp;
        if (len == 0) {
            return temp;
        }
        temp.reserve(len);
        const char *it = input;
        const char *end = input + len;
        while (it < end) {
            const char ch = it[0];
            size_t left = end - it - 1;
            if (ch != '%' || left < 2 || (ch == '%' && (!IsHexDigit(it[1]) || // 2:The length is less than 2
                !IsHexDigit(it[2])))) { // 2:The number of characters is less than 2
                temp += ch;
                it++;
                continue;
            } else {
                unsigned first = AsciiToHex(it[1]);
                unsigned second = AsciiToHex(it[2]); // 2:Subscript 2
                char pram = static_cast<char>(first * 16 + second); // 16:Convert hex
                temp += pram;
                it += 3; // 3:Move the pointer to the right by 3 digits.
            }
        }
        return temp;
    }

    static void DeleteC0OrSpace(std::string& str)
    {
        if (str.empty()) {
            return;
        }
        size_t i = 0;
        size_t strlen = str.size();
        for (; i < strlen;) {
            if (str[i] >= '\0' && str[i] <= ' ') {
                i++;
            } else {
                break;
            }
        }
        str = str.substr(i);
        strlen = str.size();
        for (i = strlen - 1; i != 0; i--) {
            if (str[i] >= '\0' && str[i] <= ' ') {
                str.pop_back();
            } else {
                break;
            }
        }
    }

    static void DeleteTabOrNewline(std::string& str1)
    {
        for (auto item = str1.begin(); item != str1.end();) {
            if (IsASCIITabOrNewline(*item)) {
                item = str1.erase(item);
            } else {
                ++item;
            }
        }
    }

    static bool IsSpecial(std::string scheme)
    {
        auto temp = g_head.count(scheme);
        if (temp > 0) {
            return true;
        }
        return false;
    }

    static bool AnalysisScheme(std::string& input, std::string& scheme,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (!isalpha(input[0])) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return false;
        } else {
            size_t strlen = input.size();
            for (size_t i = 0; i < strlen - 1; ++i) {
                if ((isalnum(input[i]) || input[i] == '+' || input[i] == '-' || input[i] == '.') &&
                    isupper(input[i])) {
                        input[i] = tolower(input[i]);
                }
                if (!isalnum(input[i]) && input[i] != '+' && input[i] != '-' && input[i] != '.') {
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0)); 
                    // 0:Bit 0 Set to true,The URL analysis failed
                    return false;
                }
            }
            scheme = input;
            if (IsSpecial(scheme)) {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT1));
            }
            return true;
        }
    }

    static void AnalysisFragment(const std::string& input, std::string& fragment,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        fragment = input;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT8));
    }

    static void AnalysisQuery(const std::string& input, std::string& query,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        query = input;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT7));
    }
    static void AnalysisUsernameAndPasswd(std::string& input, std::string& username, std::string& password,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        int pos = input.size() - 1;
        for (; pos >= 0; pos--) {
            if (input[pos] == '@') {
                break;
            }
        }
        std::string userAndPasswd = input.substr(0, pos);
        input = input.substr(pos + 1);
        if (userAndPasswd.empty()) {
            return;
        }
        if (userAndPasswd.find('@') != std::string::npos) {
            while (true) {
                size_t i = 0;
                if ((i = userAndPasswd.find('@')) != std::string::npos) {
                    userAndPasswd = userAndPasswd.replace(i, 1, "%40");
                } else {
                    break;
                }
            }
        }

        if (userAndPasswd.find(':') != std::string::npos) {
            size_t i = userAndPasswd.find(':');
            std::string user = userAndPasswd.substr(0, i);
            std::string keyWord = userAndPasswd.substr(i + 1);
            if (!user.empty()) {
                username = user;
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT2));
            }
            if (!keyWord.empty()) {
                password = keyWord;
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT3));
            }
        } else {
            username = userAndPasswd;
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT2));
        }
    }

    static void AnalysisPath(std::string& input, std::vector<std::string>& path,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, bool isSpecial)
    {
        std::vector<std::string> temp;
        size_t pos = 0;
        while (((pos = input.find('/')) != std::string::npos) ||
            ((pos = input.find('\\')) != std::string::npos && isSpecial)) {
            temp.push_back(input.substr(0, pos));
            input = input.substr(pos + 1);
        }
        temp.push_back(input);
        size_t length = temp.size();
        for (size_t it = 0; it < length; ++it) {
            auto result = find(g_doubleSegment.begin(), g_doubleSegment.end(), temp[it]);
            if (result != g_doubleSegment.end()) {
                if (path.empty() && it == length - 1) {
                    path.emplace_back("");
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
                }
                if (path.empty()) {
                    continue;
                }
                path.pop_back();
                if (it == length - 1) {
                    path.emplace_back("");
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
                }
                continue;
            }
            result = find(g_singlesegment.begin(), g_singlesegment.end(), temp[it]);
            if (result != g_singlesegment.end() && it == length - 1) {
                path.emplace_back("");
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
                continue;
            }
            if (result == g_singlesegment.end()) {
                path.push_back(temp[it]);
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
            }
        }
    }

    static void AnalysisPort(std::string input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        for (auto i : input) {
            if (!isdigit(i)) {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
        }
        int it = stoi(input);
        const int maxPort = 65535; // 65535:Maximum port number
        if (it > maxPort) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT5));
        for (auto i : g_head) {
            if (i.first == urlinfo.scheme && i.second == it) {
                urlinfo.port = -1;
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT5), 0);
                return;
            }
        }
        urlinfo.port = it;
    }

    static void AnalysisOpaqueHost(std::string input, std::string& host,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        size_t strlen = input.size();
        for (size_t i = 0; i < strlen; ++i) {
            char ch = input[i];
            auto result = find(g_specialcharacter.begin(), g_specialcharacter.end(), ch);
            if (ch != '%' && (result != g_specialcharacter.end())) {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
        }
        host = input;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
    }

    static std::string IPv6ZeroComperess(std::vector<std::string>& tempIPV6, std::string& input,
        int maxZeroIndex, int max)
    {
        for (int i = 0; i < maxZeroIndex; ++i) {
            input += tempIPV6[i];
            if (i != maxZeroIndex - 1) {
                input += ":";
            }
        }
        input += "::";
        size_t strlen = tempIPV6.size();
        for (size_t i = maxZeroIndex + max; i < strlen; ++i) {
            input += tempIPV6[i];
            if (i != strlen - 1) {
                input += ":";
            }
        }
        return input;
    }

    static std::string IPv6NoComperess(std::vector<std::string>& tempIPV6, std::string& input)
    {
        size_t strlen = tempIPV6.size();
            for (size_t i = 0; i < strlen; ++i) {
                if (tempIPV6[i][0] == '?' && tempIPV6[i].size() == 1) {
                    input += ":";
                } else {
                    input += tempIPV6[i];
                    if (i != tempIPV6.size() - 1) {
                        input += ":";
                    }
                }
            }
        return input;
    }

    static std::string IPv6HostCompress(std::vector<std::string>& tempIPV6, int flag)
    {
        std::string input;
        if (flag == 1) {
            return IPv6NoComperess(tempIPV6, input);
        }
        int max = 0;
        int count = 0;
        size_t maxZeroIndex = 0;
        size_t strlen = tempIPV6.size();
        for (size_t i = 0; i < strlen;) {
            if (tempIPV6[i] == "0" && (i + 1 < strlen && tempIPV6[i + 1] == "0")) {
                int index = i;
                while (i < strlen && tempIPV6[i] == "0") {
                    i++;
                    count++;
                }
                if (max < count) {
                    max = count;
                    maxZeroIndex = index;
                }
            } else {
                count = 0;
                i++;
            }
        }
        if (count == 8) { // 8:If IPv6 is all 0
            return "::";
        } else if (max == 0) {
            strlen = tempIPV6.size();
            for (size_t i = 0; i < strlen; ++i) {
                input += tempIPV6[i];
                if (i != strlen - 1) {
                    input += ":";
                }
            }
            return input;
        } else if (maxZeroIndex == 0) {
            input += "::";
            strlen = tempIPV6.size();
            for (size_t i = max; i < strlen; ++i) {
                input += tempIPV6[i] + ":";
            }
            input.pop_back();
            return input;
        } else {
            return IPv6ZeroComperess(tempIPV6, input, maxZeroIndex, max);
        }
    }

    void DealWithtempIpv6(std::vector<std::string> &tempIpv6, std::stringstream &ss,
        std::string &numberHex, const int tempProt[4])
    {
        tempIpv6.push_back(numberHex);
        ss.clear();
        numberHex.clear();
        ss << std::hex << tempProt[2] * 0x100 + tempProt[3]; // 2: 3:subscript position
        ss >> numberHex;
        tempIpv6.push_back(numberHex);
        ss.clear();
        numberHex.clear();
        tempIpv6.erase(tempIpv6.end() - 3); // 3:Remove redundant space
    }

    void IPv6DealWithColon(int& flag, std::string& strInput,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, size_t &pos)
    {
        flag = 1;
        if (strInput.find("::", pos + 2) != std::string::npos) { // 2:Subscript Move Right2
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
        }
        return;
    }

    void IsFlagExist(size_t &pos, std::vector<std::string> &temp, std::vector<std::string> &tempEnd,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> &flags, unsigned &numberFlag)
    {
        while (((pos = temp[numberFlag].find('.')) != std::string::npos)) {
            tempEnd.push_back(temp[numberFlag].substr(0, pos));
            temp[numberFlag] = temp[numberFlag].substr(pos + 1);
        }
        tempEnd.push_back(temp[numberFlag]);
        if (tempEnd.size() != 4) { // 4:The size is not 4
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
        }
    }
    void DealWithProt(std::vector<std::string> &tempEnd, unsigned &val,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags,
        int &number, int tempProt[4])
    {
        size_t strlen = tempEnd.size();
        for (size_t x = 0; x < strlen; ++x) {
            val = stoi(tempEnd[x]);
            if (val > 255) { // 255:The maximum value is 255
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
            tempProt[number] = val;
            number++;
            val = 0;
        }
    }

    void DealWithElse(std::vector<std::string> &temp, size_t &i, unsigned &numberFlag,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, unsigned &val)
    {
        size_t strlen = temp[i].size();
        for (size_t j = 0; j < strlen; ++j) {
            if (((temp[i].find('.')) != std::string::npos)) {
                numberFlag = i;
                if (temp.size() == i || temp.size() > 7) { // 7:The size cannot be greater than 7
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                    return;
                }
                return;
            } else if (IsHexDigit(temp[i][j])) {
                val = val * 0x10 + AsciiToHex(temp[i][j]);
            }
        }
    }

    void DealWithStringStream(std::stringstream &ss, unsigned &val,
        std::string &numberHex, std::vector<std::string> &tempIpv6)
    {
        ss << std::hex << val;
        ss >> numberHex;
        tempIpv6.push_back(numberHex);
        ss.clear();
        numberHex.clear();
        val = 0;
    }

    static void IPv6Host(std::string& input, std::string& host,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (input.size() == 0) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        std::string strInput = input;
        std::stringstream ss;
        std::string numberHex;
        unsigned val = 0;
        unsigned numberFlag = 0;
        std::vector<std::string> temp;
        std::vector<std::string> tempEnd;
        std::vector<std::string> tempIpv6;
        size_t pos = 0;
        int tempProt[4] = { 0 };
        int number = 0;
        int flag = 0;
        if ((pos = strInput.find("::", 0)) != std::string::npos) {
            IPv6DealWithColon(flag, strInput, flags, pos);
        }
        while (((pos = strInput.find(':')) != std::string::npos)) {
            temp.push_back(strInput.substr(0, pos));
            strInput = strInput.substr(pos + 1);
        }
        temp.push_back(strInput);
        if (temp.size() > 8) { // 8:The incoming value does not meet the criteria
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        size_t length = temp.size();
        for (size_t i = 0; i < length; ++i) {
            if (temp[i].empty()) {
                tempIpv6.push_back("?");
            } else {
                DealWithElse(temp, i, numberFlag, flags, val);
                DealWithStringStream(ss, val, numberHex, tempIpv6);
            }
        }
        if (numberFlag != 0) {
            IsFlagExist(pos, temp, tempEnd, flags, numberFlag);
            DealWithProt(tempEnd, val, flags, number, tempProt);
            ss << std::hex << tempProt[0] * 0x100 + tempProt[1];
            ss >> numberHex;
            DealWithtempIpv6(tempIpv6, ss, numberHex, tempProt);
        }
        strInput = IPv6HostCompress(tempIpv6, flag);
        host = '[' + strInput + ']';
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT10));
    }

    static bool CheckNunType(const char ch, const unsigned num)
    {
        enum class NUMERATION {
            OCT = 8, // 8:Octal
            DEC = 10, // 10:Decimal
            HEX = 16 // 16:Hexadecimal
        };
        if (NUMERATION(num) == NUMERATION::OCT) {
            if (ch < '0' || ch > '7') { // 0~7:Octal
                return false;
            }
        } else if (NUMERATION(num) == NUMERATION::DEC) {
            if (ch < '0' || ch > '9') { // 0~9:Decimal
                return false;
            }
        } else if (NUMERATION(num) == NUMERATION::HEX) {
            if (!((ch >= '0' && ch <= '9') ||  // 0~9, a~f, A~F:Hexadecimal
                (ch >= 'A' && ch <= 'F') ||
                (ch >= 'a' && ch <= 'f'))) {
                return false;
            }
        }
        return true;
    }

    static int64_t AnalyseNum(std::string parts)
    {
        unsigned num = 10; // 10:Decimal
        std::string partsBeg = parts.substr(0, 2); // 2:Take two digits to determine whether it is hexadecimal
        size_t partsLen = parts.length();
        if (partsLen >= 2 && (partsBeg == "0X" || partsBeg == "0x")) { // 2:parts length
            num = 16; // 16:Convert to hexadecimal
            parts = parts.substr(2); // 2:delete '0x'
        } else if (num == 10 && partsLen > 1 && parts.substr(0, 1) == "0") { // 10:Conversion to Decimal Coefficient
            num = 8; // 8:Convert to octal
            parts = parts.substr(1);
        }
        for (size_t i = 0; i < parts.length(); i++) {
            bool ret = CheckNunType(parts[i], num);
            if (!ret) {
                return -1;
            }
        }
        return strtoll(parts.c_str(), nullptr, num);
    }

    static bool OverHex(std::string input)
    {
        size_t size = input.size();
        for (size_t i = 0; i < size; i++) {
            return !IsHexDigit(input[i]);
        }
        return false;
    }

    static bool NotAllNum(std::string input)
    {
        size_t size = input.size();
        for (size_t i = 0; i < size; i++) {
            if (!isdigit(input[i])) {
                return true;
            }
        }
        return false;
    }

    static bool AnalyseIPv4(const char *instr, std::string &host,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> &flags)
    {
        int count = 0;
        for (const char *ptr = instr; *ptr != '\0'; ptr++) {
            if (*ptr == '.') {
                if (++count > 3) { // 3:The IPV4 address has only four segments
                    return false;
                }
            }
        }
        if (count != 3) { // 3:The IPV4 address has only four segments
            return false;
        }

        size_t pos = 0;
        std::vector<std::string> strVec;
        std::string input = static_cast<std::string>(instr);
        while (((pos = input.find('.')) != std::string::npos)) {
            strVec.push_back(input.substr(0, pos));
            input = input.substr(pos + 1);
        }
        strVec.push_back(input);
        size_t size = strVec.size();
        for (size_t i = 0; i < size; i++) {
            if (strVec[i].empty()) {
                return false;
            }
            std::string begStr = strVec[i].substr(0, 2); // 2:Intercept the first two characters
            if ((begStr == "0x" || begStr == "0X") && OverHex(strVec[i].substr(2))) { // 2:Intercept
                return false;
            } else if ((begStr == "0x" || begStr == "0X") && !(OverHex(strVec[i].substr(2)))) { // 2:Intercept
                continue;
            }
            if (NotAllNum(strVec[i])) {
                return false;
            }
        }
        for (size_t i = 0; i < size; i++) {
            int64_t value = AnalyseNum(strVec[i].c_str());
            if ((value < 0) || (value > 255)) { // 255:Only handle numbers between 0 and 255
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return false;
            } else {
                host += std::to_string(value);
                if (i != size - 1) {
                    host += ".";
                }
            }
        }
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
        return true;
    }
    static void AnalysisHost(std::string& input, std::string& host,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, bool special)
    {
        if (input.empty()) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        if (input[0] == '[') {
            if ((input[input.length() - 1]) == ']') {
                size_t  b = input.length();
                input = input.substr(1, b - 2); // 2:Truncating Strings
                IPv6Host(input, host, flags);
                return;
            } else {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
        }
        if (!special) {
            AnalysisOpaqueHost(input, host, flags);
            return;
        }
        std::string decodeInput = DecodePercent(input.c_str(), input.length());
        size_t strlen = decodeInput.size();
        for (size_t pos = 0; pos < strlen; ++pos) {
            char ch = decodeInput[pos];
            auto result = find(g_specialcharacter.begin(), g_specialcharacter.end(), ch);
            if (result != g_specialcharacter.end()) {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
        }
        bool ipv4 = AnalyseIPv4(decodeInput.c_str(), host, flags);
        if (ipv4) {
            return;
        }
        host = decodeInput;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
    }
    static bool ISFileNohost(const std::string& input)
    {
        if ((isalpha(input[0]) && (input[1] == ':' || input[1] == '|'))) {
            return true;
        }
        return false;
    }
    static void AnalysisFilePath(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        std::vector<std::string> temp;
        size_t pos = 0;
        while (((pos = input.find('/')) != std::string::npos) || ((pos = input.find('\\')) != std::string::npos)) {
            temp.push_back(input.substr(0, pos));
            input = input.substr(pos + 1);
        }
        temp.push_back(input);
        size_t length = temp.size();
        for (size_t i = 0; i < length; ++i) {
            auto a = find(g_doubleSegment.begin(), g_doubleSegment.end(), temp[i]);
            if (a != g_doubleSegment.end()) {
                if ((urlinfo.path.size() == 1) && ISFileNohost(urlinfo.path[0]) &&
                    urlinfo.path[0].size() == 2) { // 2:The interception length is 2
                    urlinfo.path[0][1] = ':';
                } else if (!urlinfo.path.empty()) {
                    urlinfo.path.pop_back();
                }
                if (i == temp.size() - 1) {
                    urlinfo.path.push_back("");
                }
                continue;
            }
            a = find(g_singlesegment.begin(), g_singlesegment.end(), temp[i]);
            if (a != g_singlesegment.end()) {
                if (i == temp.size() - 1) {
                    urlinfo.path.push_back("");
                }
                continue;
            }
            urlinfo.path.push_back(temp[i]);
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
        }
        std::string it = urlinfo.path[0];
        if (isalpha(it[0]) && (it[1] == ':' || it[1] == '|')) {
            if (it.size() == 2) { // 2:The length is 2
                it[1] = ':';
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4), 0);
                urlinfo.host.clear();
            }
        }
    }

    static void AnalysisFile(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        bool special = true;
        if ((input[0] == '/' || input[0] == '\\') && (input[1] == '/' || input[1] == '\\')) {
            std::string temp = input.substr(2); // 2:Intercept from 2 subscripts
            size_t pos = 0;
            if ((((pos = temp.find('/')) != std::string::npos) ||
                ((pos = temp.find('\\')) != std::string::npos)) && pos == 0) {
                temp = temp.substr(1);
                AnalysisFilePath(temp, urlinfo, flags);
            } else if ((((pos = temp.find('/')) != std::string::npos) ||
                ((pos = temp.find('\\')) != std::string::npos)) && pos != 0) {
                std::string strHost = temp.substr(0, pos);
                std::string strPath = temp.substr(pos + 1);
                if (!ISFileNohost(strHost)) {
                    AnalysisHost(strHost, urlinfo.host, flags, special);
                } else if (!ISFileNohost(strHost) && flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                    return;
                }
                if (!ISFileNohost(strHost)) {
                    AnalysisFilePath(strPath, urlinfo, flags);
                } else {
                    AnalysisFilePath(temp, urlinfo, flags);
                }
            } else {
                if (!temp.empty() && flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                    AnalysisHost(temp, urlinfo.host, flags, special);
                } else if (!temp.empty() && !flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                    AnalysisHost(temp, urlinfo.host, flags, special);
                    return;
                }
            }
        } else {
            if (input[0] == '/' || input[0] == '\\') {
                input = input.substr(1);
            }
            AnalysisFilePath(input, urlinfo, flags);
        }
    }

    static void AnalysisFilescheme(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        std::string strPath = urlinfo.scheme + input;
        urlinfo.scheme = "file:";
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT1));
        AnalysisFilePath(strPath, urlinfo, flags);
    }

    void AnalyInfoPath(std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> &flags,
        UrlData& urlinfo, std::string& input)
    {
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT9));
        if (urlinfo.path.empty()) {
            urlinfo.path.emplace_back("");
        }
        urlinfo.path[0] = input;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
        return;
    }

    void AnalyHostPath(std::string &strHost, std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags,
        UrlData& urlinfo)
    {
        size_t pos = 0;
        if (strHost[strHost.size() - 1] != ']' && (pos = strHost.find_last_of(':')) != std::string::npos) {
            std::string port = strHost.substr(pos + 1);
            strHost = strHost.substr(0, pos);
            AnalysisPort(port, urlinfo, flags);
            if (flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                return;
            }
        }
    }
    void AnalyStrHost(std::string &strHost, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> &flags)
    {
        if (strHost.find('@') != std::string::npos) {
            AnalysisUsernameAndPasswd(strHost, urlinfo.username, urlinfo.password, flags);
        }
        if (strHost.empty()) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
    }

    static void AnalysisNoDefaultProtocol(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (urlinfo.scheme.size() == 2) { // 2:The length is 2
            AnalysisFilescheme(input, urlinfo, flags);
            return;
        }
        if (input[0] == '/' && input[1] == '/') {
            std::string hostandpath = input.substr(2); // 2:Intercept from 2 subscripts
            if (hostandpath.empty()) {
                return;
            }
            size_t i = 0;
            bool special = false;
            if (hostandpath.find('/') != std::string::npos) {
                i = hostandpath.find('/');
                std::string strHost = hostandpath.substr(0, i);
                std::string strPath = hostandpath.substr(i + 1);
                if (strHost.find('@') != std::string::npos) {
                    AnalysisUsernameAndPasswd(strHost, urlinfo.username, urlinfo.password, flags);
                }
                if (strHost.empty()) {
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                    return;
                }
                size_t pos = 0;
                if (strHost[strHost.size() - 1] != ']' && (pos = strHost.find_last_of(':')) != std::string::npos) {
                    std::string port = strHost.substr(pos + 1);
                    strHost = strHost.substr(0, pos);
                    AnalysisPort(port, urlinfo, flags);
                }
                if (strHost[strHost.size() - 1] != ']' && (pos = strHost.find_last_of(':')) != std::string::npos &&
                    flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                    return;
                }
                AnalysisHost(strHost, urlinfo.host, flags, special);
                AnalysisPath(strPath, urlinfo.path, flags, special);
            } else {
                std::string strHost = hostandpath;
                AnalyStrHost(strHost, urlinfo, flags);
                AnalyHostPath(strHost, flags, urlinfo);
                AnalysisHost(strHost, urlinfo.host, flags, special);
            }
        } else if (input[1] == '/') {
            std::string strPath = input.substr(1);
            AnalysisPath(strPath, urlinfo.path, flags, false);
        } else {
            AnalyInfoPath(flags, urlinfo, input);
        }
    }

    static void AnalysisOnlyHost(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, size_t pos)
    {
        std::string strHost = input;
        if (strHost.find('@') != std::string::npos) {
            AnalysisUsernameAndPasswd(strHost, urlinfo.username, urlinfo.password, flags);
        }
        if (strHost.empty()) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        if (strHost[strHost.size() - 1] != ']') {
            if ((pos = strHost.find_last_of(':')) != std::string::npos) {
                std::string port = strHost.substr(pos + 1);
                strHost = strHost.substr(0, pos);
                AnalysisPort(port, urlinfo, flags);
            }
            if ((pos = strHost.find_last_of(':')) != std::string::npos &&
                flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                return;
            }
        }
        AnalysisHost(strHost, urlinfo.host, flags, true);
    }
    void JudgePos(size_t &pos, size_t &length, std::string& input)
    {
        for (pos = 0; pos < length; pos++) {
            if (input[pos] == '/' || input[pos] == '\\') {
                break;
            }
        }
    }
    static void AnalysisHostAndPath(std::string& input, UrlData& urlinfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (flags.test(static_cast<size_t>(BitsetStatusFlag::BIT1))) {
            size_t pos = 0;
            bool special = true;
            size_t inputLen = input.size();
            for (; pos < inputLen;) {
                if (input[pos] == '/' || input[pos] == '\\') {
                    pos++;
                } else {
                    break;
                }
            }
            input = input.substr(pos);
            if (input.size() == 0) {
                flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            } else if (input.size() != 0 && (input.find('/') != std::string::npos ||
                input.find('\\') != std::string::npos)) {
                size_t length = input.size();
                JudgePos(pos, length, input);
                std::string strHost = input.substr(0, pos);
                std::string strPath = input.substr(pos + 1);
                if (strHost.find('@') != std::string::npos) {
                    AnalysisUsernameAndPasswd(strHost, urlinfo.username, urlinfo.password, flags);
                }
                if (strHost.empty()) {
                    flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                    return;
                }
                if (strHost[strHost.size() - 1] != ']' && (pos = strHost.find_last_of(':')) != std::string::npos) {
                    std::string port = strHost.substr(pos + 1);
                    strHost = strHost.substr(0, pos);
                    AnalysisPort(port, urlinfo, flags);
                }
                if (strHost[strHost.size() - 1] != ']' && (pos = strHost.find_last_of(':')) != std::string::npos &&
                    flags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                    return;
                }
                AnalysisHost(strHost, urlinfo.host, flags, special);
                AnalysisPath(strPath, urlinfo.path, flags, special);
            } else if (input.size() != 0 && input.find('/') == std::string::npos &&
                input.find('\\') == std::string::npos) {
                AnalysisOnlyHost(input, urlinfo, flags, pos);
            }
        } else {
            AnalysisNoDefaultProtocol(input, urlinfo, flags);
        }
    }

    static void AnalysisInput(std::string& input, UrlData& urlData,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (input.find('#') != std::string::npos) {
            size_t i = input.find('#');
            std::string fragment = input.substr(i);
            AnalysisFragment(fragment, urlData.fragment, flags);
            input = input.substr(0, i);
        }
        if (input.find('?') != std::string::npos) {
            size_t i = input.find('?');
            std::string query = input.substr(i);
            AnalysisQuery(query, urlData.query, flags);
            input = input.substr(0, i);
        }
        bool special = (flags.test(static_cast<size_t>(BitsetStatusFlag::BIT1)) ? true : false);
        AnalysisPath(input, urlData.path, flags, special);
    }

    static void BaseInfoToUrl(const UrlData& baseInfo,
        const std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> baseflags, UrlData& urlData,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags, bool inputIsEmpty)
    {
        urlData.scheme = baseInfo.scheme;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT1),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT1)));
        urlData.host = baseInfo.host;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
        urlData.username = baseInfo.username;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT2),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT2)));
        urlData.password = baseInfo.password;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT3),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT3)));
        urlData.port = baseInfo.port;
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT5),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT5)));
        if (inputIsEmpty) {
            urlData.path = baseInfo.path;
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT6),
                baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT6)));
            urlData.query = baseInfo.query;
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT7),
                baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT7)));
            urlData.fragment = baseInfo.fragment;
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT8),
                baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT8)));
        }
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT9),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT9)));
        flags.set(static_cast<size_t>(BitsetStatusFlag::BIT10),
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT10)));
    }

    static void ShorteningPath(UrlData& baseData, bool isFile)
    {
        if (baseData.path.empty()) {
            return;
        }
        if ((baseData.path.size() == 1) && isFile &&
            isalpha(baseData.path[0][0]) && (baseData.path[0][1] == ':')) {
            return;
        }
        baseData.path.pop_back();
    }

    URL::URL(napi_env env, const std::string& input)
    {
        env_ = env;
        std::string str = input;
        DeleteC0OrSpace(str);
        DeleteTabOrNewline(str);
        InitOnlyInput(str, urlData_, flags_);
    }

    void DelCont(std::string strBase, std::string &strInput, UrlData &baseInfo,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> &baseflags)
    {
        DeleteC0OrSpace(strBase);
        DeleteTabOrNewline(strBase);
        DeleteC0OrSpace(strInput);
        DeleteTabOrNewline(strInput);
        URL::InitOnlyInput(strBase, baseInfo, baseflags);
    }

    URL::URL(napi_env env, const std::string& input, const std::string& base)
    {
        env_ = env;
        UrlData baseInfo;
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> baseflags;
        std::string strBase = base;
        std::string strInput = input;
        if (strBase.empty()) {
            baseflags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
        }
        DelCont(strBase, strInput, baseInfo, baseflags);
        if (baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        } else if (!baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
            InitOnlyInput(strInput, urlData_, flags_);
            if (!flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
                return;
            }
            if ((input[0] == '/') && (input[1] == '/' || (input[1] == '\\' &&
                baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT1))))) {
                std::string newInput = baseInfo.scheme + input;
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0), 0);
                InitOnlyInput(newInput, urlData_, flags_);
                return;
            }
            if (!baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0), 0);
                BaseInfoToUrl(baseInfo, baseflags, urlData_, flags_, input.empty());
                if (!input.empty() && input[0] == '/') {
                    strInput = input.substr(1);
                    AnalysisInput(strInput, urlData_, flags_);
                } else if (!input.empty() && input[0] != '/') {
                    AnalysisInput(strInput, urlData_, flags_);
                }
                if (!input.empty() && input[0] != '/' && urlData_.path.empty()) {
                    urlData_.path = baseInfo.path;
                    flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6),
                        baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT6)));
                }
                if (!input.empty() && input[0] != '/' && !urlData_.path.empty()) {
                    bool isFile = ((urlData_.scheme == "file:") ? true : false);
                    ShorteningPath(baseInfo, isFile);
                    baseInfo.path.insert(baseInfo.path.end(), urlData_.path.begin(), urlData_.path.end());
                    urlData_.path = baseInfo.path;
                    flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
                }
            } else if (baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
                return;
            }
        }
    }

    URL::URL(napi_env env, const std::string& input, const URL& base)
    {
        env_ = env;
        std::string strInput = input;
        UrlData baseInfo = base.urlData_;
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> baseflags = base.flags_;
        DeleteC0OrSpace(strInput);
        DeleteTabOrNewline(strInput);
        InitOnlyInput(strInput, urlData_, flags_);
        if (!flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
            return;
        }
        if ((input[0] == '/') && (input[1] == '/' || (input[1] == '\\' &&
            baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT1))))) {
            std::string newInput = baseInfo.scheme + input;
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0), 0);
            InitOnlyInput(newInput, urlData_, flags_);
            return;
        }
        if (!baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0), 0);
            BaseInfoToUrl(baseInfo, baseflags, urlData_, flags_, input.empty());
            if (!input.empty() && input[0] == '/') {
                strInput = input.substr(1);
                AnalysisInput(strInput, urlData_, flags_);
            }
            if (!input.empty() && input[0] != '/') {
                AnalysisInput(strInput, urlData_, flags_);
                if (urlData_.path.empty()) {
                    urlData_.path = baseInfo.path;
                    flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6),
                        baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT6)));
                } else {
                    bool isFile = ((urlData_.scheme == "file:") ? true : false);
                    ShorteningPath(baseInfo, isFile);
                    baseInfo.path.insert(baseInfo.path.end(), urlData_.path.begin(), urlData_.path.end());
                    urlData_.path = baseInfo.path;
                    flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
                }
            }
        } else if (baseflags.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
    }

    napi_value URL::GetHostname() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT4))) {
            temp = urlData_.host.c_str();
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetSearch() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT7))) {
            if (urlData_.query.size() == 1) {
                temp = "";
            } else {
                temp = urlData_.query.c_str();
            }
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetUsername() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT2))) {
            temp = urlData_.username.c_str();
        } else
            temp = "";
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetPassword() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT3))) {
            temp = urlData_.password.c_str();
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetFragment() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT8))) {
            if (urlData_.fragment.size() == 1) {
                temp = "";
            } else {
                temp = urlData_.fragment.c_str();
            }
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetScheme() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (!urlData_.scheme.empty()) {
            temp = urlData_.scheme.c_str();
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetPath() const
    {
        napi_value result;
        std::string temp = "/";
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT6))) {
            size_t length = urlData_.path.size();
            for (size_t i = 0; i < length; i++) {
                if (i < length - 1) {
                    temp += urlData_.path[i] + "/";
                } else {
                    temp += urlData_.path[i];
                }
            }
        } else {
            bool special = IsSpecial(urlData_.scheme);
            if (!special) {
                temp = "";
            }
        }
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp.c_str(), temp.size(), &result));
        return result;
    }


    napi_value URL::GetPort() const
    {
        napi_value result;
        const char *temp = nullptr;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT5))) {
            temp = std::to_string(urlData_.port).c_str();
        } else {
            temp = "";
        }
        size_t templen = strlen(temp);
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp, templen, &result));
        return result;
    }

    napi_value URL::GetHost() const
    {
        napi_value result;
        std::string temp1 = urlData_.host;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT5))) {
            temp1 += ":";
            temp1 += std::to_string(urlData_.port);
        }
        NAPI_CALL(env_, napi_create_string_utf8(env_, temp1.c_str(), temp1.size(), &result));
        return result;
    }

    napi_value URL::GetOnOrOff() const
    {
        napi_value result;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
            bool flag = false;
            NAPI_CALL(env_, napi_get_boolean(env_, flag, &result));
        } else {
            bool flag = true;
            NAPI_CALL(env_, napi_get_boolean(env_, flag, &result));
        }
        return result;
    }

    napi_value URL::GetIsIpv6() const
    {
        napi_value result;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT10))) {
            bool flag = true;
            NAPI_CALL(env_, napi_get_boolean(env_, flag, &result));
        } else {
            bool flag = false;
            NAPI_CALL(env_, napi_get_boolean(env_, flag, &result));
        }
        return result;
    }

    void URL::SetHostname(const std::string& input)
    {
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
            return;
        }
        std::string strHost = input;
        size_t length = strHost.size();
        for (size_t pos = 0; pos < length; pos++) {
            if ((strHost[pos] == ':') || (strHost[pos] == '?') || (strHost[pos] == '#') ||
                (strHost[pos] == '/') || (strHost[pos] == '\\')) {
                strHost = strHost.substr(0, pos);
                break;
            }
        }
        if (strHost.size() == 0) {
            return;
        }
        bool special = IsSpecial(urlData_.scheme);
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFlags;
        std::string thisHostname = "";
        AnalysisHost(strHost, thisHostname, thisFlags, special);
        if (thisFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT4))) {
            if ((urlData_.scheme == "file:") && (thisHostname == "localhost")) {
                thisHostname = "";
            }
            urlData_.host = thisHostname;
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
        }
    }

    void URL::SetHref(const std::string& input)
    {
        std::string str = input;
        DeleteC0OrSpace(str);
        DeleteTabOrNewline(str);
        UrlData thisNewUrl;
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisNewFlags;
        InitOnlyInput(str, thisNewUrl, thisNewFlags);
        if (!thisNewFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT0))) {
            urlData_ = thisNewUrl;
            flags_ = thisNewFlags;
        }
    }

    void URL::SetPath(const std::string& input)
    {
        std::string strPath = input;
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
            return;
        }
        if (strPath.empty()) {
            return;
        }
        std::string oldstr = "%3A";
        std::string newstr = ":";
        ReplaceSpecialSymbols(strPath, oldstr, newstr);
        bool special = IsSpecial(urlData_.scheme);
        if (urlData_.scheme == "file:") {
            UrlData thisFileDate;
            std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFileFlag;
            if ((strPath[0] == '/') || (strPath[0] == '\\' &&
                flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT1)))) {
                strPath = strPath.substr(1);
            }
            AnalysisFilePath(strPath, thisFileDate, thisFileFlag);
            if (thisFileFlag.test(static_cast<size_t>(BitsetStatusFlag::BIT6))) {
                urlData_.path = thisFileDate.path;
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
            }
        } else {
            std::vector<std::string> thisPath;
            std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFlags;
            if ((strPath[0] == '/') || (strPath[0] == '\\' &&
                flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT1)))) {
                strPath = strPath.substr(1);
            }
            AnalysisPath(strPath, thisPath, thisFlags, special);
            if (thisFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT6))) {
                urlData_.path = thisPath;
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT6));
            }
        }
    }

    void SplitString(const std::string& input, std::string& strHost, std::string& port)
    {
        size_t strlen = input.size();
        for (size_t pos = 0; pos < strlen; pos++) {
            if ((input[pos] == ':') || (input[pos] == '?') || (input[pos] == '#') ||
                (input[pos] == '/') || (input[pos] == '\\')) {
                strHost = input.substr(0, pos);
                if (input[pos] == ':') {
                    pos++;
                    port = input.substr(pos);
                }
                break;
            }
        }
    }

    void URL::SetHost(const std::string& input)
    {
        if (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT9))) {
            return;
        }
        if (input.empty()) {
            return;
        }
        std::string strHost = input;
        std::string port = "";
        SplitString(input, strHost, port);
        if (strHost.size() == 0) {
            return;
        }
        bool special = IsSpecial(urlData_.scheme);
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> hostnameflags;
        std::string thisHostname = "";
        AnalysisHost(strHost, thisHostname, hostnameflags, special);
        if (hostnameflags.test(static_cast<size_t>(BitsetStatusFlag::BIT4))) {
            if ((urlData_.scheme == "file:") && (thisHostname == "localhost")) {
                thisHostname = "";
            }
            urlData_.host = thisHostname;
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT4));
        } else {
            return;
        }
        if (port.size() > 0) {
            size_t strlen = port.size();
            for (size_t pos = 0; pos < strlen; pos++) {
                if ((port[pos] == '?') || (port[pos] == '#') || (port[pos] == '/') || (port[pos] == '\\')) {
                    port = port.substr(0, pos);
                    break;
                }
            }
            if (port.size() > 0) {
                std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFlags;
                UrlData thisport;
                AnalysisPort(port, thisport, thisFlags);
                if (thisFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT5))) {
                    flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT5));
                    urlData_.port = thisport.port;
                }
            }
        }
    }

    void URL::SetPort(const std::string& input)
    {
        std::string port = input;
        size_t portlen = port.size();
        for (size_t pos = 0; pos < portlen; pos++) {
            if ((port[pos] == '?') || (port[pos] == '#') || (port[pos] == '/') || (port[pos] == '\\')) {
                port = port.substr(0, pos);
                break;
            }
        }
        if (port.size() > 0) {
            std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFlags;
            UrlData thisport;
            AnalysisPort(port, thisport, thisFlags);
            if (thisFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT5))) {
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT5));
                urlData_.port = thisport.port;
            }
        }
    }

    void URL::SetSearch(const std::string& input)
    {
        std::string temp;
        if (input.size() == 0) {
            urlData_.query = "";
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT7), 0);
        } else {
            if (input[0] != '?') {
                temp = "?";
                temp += input;
            } else {
                temp = input;
            }
            std::string oldstr = "#";
            std::string newstr = "%23";
            ReplaceSpecialSymbols(temp, oldstr, newstr);
            AnalysisQuery(temp, urlData_.query, flags_);
        }
    }

    void URL::SetFragment(const std::string& input)
    {
        std::string temp;
        if (input.size() == 0) {
            urlData_.fragment = "";
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT8), 0);
        } else {
            if (input[0] != '#') {
                temp = "#";
                temp += input;
            } else {
                temp = input;
            }
            AnalysisFragment(temp, urlData_.fragment, flags_);
        }
    }

    void URL::SetScheme(const std::string& input)
    {
        std::string strInput = input;
        bool special = IsSpecial(urlData_.scheme);
        bool inputIsSpecial = IsSpecial(input);
        if ((special != inputIsSpecial) || ((input == "file") &&
            (flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT2)) ||
            flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT3)) ||
            flags_.test(static_cast<size_t>(BitsetStatusFlag::BIT5))))) {
            return;
        }
        std::string thisScheme = "";
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)> thisFlags;
        if (AnalysisScheme(strInput, thisScheme, thisFlags)) {
            if (thisFlags.test(static_cast<size_t>(BitsetStatusFlag::BIT1))) {
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT1));
            }
            urlData_.scheme = thisScheme;
        }
    }

    void URL::SetUsername(const std::string& input)
    {
        if (input.size() == 0) {
            urlData_.username = "";
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT2), 0);
        } else {
            if (!input.empty()) {
                std::string usname = input;
                std::string oldstr = "@";
                std::string newstr = "%40";
                ReplaceSpecialSymbols(usname, oldstr, newstr);
                oldstr = "/";
                newstr = "%2F";
                ReplaceSpecialSymbols(usname, oldstr, newstr);
                urlData_.username = usname;
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT2));
            }
        }
    }

    void URL::SetPassword(const std::string& input)
    {
        if (input.size() == 0) {
            urlData_.password = "";
            flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT3), 0);
        } else {
            if (!input.empty()) {
                std::string keyWord = input;
                std::string oldstr = "@";
                std::string newstr = "%40";
                ReplaceSpecialSymbols(keyWord, oldstr, newstr);
                oldstr = "/";
                newstr = "%2F";
                ReplaceSpecialSymbols(keyWord, oldstr, newstr);
                urlData_.password = keyWord;
                flags_.set(static_cast<size_t>(BitsetStatusFlag::BIT3));
            }
        }
    }

    void URL::InitOnlyInput(std::string& input, UrlData& urlData,
        std::bitset<static_cast<size_t>(BitsetStatusFlag::BIT_STATUS_11)>& flags)
    {
        if (input.empty()) {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
        if (input.find(':') != std::string::npos) {
            size_t pos = input.find(':');
            pos++;
            std::string scheme = input.substr(0, pos);
            if (!AnalysisScheme(scheme, urlData.scheme, flags)) {
                return;
            }
            if (input.find('#') != std::string::npos) {
                size_t i = input.find('#');
                std::string fragment = input.substr(i);
                AnalysisFragment(fragment, urlData.fragment, flags);
                input = input.substr(0, i);
            }
            if (input.find('?') != std::string::npos) {
                size_t i = input.find('?');
                std::string query = input.substr(i);
                AnalysisQuery(query, urlData.query, flags);
                input = input.substr(0, i);
            }
            std::string str = input.substr(pos);
            if (urlData.scheme == "file:") {
                AnalysisFile(str, urlData, flags);
            } else {
                AnalysisHostAndPath(str, urlData, flags);
            }
        } else {
            flags.set(static_cast<size_t>(BitsetStatusFlag::BIT0));
            return;
        }
    }

    URLSearchParams::URLSearchParams(napi_env env) : env(env)
    {}
    std::wstring StrToWstr(const std::string& str)
    {
        char *p = setlocale(LC_ALL, "");
        if (p == nullptr) {
            return L"";
        }
        std::wstring wstr = L"";
        size_t len = str.size() + 1;
        if (len > 0) {
            auto wch = new wchar_t[len];
            mbstowcs(wch, str.c_str(), len);
            wstr = wch;
            delete[] wch;
            p = setlocale(LC_ALL, "");
            if (p == nullptr) {
            return L"";
            }
            return wstr;
        }
        return wstr;
    }

    bool IsEscapeRange(const char charaEncode)
    {
        if ((charaEncode > 0 && charaEncode < '*') ||
            (charaEncode > '*' && charaEncode < '-') ||
            (charaEncode == '/') ||
            (charaEncode > '9' && charaEncode < 'A') ||
            (charaEncode > 'Z' && charaEncode < '_') ||
            (charaEncode == '`') ||
            (charaEncode > 'z')) {
            return true;
        }
        return false;
    }

    size_t CharToUnicode(std::string str, size_t &i)
    {
        size_t bytOfSpeChar = 3; // 3:Bytes of special characters in Linux
        std::string subStr = str.substr(i, bytOfSpeChar);
        i += 2; // 2:Searching for the number and number of keys and values
        std::wstring wstr = StrToWstr(subStr.c_str());
        wchar_t wch = wstr[0];
        auto charaEncode = static_cast<size_t>(wch);
        return charaEncode;
    }
    std::string ReviseStr(std::string str, std::string *reviseChar)
    {
        const size_t lenStr = str.length();
        if (lenStr == 0) {
            return "";
        }
        std::string output = "";
        size_t numOfAscii = 128; // 128:Number of ASCII characters
        size_t i = 0;
        for (; i < lenStr; i++) {
            auto charaEncode = static_cast<size_t>(str[i]);
            if (charaEncode < 0 || charaEncode >= numOfAscii) {
                charaEncode = CharToUnicode(str, i);
            }
            if (charaEncode >= 0 && charaEncode < numOfAscii) {
                // 2:Defines the escape range of ASCII characters
                if (IsEscapeRange(charaEncode)) {
                    output += reviseChar[charaEncode];
                } else {
                    output += str.substr(i, 1);
                }
            } else if (charaEncode <= 0x000007FF) { // Convert the Unicode code into two bytes
                std::string output1 = reviseChar[0x000000C0 |
                    (charaEncode / 64)]; // 64:Acquisition method of the first byte
                std::string output2 = reviseChar[numOfAscii |
                    (charaEncode & 0x0000003F)]; // Acquisition method of the second byte
                output += output1 + output2;
            } else if ((charaEncode >= 0x0000E000) ||
                        (charaEncode <= 0x0000D7FF)) { // Convert the Unicode code into three bytes
                std::string output1 = reviseChar[0x000000E0 |
                    (charaEncode / 4096)]; // 4096:Acquisition method of the first byte
                std::string output2 = reviseChar[numOfAscii |
                    ((charaEncode / 64) & 0x0000003F)]; // 64:method of the second byte
                std::string output3 = reviseChar[numOfAscii |
                    (charaEncode & 0x0000003F)]; // Acquisition method of the third  byte
                output += output1 + output2 + output3;
            } else {
                const size_t charaEncode1 = static_cast<size_t>(str[++i]) & 1023; // 1023:Convert codes
                charaEncode = 65536 + (((charaEncode & 1023) << 10) |
                    charaEncode1); // 65536:Specific transcoding method
                std::string output1 = reviseChar[0x000000F0 |
                    (charaEncode / 262144)]; // 262144:Acquisition method of the first byte
                std::string output2 = reviseChar[numOfAscii |
                    ((charaEncode / 4096) & 0x0000003F)]; // 4096:Acquisition method of the second byte
                std::string output3 = reviseChar[numOfAscii |
                    ((charaEncode / 64) & 0x0000003F)]; // 64:Acquisition method of the third  byte
                std::string output4 = reviseChar[numOfAscii |
                    (charaEncode & 0x0000003F)]; // Acquisition method of the fourth   byte
                output += output1 + output2 + output3 + output4;
            }
        }
        return output;
    }

    napi_value URLSearchParams::ToString()
    {
        std::string output = "";
        std::string reviseChar[256] = {""}; // 256:Array length
        for (size_t i = 0; i < 256; ++i) { // 256:Array length
            size_t j = i;
            std::stringstream ioss;
            std::string str1 = "";
            ioss << std::hex << j;
            ioss >> str1;
            transform(str1.begin(), str1.end(), str1.begin(), ::toupper);
            if (i < 16) { // 16:Total number of 0-F
                reviseChar[i] = '%' + ("0" + str1);
            } else {
                reviseChar[i] = '%' + str1;
            }
        }
        reviseChar[0x20] = "+"; // 0x20:ASCII value of spaces
        const size_t lenStr = searchParams.size();
        if (lenStr == 0) {
            napi_value result = nullptr;
            napi_create_string_utf8(env, output.c_str(), output.size(), &result);
            return result;
        }
        std::string firstStrKey = ReviseStr(searchParams[0], reviseChar);
        std::string firstStrValue = ReviseStr(searchParams[1], reviseChar);
        output = firstStrKey + "=" + firstStrValue;
        if (lenStr % 2 == 0) { // 2:Divisible by 2
            size_t i = 2; // 2:Initial Position
            for (; i < lenStr; i += 2) { // 2:Searching for the number and number of keys and values
                std::string strKey = ReviseStr(searchParams[i], reviseChar);
                std::string strValue = ReviseStr(searchParams[i + 1], reviseChar);
                output += +"&" + strKey + "=" + strValue;
            }
        }
        napi_value result = nullptr;
        napi_create_string_utf8(env, output.c_str(), output.size(), &result);
        return result;
    }
    void URLSearchParams::HandleIllegalChar(std::wstring& inputStr, std::wstring::const_iterator it)
    {
        std::wstring::iterator iter = inputStr.begin();
        advance(iter, std::distance<std::wstring::const_iterator>(iter, it));
        while (iter != inputStr.end()) {
            char16_t ch = *iter;
            if (!((ch & 0xF800) == 0xD800)) {
                ++iter;
                continue;
            } else if ((ch & 0x400) != 0 || iter == inputStr.end() - 1) {
                *iter = 0xFFFD;
            } else {
                char16_t dh = *(iter + 1);
                if ((dh & 0xFC00) == 0xDC00) {
                    ++iter;
                } else {
                    *iter = 0xFFFD;
                }
            }
            ++iter;
        }
    }
    std::string URLSearchParams::ToUSVString(std::string inputStr)
    {
        size_t strLen = strlen(inputStr.c_str());
        wchar_t *strPtr = nullptr;
        std::wstring winput = L"";
        int strSize = mbstowcs(strPtr, inputStr.c_str(), 0) + 1;
        if (strSize > 0) {
            strPtr = new wchar_t[strSize];
            mbstowcs(strPtr, inputStr.c_str(), strLen);
            winput = strPtr;
        }
        const char *expr = "(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])";
        size_t exprLen = strlen(expr);
        wchar_t *exprPtr = nullptr;
        int exprSize = mbstowcs(exprPtr, expr, 0) + 1;
        if (exprSize > 0) {
            exprPtr = new wchar_t[exprSize];
            mbstowcs(exprPtr, expr, exprLen);
        }
        std::wregex wexpr(exprPtr);
        delete[] exprPtr;
        std::wsmatch result;
        delete[] strPtr;
        std::wstring::const_iterator iterStart = winput.begin();
        std::wstring::const_iterator iterEnd = winput.end();
        if (!regex_search(iterStart, iterEnd, result, wexpr)) {
            return inputStr;
        }
        HandleIllegalChar(winput, result[0].first);
        size_t inputLen = wcslen(winput.c_str());
        char *rePtr = nullptr;
        std::string reStr = "";
        int reSize = wcstombs(rePtr, winput.c_str(), 0) + 1;
        if (reSize > 0) {
            rePtr = new char[reSize];
            if (memset_s(rePtr, reSize, 0, reSize) != 0) {
                HILOG_ERROR("ToUSVString memset_s failed");
                delete[] rePtr;
                return reStr;
            } else {
                wcstombs(rePtr, winput.c_str(), inputLen);
                reStr = rePtr;
            }
        }
        delete[] rePtr;
        return reStr;
    }
    napi_value URLSearchParams::Get(napi_value buffer)
    {
        char *name = nullptr;
        size_t nameSize = 0;
        std::string temp = "";
        napi_get_value_string_utf8(env, buffer, nullptr, 0, &nameSize);
        if (nameSize > 0) {
            name = new char[nameSize + 1];
            napi_get_value_string_utf8(env, buffer, name, nameSize + 1, &nameSize);
            temp = name;
        }
        std::string sname = ToUSVString(temp);
        delete[] name;
        napi_value result = nullptr;
        if (searchParams.size() == 0) {
            return result;
        }
        size_t size = searchParams.size() - 1;
        for (size_t i = 0; i < size; i += 2) { // 2:Searching for the number and number of keys and values
            if (searchParams[i] == sname) {
                std::string str = searchParams[i + 1];
                napi_create_string_utf8(env, searchParams[i + 1].c_str(), searchParams[i + 1].length(), &result);
                return result;
            }
        }
        return result;
    }
    napi_value URLSearchParams::GetAll(napi_value buffer)
    {
        char *name = nullptr;
        size_t nameSize = 0;
        std::string sname = "";
        napi_get_value_string_utf8(env, buffer, nullptr, 0, &nameSize);
        if (nameSize > 0) {
            name = new char[nameSize + 1];
            napi_get_value_string_utf8(env, buffer, name, nameSize + 1, &nameSize);
            sname = ToUSVString(name);
        }
        delete[] name;
        napi_value result = nullptr;
        napi_value napiStr = nullptr;
        NAPI_CALL(env, napi_create_array(env, &result));
        size_t flag = 0;
        if (searchParams.size() == 0) {
            return result;
        }
        size_t size = searchParams.size() - 1;
        for (size_t i = 0; i < size; i += 2) { // 2:Searching for the number and number of keys and values
            if (searchParams[i] == sname) {
                napi_create_string_utf8(env, searchParams[i + 1].c_str(), searchParams[i + 1].length(), &napiStr);
                napi_status status = napi_set_element(env, result, flag, napiStr);
                if (status != napi_ok) {
                    HILOG_INFO("set element error");
                }
                flag++;
            }
        }
        return result;
    }
    void URLSearchParams::Append(napi_value buffer, napi_value temp)
    {
        char *name = nullptr;
        size_t nameSize = 0;
        std::string tempName = "";
        std::string tempValue = "";
        napi_get_value_string_utf8(env, buffer, nullptr, 0, &nameSize);
        if (nameSize > 0) {
            name = new char[nameSize + 1];
            napi_get_value_string_utf8(env, buffer, name, nameSize + 1, &nameSize);
            tempName = name;
        }
        char *value = nullptr;
        size_t valueSize = 0;
        napi_get_value_string_utf8(env, temp, nullptr, 0, &valueSize);
        if (valueSize > 0) {
            value = new char[valueSize + 1];
            napi_get_value_string_utf8(env, temp, value, valueSize + 1, &valueSize);
            tempValue = value;
        }
        searchParams.push_back(tempName);
        searchParams.push_back(tempValue);
        delete[] name;
        delete[] value;
    }
    void URLSearchParams::Delete(napi_value buffer)
    {
        char *name = nullptr;
        size_t nameSize = 0;
        std::string sname = "";
        napi_get_value_string_utf8(env, buffer, nullptr, 0, &nameSize);
        if (nameSize > 0) {
            name = new char[nameSize + 1];
            napi_get_value_string_utf8(env, buffer, name, nameSize + 1, &nameSize);
            sname = ToUSVString(name);
        }
        delete[] name;
        for (std::vector<std::string>::iterator iter = searchParams.begin(); iter != searchParams.end();) {
            if (*iter == sname) {
                iter = searchParams.erase(iter, iter + 2); // 2:Searching for the number and number of keys and values
            } else {
                iter += 2; // 2:Searching for the number and number of keys and values
            }
        }
    }
    napi_value URLSearchParams::Entries() const
    {
        napi_value resend = nullptr;
        napi_value firNapiStr = nullptr;
        napi_value secNapiStr = nullptr;
        napi_create_array(env, &resend);
        if (searchParams.size() == 0) {
            return resend;
        }
        size_t size = searchParams.size() - 1;
        for (size_t i = 0; i < size; i += 2) { // 2:Searching for the number and number of keys and values
            napi_value result = nullptr;
            napi_create_array(env, &result);

            napi_create_string_utf8(env, searchParams[i].c_str(), searchParams[i].length(), &firNapiStr);
            napi_create_string_utf8(env, searchParams[i + 1].c_str(), searchParams[i + 1].length(), &secNapiStr);
            napi_set_element(env, result, 0, firNapiStr);
            napi_set_element(env, result, 1, secNapiStr);
            napi_set_element(env, resend, i / 2, result); // 2:Find the number of keys
        }
        return resend;
    }
    void URLSearchParams::ForEach(napi_value function, napi_value thisVar)
    {
        if (searchParams.size() == 0) {
            return;
        }
        size_t size = searchParams.size() - 1;
        for (size_t i = 0; i < size; i += 2) { // 2:Searching for the number and number of keys and values
            napi_value returnVal = nullptr;
            size_t argc = 3;
            napi_value global = nullptr;
            napi_get_global(env, &global);
            napi_value key = nullptr;
            napi_create_string_utf8(env, searchParams[i].c_str(), strlen(searchParams[i].c_str()), &key);
            napi_value value = nullptr;
            napi_create_string_utf8(env, searchParams[i + 1].c_str(), strlen(searchParams[i + 1].c_str()), &value);
            napi_value argv[3] = {key, value, thisVar};
            napi_call_function(env, global, function, argc, argv, &returnVal);
        }
    }
    napi_value URLSearchParams::IsHas(napi_value name) const
    {
        char *buffer = nullptr;
        size_t bufferSize = 0;
        std::string buf = "";
        napi_get_value_string_utf8(env, name, nullptr, 0, &bufferSize);
        if (bufferSize > 0) {
            buffer = new char[bufferSize + 1];
            napi_get_value_string_utf8(env, name, buffer, bufferSize + 1, &bufferSize);
            buf = buffer;
        }
        bool flag = false;
        napi_value result = nullptr;
        size_t lenStr = searchParams.size();
        for (size_t i = 0; i != lenStr; i += 2) { // 2:Searching for the number and number of keys and values
            if (searchParams[i] == buf) {
                flag = true;
                napi_get_boolean(env, flag, &result);
                return result;
            }
        }
        delete []buffer;
        napi_get_boolean(env, flag, &result);
        return result;
    }
    void URLSearchParams::Set(napi_value name, napi_value value)
    {
        char *buffer0 = nullptr;
        size_t bufferSize0 = 0;
        std::string cppName = "";
        std::string cppValue = "";
        napi_get_value_string_utf8(env, name, nullptr, 0, &bufferSize0);
        if (bufferSize0 > 0) {
            buffer0 = new char[bufferSize0 + 1];
            napi_get_value_string_utf8(env, name, buffer0, bufferSize0 + 1, &bufferSize0);
            cppName = buffer0;
            delete[] buffer0;
        }
        char *buffer1 = nullptr;
        size_t bufferSize1 = 0;
        napi_get_value_string_utf8(env, value, nullptr, 0, &bufferSize1);
        if (bufferSize1 > 0) {
            buffer1 = new char[bufferSize1 + 1];
            napi_get_value_string_utf8(env, value, buffer1, bufferSize1 + 1, &bufferSize1);
            cppValue = buffer1;
            delete[] buffer1;
        }
        bool flag = false;
        for (std::vector<std::string>::iterator it = searchParams.begin(); it < searchParams.end() - 1;) {
            if (*it == cppName) {
                if (!flag) {
                    *(it + 1) = cppValue;
                    flag = true;
                    it += 2; // 2:Searching for the number and number of keys and values
                } else {
                    it = searchParams.erase(it, it + 2); // 2:Searching for the number and number of keys and values
                }
            } else {
                it += 2; // 2:Searching for the number and number of keys and values
            }
        }
        if (!flag) {
            searchParams.push_back(cppName);
            searchParams.push_back(cppValue);
        }
    }
    void URLSearchParams::Sort()
    {
        unsigned int len = searchParams.size();
        if (len <= 2 && (len % 2 != 0)) { // 2: Iterate over key-value pairs
            return;
        }
        unsigned int i = 0;
        for (; i < len - 2; i += 2) { // 2:Iterate over key-value pairs
            unsigned int  j = i + 2; // 2:Iterate over key-value pairs
            for (; j < len; j += 2) { // 2:Iterate over key-value pairs
                bool tmp = (searchParams[i] > searchParams[j]);
                if (tmp) {
                    const std::string curKey = searchParams[i];
                    const std::string curVal = searchParams[i + 1];
                    searchParams[i] = searchParams[j];
                    searchParams[i + 1] = searchParams[j + 1];
                    searchParams[j] = curKey;
                    searchParams[j + 1] = curVal;
                }
            }
        }
    }
    napi_value URLSearchParams::IterByKeys()
    {
        std::vector<std::string> toKeys;
        napi_value result = nullptr;
        napi_value napiStr = nullptr;
        napi_create_array(env, &result);
        size_t stepSize = 2; // 2:Searching for the number and number of keys and values
        size_t lenStr = searchParams.size();
        if (lenStr % 2 == 0) { // 2:Get the number of values
            for (auto it = searchParams.begin(); it != searchParams.end(); it += stepSize) {
                toKeys.push_back(*it);
            }
            size_t lenToKeys = toKeys.size();
            for (size_t i = 0; i < lenToKeys; i++) {
                napi_create_string_utf8(env, toKeys[i].c_str(), toKeys[i].length(), &napiStr);
                napi_set_element(env, result, i, napiStr);
            }
        }
        return result;
    }
    napi_value URLSearchParams::IterByValues()
    {
        std::vector<std::string> toKeys;
        napi_value result = nullptr;
        napi_value napiStr = nullptr;
        napi_create_array(env, &result);
        size_t stepSize = 2; // 2:Searching for the number and number of keys and values
        size_t lenStr = searchParams.size();
        if (lenStr % 2 == 0) { // 2:Get the number of values
            for (auto it = searchParams.begin();
                it != searchParams.end();
                it += stepSize) {
                toKeys.push_back(*(it + 1));
            }
            size_t lenToKeys = toKeys.size();
            for (size_t i = 0; i < lenToKeys; i++) {
                napi_create_string_utf8(env, toKeys[i].c_str(), toKeys[i].length(), &napiStr);
                napi_set_element(env, result, i, napiStr);
            }
        }
        return result;
    }
    void URLSearchParams::SetArray(const std::vector<std::string> vec)
    {
        searchParams = vec;
    }
    napi_value URLSearchParams::GetArray() const
    {
        napi_value arr = nullptr;
        napi_create_array(env, &arr);
        size_t length = searchParams.size();
        for (size_t i = 0; i < length; i++) {
            napi_value result = nullptr;
            napi_create_string_utf8(env, searchParams[i].c_str(), searchParams[i].size(), &result);
            napi_set_element(env, arr, i, result);
        }
        return arr;
    }
} // namespace