react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/Makefile.crosscompile

@@ -1,54 +0,0 @@
-ALL=aarch64     \
-    loongarch64 \
-    powerpc64   \
-    powerpc64le \
-    riscv64
-
-.PHONY: help
-help:
-	@echo "Build simdutf using the installed crosscompilers"
-	@echo "Known crosscompilers:"
-	@echo "- make aarch64"
-	@echo "- make loongarch64"
-	@echo "- make powerpc64"
-	@echo "- make powerpc64le"
-	@echo "- make riscv64"
-	@echo ""
-	@echo "To run all above use:"
-	@echo "- make all"
-
-.PHONY: all
-all: $(ALL)
-
-.PHONY: aarch64
-aarch64:
-	cmake -B $@build -GNinja --toolchain cmake/toolchains-dev/$@.cmake
-	cmake --build $@build
-
-.PHONY: loongarch64
-loongarch64:
-	cmake -B $@build -GNinja --toolchain cmake/toolchains-dev/$@.cmake
-	cmake --build $@build
-
-.PHONY: powerpc64
-powerpc64:
-	cmake -B $@build -GNinja --toolchain cmake/toolchains-dev/$@.cmake
-	cmake --build $@build
-
-.PHONY: powerpc64le
-powerpc64le:
-	cmake -B $@build -GNinja --toolchain cmake/toolchains-dev/$@.cmake -D SIMDUTF_AMALGAMATION=OFF -D SIMDUTF_INTERNAL_TESTS=ON
-	cmake --build $@build
-
-.PHONY: riscv64
-riscv64:
-	cmake -B $@build -GNinja --toolchain cmake/toolchains-dev/$@.cmake
-	cmake --build $@build
-
-.PHONY: clean
-clean:
-	rm -rf aarch64build
-	rm -rf loongarch64build
-	rm -rf powerpc64build
-	rm -rf powerpc64lebuild
-	rm -rf riscv64build

package/deps/simdutf/README-RVV.md

@@ -1,16 +0,0 @@
-Developing for RISC-V Vector extension (RVV)
---------------------------------------------------------------------------------
-
-Since RVV is not widely available, we still can check validity of implementation
-using either QEMU or Spike emulator.
-
-To use Spike one has to specify the toolchain:
-
-```
-$ cmake -B rvvbuild -DCMAKE_TOOLCHAIN_FILE=toolchain-rvv-spike.cmake
-$ cmake --build rvvbuild
-$ cd rvvbuild
-```
-
-To use QEMU, please refer to `.github/workflows/rvv-128-clang-17.yml` for
-command line options.

package/deps/simdutf/SECURITY.md

@@ -1,8 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please use the following contact information for reporting a vulnerability:
-
-- [Daniel Lemire](https://github.com/lemire) - daniel@lemire.me
-- [Paul Driek](https://github.com/pauldreik) -  firstname@thisdomainname where the domain is pauldreik.se, PGP key is 44EAE0EB.

package/deps/simdutf/benchmarks/CMakeLists.txt

@@ -1,101 +0,0 @@
-if (CMAKE_COMPILER_IS_GNUCXX)
-  add_compile_options("-fdiagnostics-color")
-  add_compile_options("-Wpedantic")
-  add_compile_options("-Wextra")
-  add_compile_options("-Wall")
-endif()
-
-
-if(MSVC)
-  add_compile_options("/Zi" "/EHsc" "/GR")
-endif()
-
-if(SIMDUTF_SANITIZE)
-  add_compile_options(-fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
-  add_compile_definitions(ASAN_OPTIONS=detect_leaks=1)
-endif()
-
-
-add_executable(stream stream.cpp)
-target_link_libraries(stream PUBLIC simdutf)
-
-if(SIMDUTF_ICONV)
-find_package(Iconv)
-if(Iconv_FOUND)
-  target_compile_definitions(stream PRIVATE ICONV_AVAILABLE=1)
-  if(Iconv_IS_BUILT_IN)
-    message(STATUS "Iconv is part of the C library.")
-  else(Iconv_IS_BUILT_IN)
-    message(STATUS "Iconv is a separate library, headers at ${Iconv_INCLUDE_DIR}, binary at ${Iconv_LIBRARY}")
-    target_link_libraries(stream PUBLIC  ${Iconv_LIBRARY})
-    target_include_directories(stream PUBLIC ${Iconv_INCLUDE_DIR})
-  endif(Iconv_IS_BUILT_IN)
-else(Iconv_FOUND)
-  message(STATUS "Iconv was not found!")
-endif(Iconv_FOUND)
-else(SIMDUTF_ICONV)
-  message(STATUS "We are not seeking iconv.")
-endif(SIMDUTF_ICONV)
-
-add_subdirectory(src)
-
-add_executable(benchmark benchmark.cpp)
-target_link_libraries(benchmark PUBLIC simdutf::benchmarks::benchmark)
-
-set_property(TARGET benchmark PROPERTY CXX_STANDARD 17)
-set_property(TARGET benchmark PROPERTY CXX_STANDARD_REQUIRED ON)
-
-if(WIN32 AND BUILD_SHARED_LIBS)
-  # Copy the simdutf dll into the benchmark directory
-  add_custom_command(TARGET stream POST_BUILD        # Adds a post-build event
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different  # which executes "cmake -E copy_if_different..."
-        "$<TARGET_FILE:simdutf>"      # <--this is in-file
-        "$<TARGET_FILE_DIR:random_fuzzer>")                 # <--this is out-file path
-endif()
-
-
-set_property(TARGET stream PROPERTY CXX_STANDARD 17)
-set_property(TARGET stream PROPERTY CXX_STANDARD_REQUIRED ON)
-
-add_executable(alignment alignment.cpp)
-target_link_libraries(alignment PUBLIC simdutf)
-
-set_property(TARGET alignment PROPERTY CXX_STANDARD 17)
-set_property(TARGET alignment PROPERTY CXX_STANDARD_REQUIRED ON)
-
-
-
-find_package(Threads)
-
-if(Threads_FOUND)
-  add_executable(threaded threaded.cpp)
-  target_link_libraries(threaded PUBLIC simdutf)
-  target_link_libraries(threaded PUBLIC Threads::Threads)
-
-  set_property(TARGET threaded PROPERTY CXX_STANDARD 17)
-  set_property(TARGET threaded PROPERTY CXX_STANDARD_REQUIRED ON)
-endif(Threads_FOUND)
-
-option(SIMDUTF_BENCHMARK_BASE64 "Whether the base64 benchmarks are included as part of the CMake Build (requires C++17 or better)." ON)
-
-if(SIMDUTF_BENCHMARK_BASE64)
-  if(CMAKE_CXX_COMPILER_ID STREQUAL Clang AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
-    message(STATUS "Not building base64 benchmarks when using clang-cl due to build errors with the aklomp/base64 dependency.")
-  else()
-    add_subdirectory(base64)
-  endif()
-endif(SIMDUTF_BENCHMARK_BASE64)
-
-
-add_executable(benchmark_to_well_formed_utf16 benchmark_to_well_formed_utf16.cpp)
-target_link_libraries(benchmark_to_well_formed_utf16 PUBLIC simdutf)
-target_link_libraries(benchmark_to_well_formed_utf16 PUBLIC simdutf::benchmarks::benchmark)
-set_property(TARGET benchmark_to_well_formed_utf16 PROPERTY CXX_STANDARD 17)
-set_property(TARGET benchmark_to_well_formed_utf16 PROPERTY CXX_STANDARD_REQUIRED ON)
-
-
-add_executable(shortbench shortbench.cpp)
-target_link_libraries(shortbench PUBLIC simdutf::benchmarks::benchmark)
-target_compile_features(shortbench PRIVATE cxx_std_20)
-
-add_subdirectory(find)

package/deps/simdutf/benchmarks/alignment.cpp

@@ -1,150 +0,0 @@
-/**
- * This simple program is meant to test the effect of alignment on the speed.
- */
-
-#include <chrono>
-#include <cmath>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-#include "simdutf.h"
-
-uint64_t nano() {
-  return std::chrono::duration_cast<::std::chrono::nanoseconds>(
-             std::chrono::steady_clock::now().time_since_epoch())
-      .count();
-}
-
-template <typename PROCEDURE>
-double bench(PROCEDURE f, uint64_t threshold = 200'000'000) {
-  uint64_t start = nano();
-  uint64_t finish = start;
-  size_t times{0};
-  for (; finish - start < threshold; times++) {
-    size_t output_size = f();
-    if (output_size == 0) {
-      throw std::runtime_error("bad input?");
-    }
-    finish = nano();
-  }
-  return double(finish - start) / times;
-}
-
-void run_from_utf8(const std::vector<char> &input_data) {
-  std::cout << "# aligning input" << std::endl;
-  std::cout << "# input size = " << input_data.size() << " bytes" << std::endl;
-  std::vector<char> tmp_buffer(input_data);
-  tmp_buffer.resize(tmp_buffer.size() + 512);
-  std::vector<char16_t> buffer(
-      simdutf::utf16_length_from_utf8(input_data.data(), input_data.size()));
-  size_t utf8count = simdutf::count_utf8(input_data.data(), input_data.size());
-  // Let us warm up:
-  bench(
-      [&tmp_buffer, &input_data, &buffer]() -> size_t {
-        return simdutf::convert_utf8_to_utf16le(
-            tmp_buffer.data(), input_data.size(), buffer.data());
-      },
-      2'000'000'000);
-  // warmed up
-  double best_speed = 0;
-  double worst_speed = 1e300;
-
-  for (size_t offset = 0; offset < 512; offset += 1) {
-    memcpy(tmp_buffer.data() + offset, input_data.data(), input_data.size());
-
-    std::cout << offset << ",\t";
-    auto size_procedure = [&tmp_buffer, &input_data, offset,
-                           &buffer]() -> size_t {
-      return simdutf::convert_utf8_to_utf16le(tmp_buffer.data() + offset,
-                                              input_data.size(), buffer.data());
-    };
-    double speed = utf8count / bench(size_procedure);
-    if (speed > best_speed) {
-      best_speed = speed;
-    }
-    if (speed < worst_speed) {
-      worst_speed = speed;
-    }
-
-    std::cout << speed << "\n";
-  }
-  std::cout << "# worst speed " << worst_speed << std::endl;
-  std::cout << "# best speed " << best_speed << std::endl;
-  std::cout << "# difference (percent) " << (best_speed / worst_speed - 1) * 100
-            << std::endl;
-}
-
-void run_from_utf8_output(const std::vector<char> &input_data) {
-  std::cout << "# aligning output" << std::endl;
-  std::cout << "# input size = " << input_data.size() << " bytes" << std::endl;
-
-  std::vector<char16_t> buffer(
-      simdutf::utf16_length_from_utf8(input_data.data(), input_data.size()) +
-      512);
-  size_t utf8count = simdutf::count_utf8(input_data.data(), input_data.size());
-  // Let us warm up:
-  bench(
-      [&input_data, &buffer]() -> size_t {
-        return simdutf::convert_utf8_to_utf16le(
-            input_data.data(), input_data.size(), buffer.data());
-      },
-      2'000'000'000);
-  // warmed up
-  double best_speed = 0;
-  double worst_speed = 1e300;
-
-  for (size_t offset = 0; offset < 512; offset += 1) {
-
-    std::cout << offset << ",\t";
-    auto size_procedure = [&input_data, offset, &buffer]() -> size_t {
-      return simdutf::convert_utf8_to_utf16le(
-          input_data.data(), input_data.size(), buffer.data() + offset);
-    };
-    double speed = utf8count / bench(size_procedure);
-    if (speed > best_speed) {
-      best_speed = speed;
-    }
-    if (speed < worst_speed) {
-      worst_speed = speed;
-    }
-
-    std::cout << speed << "\n";
-  }
-  std::cout << "# worst speed " << worst_speed << std::endl;
-  std::cout << "# best speed " << best_speed << std::endl;
-  std::cout << "# difference (percent) " << (best_speed / worst_speed - 1) * 100
-            << std::endl;
-}
-
-int main(int argc, char **argv) {
-  printf("# current system detected as %s.\n",
-         simdutf::get_active_implementation()->name().c_str());
-  if (argc < 2) {
-    std::cerr << "Please provide a file argument." << std::endl;
-    return EXIT_FAILURE;
-  }
-  const char *filename = argv[1];
-  printf("# loading file %s\n", filename);
-  std::filesystem::path path(filename);
-  std::ifstream file;
-  file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-  file.open(path);
-  std::vector<char> input_data;
-  input_data.assign(std::istreambuf_iterator<char>(file),
-                    std::istreambuf_iterator<char>());
-  auto detected_encoding =
-      simdutf::autodetect_encoding(input_data.data(), input_data.size());
-  printf("# input detected as %s.\n",
-         simdutf::to_string(detected_encoding).c_str());
-  if (detected_encoding == simdutf::encoding_type::UTF8) {
-    run_from_utf8_output(input_data);
-    std::cout << "----" << std::endl;
-
-    run_from_utf8(input_data);
-  } else {
-    printf("We only support UTF-8 inputs.\n");
-  }
-  return EXIT_SUCCESS;
-}

package/deps/simdutf/benchmarks/base64/CMakeLists.txt

@@ -1,30 +0,0 @@
-include(../../cmake/CPM.cmake)
-CPMAddPackage(
-  NAME base64
-  GITHUB_REPOSITORY aklomp/base64
-  VERSION 0.5.2
-  OPTIONS "BASE64_BUILD_CLI Off"
-)
-
-# Check if the compiler supports C++20
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("/std:c++20" MSVC_CXX20_SUPPORTED) # For MSVC
-check_cxx_compiler_flag("-std=c++20" UNIX_CXX20_SUPPORTED) # For GCC/Clang
-
-if((CMAKE_CXX_COMPILER_ID MATCHES "MSVC" AND MSVC_CXX20_SUPPORTED) OR
-   (NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC" AND UNIX_CXX20_SUPPORTED))
-    message(STATUS "Compiler supports C++20")
-  add_executable(benchmark_base64 benchmark_base64.cpp)
-  set_property(TARGET benchmark_base64 PROPERTY CXX_STANDARD 20)
-  set_property(TARGET benchmark_base64 PROPERTY CXX_STANDARD_REQUIRED ON)
-
-  target_link_libraries(benchmark_base64 PUBLIC base64)
-  target_link_libraries(benchmark_base64 PUBLIC simdutf::benchmarks::benchmark)
-
-  # check if simdutf was built with c++ 20 - otherwise atomic base64 operations are not available
-  get_property(SIMDUTF_COMPILED_CXX_VERSION TARGET simdutf PROPERTY CXX_STANDARD)
-  message(VERBOSE "simdutf version is ${SIMDUTF_COMPILED_CXX_VERSION}")
-  target_compile_definitions(benchmark_base64 PRIVATE SIMDUTF_COMPILED_CXX_VERSION=${SIMDUTF_COMPILED_CXX_VERSION})
-else()
-  message(STATUS "Compiler does not support C++20. We not building the tool benchmark_base64.")
-endif()