react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/.github/workflows/ubuntu22sani.yml

@@ -0,0 +1,29 @@
+name: Ubuntu 22.04 Sanitized CI (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use cmake with address sanitizer
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake -DSIMDUTF_SANITIZE=ON .. -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build .  --parallel $(nproc) &&
+          ctest --output-on-failure --parallel $(nproc)
+      - name: Use cmake with undefined behavior sanitizer
+        run: |
+          mkdir buildundef &&
+          cd buildundef &&
+          cmake -DSIMDUTF_SANITIZE_UNDEFINED=ON .. -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build . --parallel $(nproc)  &&
+          ctest --output-on-failure --parallel $(nproc)

package/deps/simdutf/.github/workflows/ubuntu24-cxxstandards.yml

@@ -0,0 +1,34 @@
+name: Ubuntu 24.04 All supported C++ standards
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        compiler: [g++-14, clang++-18]
+        cppversion: [11, 14, 17, 20, 23]
+        cversion: [11,]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build and test ${{matrix.compiler}} C++ ${{matrix.cppversion}}
+        run: |
+          cmake \
+             -DCMAKE_CXX_COMPILER=${{matrix.compiler}} \
+             -DSIMDUTF_CXX_STANDARD=${{matrix.cppversion}} \
+             -DSIMDUTF_C_STANDARD=${{matrix.cversion}} \
+             -DSIMDUTF_BENCHMARKS=OFF \
+             -DCMAKE_BUILD_TYPE=Release \
+             -DSIMDUTF_FAST_TESTS=On \
+             -GNinja \
+             -B build \
+             -S .
+          cmake --build build
+          ctest -j --output-on-failure --test-dir build

package/deps/simdutf/.github/workflows/ubuntu24-unsignedchar.yml

@@ -0,0 +1,34 @@
+name: Ubuntu 24.04 char signedness
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        compiler: [g++-14]
+        cppversion: [11, 23]
+        charflag: [-fsigned-char, -funsigned-char]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build and test ${{matrix.charflag}} C++ ${{matrix.cppversion}}
+        run: |
+          cmake \
+             -DCMAKE_CXX_FLAGS="${{matrix.charflag}}" \
+             -DCMAKE_CXX_COMPILER=${{matrix.compiler}} \
+             -DSIMDUTF_CXX_STANDARD=${{matrix.cppversion}} \
+             -DSIMDUTF_BENCHMARKS=OFF \
+             -DSIMDUTF_FAST_TESTS=On \
+             -DCMAKE_BUILD_TYPE=Release \
+             -GNinja \
+             -B build \
+             -S .
+          cmake --build build
+          ctest -j --output-on-failure --test-dir build

package/deps/simdutf/.github/workflows/ubuntu24.yml

@@ -0,0 +1,32 @@
+name: Ubuntu 24.04 CI (GCC 13)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        include:
+          - {shared: ON, type : Debug}
+          - {shared: OFF, type : Debug}
+          - {shared: ON, type : Release}
+          - {shared: OFF, type : Release}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake -DCMAKE_CXX_FLAGS=-Werror -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON -DCMAKE_INSTALL_PREFIX:PATH=destination -DBUILD_SHARED_LIBS=${{matrix.shared}} -DCMAKE_BUILD_TYPE=${{matrix.type}} ..   -DSIMDUTF_BENCHMARKS=OFF -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build .   &&
+          ctest -j --output-on-failure &&
+          cmake --install . &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .

package/deps/simdutf/.github/workflows/ubuntu24sani.yml

@@ -0,0 +1,36 @@
+name: Ubuntu 24.04 Sanitized CI (GCC 13)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use cmake with address sanitizer
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake -DSIMDUTF_CXX_STANDARD=20 -DSIMDUTF_ATOMIC_BASE64_TESTS=ON  -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=ON -DSIMDUTF_SANITIZE=ON .. -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build . --parallel $(nproc)  &&
+          ctest --output-on-failure --parallel $(nproc)
+      - name: Use cmake with undefined behavior sanitizer
+        run: |
+          mkdir buildundef &&
+          cd buildundef &&
+          cmake -DSIMDUTF_CXX_STANDARD=20  -DSIMDUTF_ATOMIC_BASE64_TESTS=ON -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=ON -DSIMDUTF_SANITIZE_UNDEFINED=ON .. -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build . --parallel $(nproc)  &&
+          ctest --output-on-failure --parallel $(nproc)
+      - name: Use cmake with thread sanitizer
+        run: |
+          mkdir buildthread &&
+          cd buildthread &&
+          cmake -DSIMDUTF_CXX_STANDARD=20  -DSIMDUTF_ATOMIC_BASE64_TESTS=ON -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=ON -DSIMDUTF_SANITIZE_THREAD=ON .. -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build .  --parallel $(nproc) &&
+          ctest --output-on-failure --parallel $(nproc)

package/deps/simdutf/.github/workflows/ubuntu24sani_clang.yml

@@ -0,0 +1,29 @@
+name: Ubuntu 24.04 Sanitized CI (LLVM 18)
+
+on:
+    push:
+        branches:
+        - master
+    pull_request:
+        branches:
+        - master
+
+jobs:
+    ubuntu-build:
+        runs-on: ubuntu-24.04
+        steps:
+        - uses: actions/checkout@v4
+        - name: Use cmake with address sanitizer
+          run: |
+            mkdir build &&
+            cd build &&
+            cmake -DSIMDUTF_SANITIZE=ON -DCMAKE_CXX_COMPILER=clang++ .. -DSIMDUTF_FAST_TESTS=On &&
+            cmake --build . --parallel $(nproc) &&
+            ctest --output-on-failure --parallel $(nproc)
+        - name: Use cmake with undefined behavior sanitizer
+          run: |
+            mkdir buildundef &&
+            cd buildundef &&
+            cmake -DSIMDUTF_SANITIZE_UNDEFINED=ON  -DCMAKE_CXX_COMPILER=clang++ .. -DSIMDUTF_FAST_TESTS=On &&
+            cmake --build . --parallel $(nproc) &&
+            ctest --output-on-failure --parallel $(nproc)

package/deps/simdutf/.github/workflows/vs17-arm-ci.yml

@@ -0,0 +1,21 @@
+name: VS17-ARM-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 17 2022, arch: ARM64}
+          - {gen: Visual Studio 17 2022, arch: ARM64EC}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: Use cmake
+        run: |
+          cmake -G "${{matrix.gen}}" -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON -DCMAKE_CROSSCOMPILING=1 -DSIMDUTF_ICONV=OFF -B build -DSIMDUTF_FAST_TESTS=On &&
+          cmake --build build --verbose --parallel

package/deps/simdutf/.github/workflows/vs17-ci-cxx20.yml

@@ -0,0 +1,41 @@
+name: VS17-CI C++20
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake  -DSIMDUTF_CXX_STANDARD=20 -DSIMDUTF_ATOMIC_BASE64_TESTS=ON -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=ON -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON -DSIMDUTF_BENCHMARKS=ON -G "${{matrix.gen}}" -A ${{matrix.arch}} -DBUILD_SHARED_LIBS=${{matrix.shared}} -DSIMDUTF_FAST_TESTS=On -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose --parallel
+    - name: Build Release
+      run: cmake --build build --config Release --verbose --parallel
+    - name: Run Release tests
+      run: |
+        cd build
+        ctest -C Release   --output-on-failure --parallel
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug  --output-on-failure  -E basic_fuzzer --parallel
+    - name: Install
+      run: |
+        cmake --install build --config Release
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config Release --parallel

package/deps/simdutf/.github/workflows/vs17-ci.yml

@@ -0,0 +1,41 @@
+name: VS17-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON -DSIMDUTF_BENCHMARKS=ON -DBUILD_SHARED_LIBS=${{matrix.shared}} -DSIMDUTF_FAST_TESTS=On -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose --parallel
+    - name: Build Release
+      run: cmake --build build --config Release --verbose --parallel
+    - name: Run Release tests
+      run: |
+        cd build
+        ctest -C Release   --output-on-failure --parallel
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug  --output-on-failure  -E basic_fuzzer --parallel
+    - name: Install
+      run: |
+        cmake --install build --config Release
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config Release --parallel

package/deps/simdutf/.github/workflows/vs17-clang-ci.yml

@@ -0,0 +1,41 @@
+name: VS17-clang-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON -DSIMDUTF_BENCHMARKS=ON  -T ClangCL -DBUILD_SHARED_LIBS=${{matrix.shared}} -DSIMDUTF_FAST_TESTS=On -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose --parallel
+    - name: Build Release
+      run: cmake --build build --config Release --verbose --parallel
+    - name: Run Release tests
+      run: |
+        cd build
+        ctest -C Release --output-on-failure --parallel
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug --output-on-failure  -E basic_fuzzer --parallel
+    - name: Install
+      run: |
+        cmake --install build --config Release
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config Release --parallel

package/deps/simdutf/.github/workflows/vs17-cxxstandards.yml

@@ -0,0 +1,36 @@
+name: VS17 All supported C++ standards
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        cppversion: [11, 14, 17, 20, 23]
+        gen: ["Visual Studio 17 2022"]
+        arch: [x64]
+        shared: [ON]
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake `
+           -G "${{matrix.gen}}" `
+           -A ${{matrix.arch}} `
+           -DSIMDUTF_CXX_STANDARD=${{matrix.cppversion}} `
+           -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON `
+           -DSIMDUTF_BENCHMARKS=OFF `
+           -DSIMDUTF_FAST_TESTS=On `
+           -DBUILD_SHARED_LIBS=${{matrix.shared}} `
+           -B build `
+           -S .
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run Release tests
+      run: |
+        cd build
+        ctest -C Release --output-on-failure

package/deps/simdutf/AI_USAGE_POLICY.md

@@ -0,0 +1,56 @@
+# AI Usage Policy
+
+Contributors can use whatever tools they would like to
+craft their contributions, but there must be a **human in the loop**.
+**Contributors must read and review all LLM-generated code or text before they
+ask other project members to review it.** The contributor is always the author
+and is fully accountable for their contributions. Contributors should be
+sufficiently confident that the contribution is high enough quality that asking
+for a review is a good use of scarce maintainer time, and they should be **able
+to answer questions about their work** during review.
+
+We expect that new contributors will be less confident in their contributions,
+and our guidance to them is to **start with small contributions** that they can
+fully understand to build confidence. We aspire to be a welcoming community
+that helps new contributors grow their expertise, but learning involves taking
+small steps, getting feedback, and iterating. Passing maintainer feedback to an
+LLM doesn't help anyone grow, and does not sustain our community.
+
+This policy includes, but is not limited to, the following kinds of
+contributions:
+
+- Code, usually in the form of a pull request
+- Issues or security vulnerabilities
+- Comments and feedback on pull requests
+
+## Extractive Contributions
+
+The reason for our "human-in-the-loop" contribution policy is that processing
+patches, PRs, RFCs, and comments is not free -- it takes a lot of
+maintainer time and energy to review those contributions! Sending the
+unreviewed output of an LLM to open source project maintainers *extracts* work
+from them in the form of design and code review, so we call this kind of
+contribution an "extractive contribution".
+
+## Transparency
+
+For contributions involving significant AI assistance, we encourage you to disclose 
+its use and explain your process. If a submission appears to rely heavily on AI 
+without disclosure, we may doubt that the **human-in-the-loop** requirement has
+been met. Please show awareness of your use of AI.
+
+## Copyright
+
+Artificial intelligence systems raise many questions around copyright that have
+yet to be answered. Our policy on AI tools is similar to our copyright policy:
+Contributors are responsible for ensuring that they have the right to
+contribute code under the terms of our license, typically meaning that either
+they, their employer, or their collaborators hold the copyright. Using AI tools
+to regenerate copyrighted material does not remove the copyright, and
+contributors are responsible for ensuring that such material does not appear in
+their contributions. Contributions found to violate this policy will be removed
+just like any other offending contribution.
+
+## Reference
+
+- [LLVM AI Tool Use Policy](https://discourse.llvm.org/t/rfc-llvm-ai-tool-policy-human-in-the-loop/89159)

package/deps/simdutf/AUTHORS

@@ -0,0 +1,6 @@
+Wojciech Muła
+Daniel Lemire
+Nicolas Boyer
+John Keiser
+Robert Clausecker
+Olaf Bernstein

package/deps/simdutf/CMakeLists.txt

@@ -0,0 +1,231 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(simdutf
+  DESCRIPTION "Fast Unicode validation, transcoding and processing"
+  LANGUAGES C CXX
+  VERSION 8.2.0
+)
+
+include (TestBigEndian)
+TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
+if(IS_BIG_ENDIAN)
+  message(STATUS "Big-endian system detected.")
+endif()
+
+include(GNUInstallDirs)
+# The following requires CMake 3.21.
+# if(PROJECT_IS_TOP_LEVEL)
+#  message(STATUS "Building simdutf as a top-level project.")
+#  include(CTest)
+#else()
+#  message(STATUS "Building simdutf as a subproject.")
+#endif(PROJECT_IS_TOP_LEVEL)
+include(CTest)
+include(cmake/simdutf-flags.cmake)
+
+set(SIMDUTF_LIB_VERSION "33.0.0" CACHE STRING "simdutf library version")
+set(SIMDUTF_LIB_SOVERSION "33" CACHE STRING "simdutf library soversion")
+option(SIMDUTF_TESTS "Whether the tests are included as part of the CMake Build." ON)
+option(SIMDUTF_FAST_TESTS "Whether parameters to the tests are adapted to make them execute quicker" OFF)
+option(SIMDUTF_ATOMIC_BASE64_TESTS "Whether to test the atomic base64 functions. (OFF by default)" OFF)
+option(SIMDUTF_BENCHMARKS "Whether the benchmarks are included as part of the CMake Build." OFF)
+option(SIMDUTF_TOOLS "Whether the tools are included as part of the CMake build. Requires C++17 or better." ON)
+option(SIMDUTF_ICONV "Whether to use iconv as part of the CMake build if available." ON)
+option(SIMDUTF_FUZZERS "Whether to build the fuzzers." OFF)
+option(SIMDUTF_COVERAGE "Enable code coverage collection during tests (only GCC and Clang)." OFF)
+option(SIMDUTF_INTERNAL_TESTS "Whether to test also internal procedures. Useful mostly for developers, not users." OFF)
+option(SIMDUTF_LOGGING "Whether to enable logging (this should never be used in binary releases)." OFF)
+option(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION "Whether to enable unsafe fuzzing mode." OFF)
+
+if(SIMDUTF_LOGGING AND DEFINED CMAKE_CXX_STANDARD AND CMAKE_CXX_STANDARD LESS 17)
+    set(CMAKE_CXX_STANDARD 17)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+set(SIMDUTF_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+add_subdirectory(src)
+add_subdirectory(singleheader)
+
+if (SIMDUTF_TESTS)
+  message(STATUS "The tests are enabled.")
+  add_subdirectory(tests)
+else(SIMDUTF_TESTS)
+  message(STATUS "The tests are disabled.")
+endif(SIMDUTF_TESTS)
+
+
+if (SIMDUTF_TOOLS)
+  if(CMAKE_CXX_COMPILER_ID MATCHES GNU AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+    message(STATUS "The benchmark tool requires GCC 8.0 or better.")
+  else()
+    add_subdirectory(tools)
+  endif()
+endif()
+
+
+if (SIMDUTF_BENCHMARKS)
+  if(NOT SIMDUTF_TESTS)
+    message(STATUS "You have enabled the benchmarks, but not the tests. We don't allow running the benchmarks without the tests.")
+  elseif((CMAKE_CXX_COMPILER_ID MATCHES GNU) AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0"))
+    message(STATUS "The benchmark tool requires GCC 8.0 or better.")
+  else()
+    message(STATUS "The benchmarks can be disabled by setting SIMDUTF_BENCHMARKS, e.g., -D SIMDUTF_BENCHMARKS=OFF.")
+    add_subdirectory(benchmarks)
+  endif()
+else()
+  message(STATUS "The benchmarks can be enabled by setting SIMDUTF_BENCHMARKS, e.g., -D SIMDUTF_BENCHMARKS=ON.")
+endif()
+
+if (SIMDUTF_COVERAGE)
+  if (NOT SIMDUTF_TESTS)
+    message(FATAL_ERROR "Cannot enable code coverage without tests (enable SIMDUTF_TESTS option)")
+  endif()
+  if (NOT ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang")))
+    message(FATAL_ERROR "Code coverage is supported only by GCC and Clang")
+  endif()
+  message(STATUS "Code coverage enabled; use `ctest -T Test -T Coverage` to gather coverage details")
+endif()
+
+message(STATUS "Compiling using the C++ standard:" ${CMAKE_CXX_STANDARD})
+# ---- Install rules ----
+add_library(simdutf::simdutf ALIAS simdutf)
+
+set_target_properties(
+    simdutf PROPERTIES
+    VERSION "${SIMDUTF_LIB_VERSION}"
+    SOVERSION "${SIMDUTF_LIB_SOVERSION}"
+    WINDOWS_EXPORT_ALL_SYMBOLS YES
+)
+
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
+
+install(
+    FILES include/simdutf.h
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdutf_Development
+)
+
+
+install(
+    FILES include/simdutf_c.h
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdutf_Development
+)
+
+install(
+    DIRECTORY include/simdutf
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdutf_Development
+)
+
+install(
+    TARGETS simdutf
+    EXPORT simdutfTargets
+    RUNTIME COMPONENT simdutf_Runtime
+    LIBRARY COMPONENT simdutf_Runtime
+    NAMELINK_COMPONENT simdutf_Development
+    ARCHIVE COMPONENT simdutf_Development
+    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+configure_file(cmake/simdutf-config.cmake.in simdutf-config.cmake @ONLY)
+
+write_basic_package_version_file(
+    simdutf-config-version.cmake
+    COMPATIBILITY SameMinorVersion
+)
+
+set(
+    SIMDUTF_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdutf"
+    CACHE STRING "CMake package config location relative to the install prefix"
+)
+mark_as_advanced(SIMDUTF_INSTALL_CMAKEDIR)
+
+install(
+    FILES
+    "${PROJECT_BINARY_DIR}/simdutf-config.cmake"
+    "${PROJECT_BINARY_DIR}/simdutf-config-version.cmake"
+    DESTINATION "${SIMDUTF_INSTALL_CMAKEDIR}"
+    COMPONENT simdutf_Development
+)
+
+install(
+    EXPORT simdutfTargets
+    NAMESPACE simdutf::
+    DESTINATION "${SIMDUTF_INSTALL_CMAKEDIR}"
+    COMPONENT example_Development
+)
+
+
+# pkg-config
+include(cmake/JoinPaths.cmake)
+join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
+join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
+
+configure_file("simdutf.pc.in" "simdutf.pc" @ONLY)
+install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/simdutf.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+)
+#
+# CPack
+#
+if(is_top_project)
+  set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
+  set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
+  set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE-MIT")
+  set(CPACK_RPM_PACKAGE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE-MIT")
+  set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")
+  set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
+  include(CPack)
+endif()
+
+# ----
+
+
+
+if(SIMDUTF_TESTS AND NOT SIMDUTF_SANITIZE)
+  find_program(GREP grep)
+  find_program(NM nm)
+  if((NOT GREP) OR (NOT NM))
+    message("grep and nm are unavailable on this system.")
+  else()
+    add_test(
+      NAME "avoid_abort"
+      # Under FreeBSD, the __cxa_guard_abort symbol may appear but it is fine.
+      # So we want to look for <space><possibly _>abort as a test.
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} ' _*abort' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_cout"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} ' _*cout' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_cerr"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} ' _*cerr' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_printf"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} ' _*printf' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_stdout"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} stdout || exit 0 && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_stderr"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdutf> |  ${GREP} stderr || exit 0 && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+  endif()
+endif()
+
+if(SIMDUTF_FUZZERS)
+    add_subdirectory(fuzz)
+endif()