/* auto-generated on 2025-07-13 10:46:57 -0400. Do not edit! */

/* begin file include/simdutf.h */

#ifndef SIMDUTF_H

#define SIMDUTF_H

#include <cstring>

/* begin file include/simdutf/compiler_check.h */

#ifndef SIMDUTF_COMPILER_CHECK_H

#define SIMDUTF_COMPILER_CHECK_H

#ifndef __cplusplus

  #error simdutf requires a C++ compiler

#endif

#ifndef SIMDUTF_CPLUSPLUS

  #if defined(_MSVC_LANG) && !defined(__clang__)

    #define SIMDUTF_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)

  #else

    #define SIMDUTF_CPLUSPLUS __cplusplus

  #endif

#endif

// C++ 23

#if !defined(SIMDUTF_CPLUSPLUS23) && (SIMDUTF_CPLUSPLUS >= 202302L)

  #define SIMDUTF_CPLUSPLUS23 1

#endif

// C++ 20

#if !defined(SIMDUTF_CPLUSPLUS20) && (SIMDUTF_CPLUSPLUS >= 202002L)

  #define SIMDUTF_CPLUSPLUS20 1

#endif

// C++ 17

#if !defined(SIMDUTF_CPLUSPLUS17) && (SIMDUTF_CPLUSPLUS >= 201703L)

  #define SIMDUTF_CPLUSPLUS17 1

#endif

// C++ 14

#if !defined(SIMDUTF_CPLUSPLUS14) && (SIMDUTF_CPLUSPLUS >= 201402L)

  #define SIMDUTF_CPLUSPLUS14 1

#endif

// C++ 11

#if !defined(SIMDUTF_CPLUSPLUS11) && (SIMDUTF_CPLUSPLUS >= 201103L)

  #define SIMDUTF_CPLUSPLUS11 1

#endif

#ifndef SIMDUTF_CPLUSPLUS11

  #error simdutf requires a compiler compliant with the C++11 standard

#endif

#endif // SIMDUTF_COMPILER_CHECK_H

/* end file include/simdutf/compiler_check.h */

/* begin file include/simdutf/common_defs.h */

#ifndef SIMDUTF_COMMON_DEFS_H

#define SIMDUTF_COMMON_DEFS_H

/* begin file include/simdutf/portability.h */

#ifndef SIMDUTF_PORTABILITY_H

#define SIMDUTF_PORTABILITY_H

#include <cfloat>

#include <cstddef>

#include <cstdint>

#include <cstdlib>

#ifndef _WIN32

  // strcasecmp, strncasecmp

  #include <strings.h>

#endif

#if defined(__apple_build_version__)

  #if __apple_build_version__ < 14000000

    #define SIMDUTF_SPAN_DISABLED                                              \

      1 // apple-clang/13 doesn't support std::convertible_to

  #endif

#endif

#if SIMDUTF_CPLUSPLUS20

  #include <version>

  #if __cpp_concepts >= 201907L && __cpp_lib_span >= 202002L &&                \

      !defined(SIMDUTF_SPAN_DISABLED)

    #define SIMDUTF_SPAN 1

  #endif // __cpp_concepts >= 201907L && __cpp_lib_span >= 202002L

  #if __cpp_lib_atomic_ref >= 201806L

    #define SIMDUTF_ATOMIC_REF 1

  #endif // __cpp_lib_atomic_ref

  #if __has_cpp_attribute(maybe_unused) >= 201603L

    #define SIMDUTF_MAYBE_UNUSED_AVAILABLE 1

  #endif // __has_cpp_attribute(maybe_unused) >= 201603L

#endif

/**

 * We want to check that it is actually a little endian system at

 * compile-time.

 */

#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)

  #define SIMDUTF_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

#elif defined(_WIN32)

  #define SIMDUTF_IS_BIG_ENDIAN 0

#else

  #if defined(__APPLE__) ||                                                    \

      defined(__FreeBSD__) // defined __BYTE_ORDER__ && defined

                           // __ORDER_BIG_ENDIAN__

    #include <machine/endian.h>

  #elif defined(sun) ||                                                        \

      defined(__sun) // defined(__APPLE__) || defined(__FreeBSD__)

    #include <sys/byteorder.h>

  #else // defined(__APPLE__) || defined(__FreeBSD__)

    #ifdef __has_include

      #if __has_include(<endian.h>)

        #include <endian.h>

      #endif //__has_include(<endian.h>)

    #endif   //__has_include

  #endif // defined(__APPLE__) || defined(__FreeBSD__)

  #ifndef !defined(__BYTE_ORDER__) || !defined(__ORDER_LITTLE_ENDIAN__)

    #define SIMDUTF_IS_BIG_ENDIAN 0

  #endif

  #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

    #define SIMDUTF_IS_BIG_ENDIAN 0

  #else // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

    #define SIMDUTF_IS_BIG_ENDIAN 1

  #endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

#endif // defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__

/**

 * At this point in time, SIMDUTF_IS_BIG_ENDIAN is defined.

 */

#ifdef _MSC_VER

  #define SIMDUTF_VISUAL_STUDIO 1

  /**

   * We want to differentiate carefully between

   * clang under visual studio and regular visual

   * studio.

   *

   * Under clang for Windows, we enable:

   *  * target pragmas so that part and only part of the

   *     code gets compiled for advanced instructions.

   *

   */

  #ifdef __clang__

    // clang under visual studio

    #define SIMDUTF_CLANG_VISUAL_STUDIO 1

  #else

    // just regular visual studio (best guess)

    #define SIMDUTF_REGULAR_VISUAL_STUDIO 1

  #endif // __clang__

#endif   // _MSC_VER

#ifdef SIMDUTF_REGULAR_VISUAL_STUDIO

  // https://en.wikipedia.org/wiki/C_alternative_tokens

  // This header should have no effect, except maybe

  // under Visual Studio.

  #include <iso646.h>

#endif

#if (defined(__x86_64__) || defined(_M_AMD64)) && !defined(_M_ARM64EC)

  #define SIMDUTF_IS_X86_64 1

#elif defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)

  #define SIMDUTF_IS_ARM64 1

#elif defined(__PPC64__) || defined(_M_PPC64)

  #if defined(__VEC__) && defined(__ALTIVEC__)

    #define SIMDUTF_IS_PPC64 1

  #endif

#elif defined(__s390__)

// s390 IBM system. Big endian.

#elif (defined(__riscv) || defined(__riscv__)) && __riscv_xlen == 64

  // RISC-V 64-bit

  #define SIMDUTF_IS_RISCV64 1

  // #if __riscv_v_intrinsic >= 1000000

  //   #define SIMDUTF_HAS_RVV_INTRINSICS 1

  //   #define SIMDUTF_HAS_RVV_TARGET_REGION 1

  // #elif ...

  //  Check for special compiler versions that implement pre v1.0 intrinsics

  #if __riscv_v_intrinsic >= 11000

    #define SIMDUTF_HAS_RVV_INTRINSICS 1

  #endif

  #define SIMDUTF_HAS_ZVBB_INTRINSICS                                          \

    0 // there is currently no way to detect this

  #if SIMDUTF_HAS_RVV_INTRINSICS && __riscv_vector &&                          \

      __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64

    // RISC-V V extension

    #define SIMDUTF_IS_RVV 1

    #if SIMDUTF_HAS_ZVBB_INTRINSICS && __riscv_zvbb >= 1000000

      // RISC-V Vector Basic Bit-manipulation

      #define SIMDUTF_IS_ZVBB 1

    #endif

  #endif

#elif defined(__loongarch_lp64)

  #if defined(__loongarch_sx) && defined(__loongarch_asx)

    #define SIMDUTF_IS_LSX 1

    #define SIMDUTF_IS_LASX 1

  #elif defined(__loongarch_sx)

    #define SIMDUTF_IS_LSX 1

  #endif

#else

  // The simdutf library is designed

  // for 64-bit processors and it seems that you are not

  // compiling for a known 64-bit platform. Please

  // use a 64-bit target such as x64 or 64-bit ARM for best performance.

  #define SIMDUTF_IS_32BITS 1

  // We do not support 32-bit platforms, but it can be

  // handy to identify them.

  #if defined(_M_IX86) || defined(__i386__)

    #define SIMDUTF_IS_X86_32BITS 1

  #elif defined(__arm__) || defined(_M_ARM)

    #define SIMDUTF_IS_ARM_32BITS 1

  #elif defined(__PPC__) || defined(_M_PPC)

    #define SIMDUTF_IS_PPC_32BITS 1

  #endif

#endif // defined(__x86_64__) || defined(_M_AMD64)

#ifdef SIMDUTF_IS_32BITS

  #ifndef SIMDUTF_NO_PORTABILITY_WARNING

  // In the future, we may want to warn users of 32-bit systems that

  // the simdutf does not support accelerated kernels for such systems.

  #endif // SIMDUTF_NO_PORTABILITY_WARNING

#endif   // SIMDUTF_IS_32BITS

// this is almost standard?

#define SIMDUTF_STRINGIFY_IMPLEMENTATION_(a) #a

#define SIMDUTF_STRINGIFY(a) SIMDUTF_STRINGIFY_IMPLEMENTATION_(a)

// Our fast kernels require 64-bit systems.

//

// On 32-bit x86, we lack 64-bit popcnt, lzcnt, blsr instructions.

// Furthermore, the number of SIMD registers is reduced.

//

// On 32-bit ARM, we would have smaller registers.

//

// The simdutf users should still have the fallback kernel. It is

// slower, but it should run everywhere.

//

// Enable valid runtime implementations, and select

// SIMDUTF_BUILTIN_IMPLEMENTATION

//

// We are going to use runtime dispatch.

#ifdef SIMDUTF_IS_X86_64

  #ifdef __clang__

    // clang does not have GCC push pop

    // warning: clang attribute push can't be used within a namespace in clang

    // up til 8.0 so SIMDUTF_TARGET_REGION and SIMDUTF_UNTARGET_REGION must be

    // *outside* of a namespace.

    #define SIMDUTF_TARGET_REGION(T)                                           \

      _Pragma(SIMDUTF_STRINGIFY(clang attribute push(                          \

          __attribute__((target(T))), apply_to = function)))

    #define SIMDUTF_UNTARGET_REGION _Pragma("clang attribute pop")

  #elif defined(__GNUC__)

    // GCC is easier

    #define SIMDUTF_TARGET_REGION(T)                                           \

      _Pragma("GCC push_options") _Pragma(SIMDUTF_STRINGIFY(GCC target(T)))

    #define SIMDUTF_UNTARGET_REGION _Pragma("GCC pop_options")

  #endif // clang then gcc

#endif // x86

// Default target region macros don't do anything.

#ifndef SIMDUTF_TARGET_REGION

  #define SIMDUTF_TARGET_REGION(T)

  #define SIMDUTF_UNTARGET_REGION

#endif

// Is threading enabled?

#if defined(_REENTRANT) || defined(_MT)

  #ifndef SIMDUTF_THREADS_ENABLED

    #define SIMDUTF_THREADS_ENABLED

  #endif

#endif

// workaround for large stack sizes under -O0.

// https://github.com/simdutf/simdutf/issues/691

#ifdef __APPLE__

  #ifndef __OPTIMIZE__

    // Apple systems have small stack sizes in secondary threads.

    // Lack of compiler optimization may generate high stack usage.

    // Users may want to disable threads for safety, but only when

    // in debug mode which we detect by the fact that the __OPTIMIZE__

    // macro is not defined.

    #undef SIMDUTF_THREADS_ENABLED

  #endif

#endif

#ifdef SIMDUTF_VISUAL_STUDIO

  // This is one case where we do not distinguish between

  // regular visual studio and clang under visual studio.

  // clang under Windows has _stricmp (like visual studio) but not strcasecmp

  // (as clang normally has)

  #define simdutf_strcasecmp _stricmp

  #define simdutf_strncasecmp _strnicmp

#else

  // The strcasecmp, strncasecmp, and strcasestr functions do not work with

  // multibyte strings (e.g. UTF-8). So they are only useful for ASCII in our

  // context.

  // https://www.gnu.org/software/libunistring/manual/libunistring.html#char-_002a-strings

  #define simdutf_strcasecmp strcasecmp

  #define simdutf_strncasecmp strncasecmp

#endif

#if defined(__GNUC__) && !defined(__clang__)

  #if __GNUC__ >= 11

    #define SIMDUTF_GCC11ORMORE 1

  #endif //  __GNUC__ >= 11

#endif   // defined(__GNUC__) && !defined(__clang__)

#endif // SIMDUTF_PORTABILITY_H

/* end file include/simdutf/portability.h */

/* begin file include/simdutf/avx512.h */

#ifndef SIMDUTF_AVX512_H_

#define SIMDUTF_AVX512_H_

/*

    It's possible to override AVX512 settings with cmake DCMAKE_CXX_FLAGS.

    All preprocessor directives has form `SIMDUTF_HAS_AVX512{feature}`,

    where a feature is a code name for extensions.

    Please see the listing below to find which are supported.

*/

#ifndef SIMDUTF_HAS_AVX512F

  #if defined(__AVX512F__) && __AVX512F__ == 1

    #define SIMDUTF_HAS_AVX512F 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512DQ

  #if defined(__AVX512DQ__) && __AVX512DQ__ == 1

    #define SIMDUTF_HAS_AVX512DQ 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512IFMA

  #if defined(__AVX512IFMA__) && __AVX512IFMA__ == 1

    #define SIMDUTF_HAS_AVX512IFMA 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512CD

  #if defined(__AVX512CD__) && __AVX512CD__ == 1

    #define SIMDUTF_HAS_AVX512CD 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512BW

  #if defined(__AVX512BW__) && __AVX512BW__ == 1

    #define SIMDUTF_HAS_AVX512BW 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512VL

  #if defined(__AVX512VL__) && __AVX512VL__ == 1

    #define SIMDUTF_HAS_AVX512VL 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512VBMI

  #if defined(__AVX512VBMI__) && __AVX512VBMI__ == 1

    #define SIMDUTF_HAS_AVX512VBMI 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512VBMI2

  #if defined(__AVX512VBMI2__) && __AVX512VBMI2__ == 1

    #define SIMDUTF_HAS_AVX512VBMI2 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512VNNI

  #if defined(__AVX512VNNI__) && __AVX512VNNI__ == 1

    #define SIMDUTF_HAS_AVX512VNNI 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512BITALG

  #if defined(__AVX512BITALG__) && __AVX512BITALG__ == 1

    #define SIMDUTF_HAS_AVX512BITALG 1

  #endif

#endif

#ifndef SIMDUTF_HAS_AVX512VPOPCNTDQ

  #if defined(__AVX512VPOPCNTDQ__) && __AVX512VPOPCNTDQ__ == 1

    #define SIMDUTF_HAS_AVX512VPOPCNTDQ 1

  #endif

#endif

#endif // SIMDUTF_AVX512_H_

/* end file include/simdutf/avx512.h */

// Sometimes logging is useful, but we want it disabled by default

// and free of any logging code in release builds.

#ifdef SIMDUTF_LOGGING

  #include <iostream>

  #define simdutf_log(msg)                                                     \

    std::cout << "[" << __FUNCTION__ << "]: " << msg << std::endl              \

              << "\t" << __FILE__ << ":" << __LINE__ << std::endl;

  #define simdutf_log_assert(cond, msg)                                        \

    do {                                                                       \

      if (!(cond)) {                                                           \

        std::cerr << "[" << __FUNCTION__ << "]: " << msg << std::endl          \

                  << "\t" << __FILE__ << ":" << __LINE__ << std::endl;         \

        std::abort();                                                          \

      }                                                                        \

    } while (0)

#else

  #define simdutf_log(msg)

  #define simdutf_log_assert(cond, msg)

#endif

#if defined(SIMDUTF_REGULAR_VISUAL_STUDIO)

  #define SIMDUTF_DEPRECATED __declspec(deprecated)

  #define simdutf_really_inline __forceinline // really inline in release mode

  #define simdutf_always_inline __forceinline // always inline, no matter what

  #define simdutf_never_inline __declspec(noinline)

  #define simdutf_unused

  #define simdutf_warn_unused

  #ifndef simdutf_likely

    #define simdutf_likely(x) x

  #endif

  #ifndef simdutf_unlikely

    #define simdutf_unlikely(x) x

  #endif

  #define SIMDUTF_PUSH_DISABLE_WARNINGS __pragma(warning(push))

  #define SIMDUTF_PUSH_DISABLE_ALL_WARNINGS __pragma(warning(push, 0))

  #define SIMDUTF_DISABLE_VS_WARNING(WARNING_NUMBER)                           \

    __pragma(warning(disable : WARNING_NUMBER))

  // Get rid of Intellisense-only warnings (Code Analysis)

  // Though __has_include is C++17, it is supported in Visual Studio 2017 or

  // better (_MSC_VER>=1910).

  #ifdef __has_include

    #if __has_include(<CppCoreCheck\Warnings.h>)

      #include <CppCoreCheck\Warnings.h>

      #define SIMDUTF_DISABLE_UNDESIRED_WARNINGS                               \

        SIMDUTF_DISABLE_VS_WARNING(ALL_CPPCORECHECK_WARNINGS)

    #endif

  #endif

  #ifndef SIMDUTF_DISABLE_UNDESIRED_WARNINGS

    #define SIMDUTF_DISABLE_UNDESIRED_WARNINGS

  #endif

  #define SIMDUTF_DISABLE_DEPRECATED_WARNING SIMDUTF_DISABLE_VS_WARNING(4996)

  #define SIMDUTF_DISABLE_STRICT_OVERFLOW_WARNING

  #define SIMDUTF_POP_DISABLE_WARNINGS __pragma(warning(pop))

  #define SIMDUTF_DISABLE_UNUSED_WARNING

#else // SIMDUTF_REGULAR_VISUAL_STUDIO

  #if defined(__OPTIMIZE__) || defined(NDEBUG)

    #define simdutf_really_inline inline __attribute__((always_inline))

  #else

    #define simdutf_really_inline inline

  #endif

  #define simdutf_always_inline                                                \

    inline __attribute__((always_inline)) // always inline, no matter what

  #define SIMDUTF_DEPRECATED __attribute__((deprecated))

  #define simdutf_never_inline inline __attribute__((noinline))

  #define simdutf_unused __attribute__((unused))

  #define simdutf_warn_unused __attribute__((warn_unused_result))

  #ifndef simdutf_likely

    #define simdutf_likely(x) __builtin_expect(!!(x), 1)

  #endif

  #ifndef simdutf_unlikely

    #define simdutf_unlikely(x) __builtin_expect(!!(x), 0)

  #endif

  // clang-format off

  #define SIMDUTF_PUSH_DISABLE_WARNINGS _Pragma("GCC diagnostic push")

  // gcc doesn't seem to disable all warnings with all and extra, add warnings

  // here as necessary

  #define SIMDUTF_PUSH_DISABLE_ALL_WARNINGS                                    \

    SIMDUTF_PUSH_DISABLE_WARNINGS                                              \

    SIMDUTF_DISABLE_GCC_WARNING(-Weffc++)                                      \

    SIMDUTF_DISABLE_GCC_WARNING(-Wall)                                         \

    SIMDUTF_DISABLE_GCC_WARNING(-Wconversion)                                  \

    SIMDUTF_DISABLE_GCC_WARNING(-Wextra)                                       \

    SIMDUTF_DISABLE_GCC_WARNING(-Wattributes)                                  \

    SIMDUTF_DISABLE_GCC_WARNING(-Wimplicit-fallthrough)                        \

    SIMDUTF_DISABLE_GCC_WARNING(-Wnon-virtual-dtor)                            \

    SIMDUTF_DISABLE_GCC_WARNING(-Wreturn-type)                                 \

    SIMDUTF_DISABLE_GCC_WARNING(-Wshadow)                                      \

    SIMDUTF_DISABLE_GCC_WARNING(-Wunused-parameter)                            \

    SIMDUTF_DISABLE_GCC_WARNING(-Wunused-variable)

  #define SIMDUTF_PRAGMA(P) _Pragma(#P)

  #define SIMDUTF_DISABLE_GCC_WARNING(WARNING)                                 \

    SIMDUTF_PRAGMA(GCC diagnostic ignored #WARNING)

  #if defined(SIMDUTF_CLANG_VISUAL_STUDIO)

    #define SIMDUTF_DISABLE_UNDESIRED_WARNINGS                                 \

      SIMDUTF_DISABLE_GCC_WARNING(-Wmicrosoft-include)

  #else

    #define SIMDUTF_DISABLE_UNDESIRED_WARNINGS

  #endif

  #define SIMDUTF_DISABLE_DEPRECATED_WARNING                                   \

    SIMDUTF_DISABLE_GCC_WARNING(-Wdeprecated-declarations)

  #define SIMDUTF_DISABLE_STRICT_OVERFLOW_WARNING                              \

    SIMDUTF_DISABLE_GCC_WARNING(-Wstrict-overflow)

  #define SIMDUTF_POP_DISABLE_WARNINGS _Pragma("GCC diagnostic pop")

  #define SIMDUTF_DISABLE_UNUSED_WARNING                                       \

    SIMDUTF_PUSH_DISABLE_WARNINGS                                              \

    SIMDUTF_DISABLE_GCC_WARNING(-Wunused-function)                             \

    SIMDUTF_DISABLE_GCC_WARNING(-Wunused-const-variable)

  // clang-format on

#endif // MSC_VER

#ifndef SIMDUTF_DLLIMPORTEXPORT

  #if defined(SIMDUTF_VISUAL_STUDIO)

    /**

     * It does not matter here whether you are using

     * the regular visual studio or clang under visual

     * studio.

     */

    #if SIMDUTF_USING_LIBRARY

      #define SIMDUTF_DLLIMPORTEXPORT __declspec(dllimport)

    #else

      #define SIMDUTF_DLLIMPORTEXPORT __declspec(dllexport)

    #endif

  #else

    #define SIMDUTF_DLLIMPORTEXPORT

  #endif

#endif

#if SIMDUTF_MAYBE_UNUSED_AVAILABLE

  #define simdutf_maybe_unused [[maybe_unused]]

#else

  #define simdutf_maybe_unused

#endif

#endif // SIMDUTF_COMMON_DEFS_H

/* end file include/simdutf/common_defs.h */

/* begin file include/simdutf/encoding_types.h */

#ifndef SIMDUTF_ENCODING_TYPES_H

#define SIMDUTF_ENCODING_TYPES_H

#include <string>

namespace simdutf {

enum encoding_type {

  UTF8 = 1,      // BOM 0xef 0xbb 0xbf

  UTF16_LE = 2,  // BOM 0xff 0xfe

  UTF16_BE = 4,  // BOM 0xfe 0xff

  UTF32_LE = 8,  // BOM 0xff 0xfe 0x00 0x00

  UTF32_BE = 16, // BOM 0x00 0x00 0xfe 0xff

  Latin1 = 32,

  unspecified = 0

};

enum endianness { LITTLE = 0, BIG = 1 };

bool match_system(endianness e);

std::string to_string(encoding_type bom);

// Note that BOM for UTF8 is discouraged.

namespace BOM {

/**

 * Checks for a BOM. If not, returns unspecified

 * @param input         the string to process

 * @param length        the length of the string in code units

 * @return the corresponding encoding

 */

encoding_type check_bom(const uint8_t *byte, size_t length);

encoding_type check_bom(const char *byte, size_t length);

/**

 * Returns the size, in bytes, of the BOM for a given encoding type.

 * Note that UTF8 BOM are discouraged.

 * @param bom         the encoding type

 * @return the size in bytes of the corresponding BOM

 */

size_t bom_byte_size(encoding_type bom);

} // namespace BOM

} // namespace simdutf

#endif

/* end file include/simdutf/encoding_types.h */

/* begin file include/simdutf/error.h */

#ifndef SIMDUTF_ERROR_H

#define SIMDUTF_ERROR_H

namespace simdutf {

enum error_code {

  SUCCESS = 0,

  HEADER_BITS, // Any byte must have fewer than 5 header bits.

  TOO_SHORT,   // The leading byte must be followed by N-1 continuation bytes,

               // where N is the UTF-8 character length This is also the error

               // when the input is truncated.

  TOO_LONG,    // We either have too many consecutive continuation bytes or the

               // string starts with a continuation byte.

  OVERLONG, // The decoded character must be above U+7F for two-byte characters,

            // U+7FF for three-byte characters, and U+FFFF for four-byte

            // characters.

  TOO_LARGE, // The decoded character must be less than or equal to

             // U+10FFFF,less than or equal than U+7F for ASCII OR less than

             // equal than U+FF for Latin1

  SURROGATE, // The decoded character must be not be in U+D800...DFFF (UTF-8 or

             // UTF-32) OR a high surrogate must be followed by a low surrogate

             // and a low surrogate must be preceded by a high surrogate

             // (UTF-16) OR there must be no surrogate at all (Latin1)

  INVALID_BASE64_CHARACTER, // Found a character that cannot be part of a valid

                            // base64 string. This may include a misplaced

                            // padding character ('=').

  BASE64_INPUT_REMAINDER,   // The base64 input terminates with a single

                            // character, excluding padding (=). It is also used

                            // in strict mode when padding is not adequate.

  BASE64_EXTRA_BITS,        // The base64 input terminates with non-zero

                            // padding bits.

  OUTPUT_BUFFER_TOO_SMALL,  // The provided buffer is too small.

  OTHER                     // Not related to validation/transcoding.

};

#if SIMDUTF_CPLUSPLUS17

inline std::string_view error_to_string(error_code code) noexcept {

  switch (code) {

  case SUCCESS:

    return "SUCCESS";

  case HEADER_BITS:

    return "HEADER_BITS";

  case TOO_SHORT:

    return "TOO_SHORT";

  case TOO_LONG:

    return "TOO_LONG";

  case OVERLONG:

    return "OVERLONG";

  case TOO_LARGE:

    return "TOO_LARGE";

  case SURROGATE:

    return "SURROGATE";

  case INVALID_BASE64_CHARACTER:

    return "INVALID_BASE64_CHARACTER";

  case BASE64_INPUT_REMAINDER:

    return "BASE64_INPUT_REMAINDER";

  case BASE64_EXTRA_BITS:

    return "BASE64_EXTRA_BITS";

  case OUTPUT_BUFFER_TOO_SMALL:

    return "OUTPUT_BUFFER_TOO_SMALL";

  default:

    return "OTHER";

  }

}

#endif

struct result {

  error_code error;

  size_t count; // In case of error, indicates the position of the error. In

                // case of success, indicates the number of code units

                // validated/written.

  simdutf_really_inline result() noexcept

      : error{error_code::SUCCESS}, count{0} {}

  simdutf_really_inline result(error_code err, size_t pos) noexcept

      : error{err}, count{pos} {}

  simdutf_really_inline bool is_ok() const noexcept {

    return error == error_code::SUCCESS;

  }

  simdutf_really_inline bool is_err() const noexcept {

    return error != error_code::SUCCESS;

  }

};

struct full_result {

  error_code error;

  size_t input_count;

  size_t output_count;

  bool padding_error = false; // true if the error is due to padding, only

                              // meaningful when error is not SUCCESS

  simdutf_really_inline full_result() noexcept

      : error{error_code::SUCCESS}, input_count{0}, output_count{0} {}

  simdutf_really_inline full_result(error_code err, size_t pos_in,

                                    size_t pos_out) noexcept

      : error{err}, input_count{pos_in}, output_count{pos_out} {}

  simdutf_really_inline full_result(error_code err, size_t pos_in,

                                    size_t pos_out, bool padding_err) noexcept

      : error{err}, input_count{pos_in}, output_count{pos_out},

        padding_error{padding_err} {}

  simdutf_really_inline operator result() const noexcept {

    if (error == error_code::SUCCESS) {

      return result{error, output_count};

    } else {

      return result{error, input_count};

    }

  }

};

} // namespace simdutf

#endif

/* end file include/simdutf/error.h */

SIMDUTF_PUSH_DISABLE_WARNINGS

SIMDUTF_DISABLE_UNDESIRED_WARNINGS

// Public API

/* begin file include/simdutf/simdutf_version.h */

// /include/simdutf/simdutf_version.h automatically generated by release.py,

// do not change by hand

#ifndef SIMDUTF_SIMDUTF_VERSION_H

#define SIMDUTF_SIMDUTF_VERSION_H

/** The version of simdutf being used (major.minor.revision) */

#define SIMDUTF_VERSION "7.3.3"

namespace simdutf {

enum {

  /**

   * The major version (MAJOR.minor.revision) of simdutf being used.

   */

  SIMDUTF_VERSION_MAJOR = 7,

  /**

   * The minor version (major.MINOR.revision) of simdutf being used.

   */

  SIMDUTF_VERSION_MINOR = 3,

  /**

   * The revision (major.minor.REVISION) of simdutf being used.

   */

  SIMDUTF_VERSION_REVISION = 3

};

} // namespace simdutf

#endif // SIMDUTF_SIMDUTF_VERSION_H

/* end file include/simdutf/simdutf_version.h */

/* begin file include/simdutf/implementation.h */

#ifndef SIMDUTF_IMPLEMENTATION_H

#define SIMDUTF_IMPLEMENTATION_H

#if !defined(SIMDUTF_NO_THREADS)

  #include <atomic>

#endif

#include <string>

#ifdef SIMDUTF_INTERNAL_TESTS

  #include <vector>

#endif

/* begin file include/simdutf/internal/isadetection.h */

/* From

https://github.com/endorno/pytorch/blob/master/torch/lib/TH/generic/simd/simd.h

Highly modified.

Copyright (c) 2016-     Facebook, Inc            (Adam Paszke)

Copyright (c) 2014-     Facebook, Inc            (Soumith Chintala)

Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)

Copyright (c) 2012-2014 Deepmind Technologies    (Koray Kavukcuoglu)

Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)

Copyright (c) 2011-2013 NYU                      (Clement Farabet)

Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou,

Iain Melvin, Jason Weston) Copyright (c) 2006      Idiap Research Institute

(Samy Bengio) Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert,

Samy Bengio, Johnny Mariethoz)

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright

   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

   notice, this list of conditions and the following disclaimer in the

   documentation and/or other materials provided with the distribution.

3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories

America and IDIAP Research Institute nor the names of its contributors may be

   used to endorse or promote products derived from this software without

   specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef SIMDutf_INTERNAL_ISADETECTION_H

#define SIMDutf_INTERNAL_ISADETECTION_H

#include <cstdint>

#include <cstdlib>

#if defined(_MSC_VER)

  #include <intrin.h>

#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)

  #include <cpuid.h>

#endif

// RISC-V ISA detection utilities

#if SIMDUTF_IS_RISCV64 && defined(__linux__)

  #include <unistd.h> // for syscall

// We define these ourselves, for backwards compatibility

struct simdutf_riscv_hwprobe {

  int64_t key;

  uint64_t value;

};

  #define simdutf_riscv_hwprobe(...) syscall(258, __VA_ARGS__)

  #define SIMDUTF_RISCV_HWPROBE_KEY_IMA_EXT_0 4

  #define SIMDUTF_RISCV_HWPROBE_IMA_V (1 << 2)

  #define SIMDUTF_RISCV_HWPROBE_EXT_ZVBB (1 << 17)

#endif // SIMDUTF_IS_RISCV64 && defined(__linux__)

#if defined(__loongarch__) && defined(__linux__)

  #include <sys/auxv.h>

// bits/hwcap.h

// #define HWCAP_LOONGARCH_LSX             (1 << 4)

// #define HWCAP_LOONGARCH_LASX            (1 << 5)

#endif

namespace simdutf {

namespace internal {

enum instruction_set {

  DEFAULT = 0x0,

  NEON = 0x1,

  AVX2 = 0x4,

  SSE42 = 0x8,

  PCLMULQDQ = 0x10,

  BMI1 = 0x20,

  BMI2 = 0x40,

  ALTIVEC = 0x80,

  AVX512F = 0x100,

  AVX512DQ = 0x200,

  AVX512IFMA = 0x400,

  AVX512PF = 0x800,

  AVX512ER = 0x1000,

  AVX512CD = 0x2000,

  AVX512BW = 0x4000,

  AVX512VL = 0x8000,

  AVX512VBMI2 = 0x10000,

  AVX512VPOPCNTDQ = 0x2000,

  RVV = 0x4000,

  ZVBB = 0x8000,

  LSX = 0x40000,

  LASX = 0x80000,

};

#if defined(__PPC64__)

static inline uint32_t detect_supported_architectures() {

  return instruction_set::ALTIVEC;

}

#elif SIMDUTF_IS_RISCV64

static inline uint32_t detect_supported_architectures() {

  uint32_t host_isa = instruction_set::DEFAULT;

  #if SIMDUTF_IS_RVV

  host_isa |= instruction_set::RVV;

  #endif

  #if SIMDUTF_IS_ZVBB

  host_isa |= instruction_set::ZVBB;

  #endif

  #if defined(__linux__)

  simdutf_riscv_hwprobe probes[] = {{SIMDUTF_RISCV_HWPROBE_KEY_IMA_EXT_0, 0}};

  long ret = simdutf_riscv_hwprobe(&probes, sizeof probes / sizeof *probes, 0,

                                   nullptr, 0);

  if (ret == 0) {

    uint64_t extensions = probes[0].value;

    if (extensions & SIMDUTF_RISCV_HWPROBE_IMA_V)

      host_isa |= instruction_set::RVV;

    if (extensions & SIMDUTF_RISCV_HWPROBE_EXT_ZVBB)

      host_isa |= instruction_set::ZVBB;

  }

  #endif

  #if defined(RUN_IN_SPIKE_SIMULATOR)

  // Proxy Kernel does not implement yet hwprobe syscall

  host_isa |= instruction_set::RVV;

  #endif

  return host_isa;

}

#elif defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)

static inline uint32_t detect_supported_architectures() {

  return instruction_set::NEON;

}

#elif defined(__x86_64__) || defined(_M_AMD64) // x64

namespace {

namespace cpuid_bit {

// Can be found on Intel ISA Reference for CPUID

// EAX = 0x01

constexpr uint32_t pclmulqdq = uint32_t(1)

                               << 1; ///< @private bit  1 of ECX for EAX=0x1

constexpr uint32_t sse42 = uint32_t(1)

                           << 20; ///< @private bit 20 of ECX for EAX=0x1

constexpr uint32_t osxsave =

    (uint32_t(1) << 26) |

    (uint32_t(1) << 27); ///< @private bits 26+27 of ECX for EAX=0x1

// EAX = 0x7f (Structured Extended Feature Flags), ECX = 0x00 (Sub-leaf)

// See: "Table 3-8. Information Returned by CPUID Instruction"

namespace ebx {

constexpr uint32_t bmi1 = uint32_t(1) << 3;

constexpr uint32_t avx2 = uint32_t(1) << 5;

constexpr uint32_t bmi2 = uint32_t(1) << 8;

constexpr uint32_t avx512f = uint32_t(1) << 16;

constexpr uint32_t avx512dq = uint32_t(1) << 17;

constexpr uint32_t avx512ifma = uint32_t(1) << 21;

constexpr uint32_t avx512cd = uint32_t(1) << 28;

constexpr uint32_t avx512bw = uint32_t(1) << 30;

constexpr uint32_t avx512vl = uint32_t(1) << 31;

} // namespace ebx

namespace ecx {

constexpr uint32_t avx512vbmi = uint32_t(1) << 1;

constexpr uint32_t avx512vbmi2 = uint32_t(1) << 6;

constexpr uint32_t avx512vnni = uint32_t(1) << 11;

constexpr uint32_t avx512bitalg = uint32_t(1) << 12;

constexpr uint32_t avx512vpopcnt = uint32_t(1) << 14;

} // namespace ecx

namespace edx {

constexpr uint32_t avx512vp2intersect = uint32_t(1) << 8;

}

namespace xcr0_bit {

constexpr uint64_t avx256_saved = uint64_t(1) << 2; ///< @private bit 2 = AVX

constexpr uint64_t avx512_saved =

    uint64_t(7) << 5; ///< @private bits 5,6,7 = opmask, ZMM_hi256, hi16_ZMM

} // namespace xcr0_bit

} // namespace cpuid_bit

} // namespace

static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx,

                         uint32_t *edx) {

  #if defined(_MSC_VER)

  int cpu_info[4];

  __cpuidex(cpu_info, *eax, *ecx);

  *eax = cpu_info[0];

  *ebx = cpu_info[1];

  *ecx = cpu_info[2];

  *edx = cpu_info[3];

  #elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)

  uint32_t level = *eax;

  __get_cpuid(level, eax, ebx, ecx, edx);

  #else

  uint32_t a = *eax, b, c = *ecx, d;

  asm volatile("cpuid\n\t" : "+a"(a), "=b"(b), "+c"(c), "=d"(d));

  *eax = a;

  *ebx = b;

  *ecx = c;

  *edx = d;

  #endif

}

Unexecuted instantiation: node_buffer.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: node_builtins.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: node_i18n.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: node_metadata.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: string_bytes.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: util.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: inspector_profiler.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: main_thread_interface.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: node_string.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: encoding_binding.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

Unexecuted instantiation: inspector_socket.cc:simdutf::internal::cpuid(unsigned int*, unsigned int*, unsigned int*, unsigned int*)

static inline uint64_t xgetbv() {

  #if defined(_MSC_VER)

  return _xgetbv(0);

  #else

  uint32_t xcr0_lo, xcr0_hi;

  asm volatile("xgetbv\n\t" : "=a"(xcr0_lo), "=d"(xcr0_hi) : "c"(0));

  return xcr0_lo | ((uint64_t)xcr0_hi << 32);

  #endif

}

Unexecuted instantiation: node_buffer.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: node_builtins.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: node_i18n.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: node_metadata.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: string_bytes.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: util.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: inspector_profiler.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: main_thread_interface.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: node_string.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: encoding_binding.cc:simdutf::internal::xgetbv()

Unexecuted instantiation: inspector_socket.cc:simdutf::internal::xgetbv()

static inline uint32_t detect_supported_architectures() {

  uint32_t eax;

  uint32_t ebx = 0;

  uint32_t ecx = 0;

  uint32_t edx = 0;

  uint32_t host_isa = 0x0;

  // EBX for EAX=0x1

  eax = 0x1;

  cpuid(&eax, &ebx, &ecx, &edx);

  if (ecx & cpuid_bit::sse42) {

    host_isa |= instruction_set::SSE42;

  }

  if (ecx & cpuid_bit::pclmulqdq) {

    host_isa |= instruction_set::PCLMULQDQ;

  }

  if ((ecx & cpuid_bit::osxsave) != cpuid_bit::osxsave) {

    return host_isa;

  }

  // xgetbv for checking if the OS saves registers

  uint64_t xcr0 = xgetbv();

  if ((xcr0 & cpuid_bit::xcr0_bit::avx256_saved) == 0) {

    return host_isa;

  }

  // ECX for EAX=0x7

  eax = 0x7;

  ecx = 0x0; // Sub-leaf = 0

  cpuid(&eax, &ebx, &ecx, &edx);

  if (ebx & cpuid_bit::ebx::avx2) {

    host_isa |= instruction_set::AVX2;

  }

  if (ebx & cpuid_bit::ebx::bmi1) {

    host_isa |= instruction_set::BMI1;

  }

  if (ebx & cpuid_bit::ebx::bmi2) {

    host_isa |= instruction_set::BMI2;

  }

  if (!((xcr0 & cpuid_bit::xcr0_bit::avx512_saved) ==

        cpuid_bit::xcr0_bit::avx512_saved)) {

    return host_isa;

  }

  if (ebx & cpuid_bit::ebx::avx512f) {

    host_isa |= instruction_set::AVX512F;

  }

  if (ebx & cpuid_bit::ebx::avx512bw) {

    host_isa |= instruction_set::AVX512BW;

  }

  if (ebx & cpuid_bit::ebx::avx512cd) {

    host_isa |= instruction_set::AVX512CD;

  }

  if (ebx & cpuid_bit::ebx::avx512dq) {

    host_isa |= instruction_set::AVX512DQ;

  }

  if (ebx & cpuid_bit::ebx::avx512vl) {

    host_isa |= instruction_set::AVX512VL;

  }

  if (ecx & cpuid_bit::ecx::avx512vbmi2) {

    host_isa |= instruction_set::AVX512VBMI2;

  }

  if (ecx & cpuid_bit::ecx::avx512vpopcnt) {

    host_isa |= instruction_set::AVX512VPOPCNTDQ;

  }

  return host_isa;

}

Unexecuted instantiation: node_buffer.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: node_builtins.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: node_i18n.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: node_metadata.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: string_bytes.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: util.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: inspector_profiler.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: main_thread_interface.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: node_string.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: encoding_binding.cc:simdutf::internal::detect_supported_architectures()

Unexecuted instantiation: inspector_socket.cc:simdutf::internal::detect_supported_architectures()

#elif defined(__loongarch__)

static inline uint32_t detect_supported_architectures() {

  uint32_t host_isa = instruction_set::DEFAULT;

  #if defined(__linux__)

  uint64_t hwcap = 0;

  hwcap = getauxval(AT_HWCAP);

  if (hwcap & HWCAP_LOONGARCH_LSX) {

    host_isa |= instruction_set::LSX;

  }

  if (hwcap & HWCAP_LOONGARCH_LASX) {

    host_isa |= instruction_set::LASX;

  }

  #endif

  return host_isa;

}

#else // fallback

// includes 32-bit ARM.

static inline uint32_t detect_supported_architectures() {

  return instruction_set::DEFAULT;

}

#endif // end SIMD extension detection code

} // namespace internal

} // namespace simdutf

#endif // SIMDutf_INTERNAL_ISADETECTION_H

/* end file include/simdutf/internal/isadetection.h */

#if SIMDUTF_SPAN

  #include <concepts>

  #include <type_traits>