react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/validate_utf8_brute_force_tests.cpp

@@ -1,88 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/random_utf8.h>
-#include <tests/reference/validate_utf8.h>
-#include <tests/helpers/test.h>
-
-template <typename T>
-static void test_corrupt(T &implementation, uint32_t seed,
-                         simdutf::tests::helpers::random_utf8 gen_utf8) {
-  std::mt19937 gen(seed);
-  for (size_t i = 0; i < 10; i++) {
-    auto UTF8 = gen_utf8.generate(1000);
-    if (!implementation.validate_utf8((const char *)UTF8.data(), UTF8.size())) {
-      puts("bug");
-      ASSERT_TRUE(false);
-    }
-    std::uniform_int_distribution<size_t> distIdx{0, UTF8.size() - 1};
-    for (size_t j = 0; j < 1000; ++j) {
-      const size_t corrupt = distIdx(gen);
-      uint8_t restore = UTF8[corrupt];
-      UTF8[corrupt] = uint8_t(gen());
-      bool is_ok =
-          implementation.validate_utf8((const char *)UTF8.data(), UTF8.size());
-      bool is_ok_basic = simdutf::tests::reference::validate_utf8(
-          (const char *)UTF8.data(), UTF8.size());
-      if (is_ok != is_ok_basic) {
-        puts("bug");
-        ASSERT_TRUE(false);
-      }
-      UTF8[corrupt] = restore;
-    }
-  }
-}
-
-TEST(corrupt_1byte) {
-  uint32_t seed{1234};
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 1, 0, 0, 0));
-}
-
-TEST(corrupt_2byte) {
-  uint32_t seed{1234};
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 0, 1, 0, 0));
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 1, 1, 0, 0));
-}
-
-TEST(corrupt_3byte) {
-  uint32_t seed{1234};
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 0, 0, 1, 0));
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 0, 1, 1, 0));
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 1, 0, 1, 0));
-  test_corrupt(implementation, seed,
-               simdutf::tests::helpers::random_utf8(seed, 1, 1, 1, 0));
-}
-
-TEST(brute_force) {
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf8 gen_1_2_3_4(seed, 1, 1, 1, 1);
-  size_t total = 1000;
-  for (size_t i = 0; i < total; i++) {
-
-    auto UTF8 = gen_1_2_3_4.generate(rand() % 256);
-    if (!implementation.validate_utf8((const char *)UTF8.data(), UTF8.size())) {
-      puts("bug");
-      ASSERT_TRUE(false);
-    }
-    for (size_t flip = 0; flip < 1000; ++flip) {
-      // we are going to hack the string as long as it is UTF-8
-      const int bitflip{1 << (rand() % 8)};
-      UTF8[rand() % UTF8.size()] = uint8_t(bitflip); // we flip exactly one bit
-      bool is_ok =
-          implementation.validate_utf8((const char *)UTF8.data(), UTF8.size());
-      bool is_ok_basic = simdutf::tests::reference::validate_utf8(
-          (const char *)UTF8.data(), UTF8.size());
-      if (is_ok != is_ok_basic) {
-        puts("bug");
-        ASSERT_TRUE(false);
-      }
-    }
-  }
-}
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf8_puzzler_tests.cpp

@@ -1,33 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/test.h>
-
-// This is an attempt at reproducing an issue with the utf8 fuzzer
-TEST(puzzler) {
-  const char *bad64 =
-      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00"
-      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00"
-      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-  size_t length = 64;
-  ASSERT_FALSE(implementation.validate_utf8(bad64, length));
-}
-
-TEST(puzzler2) {
-  // Interesting case where the error occurs in the first 64 bytes but is only
-  // detected in the next 64 bytes.
-  const char *bad102 =
-      "\x0a\x04\x00\x00\xdb\xa1\xdd\xa1\xf1\xa0\xb6\x95\xe4\xb5\x89\xe7\x8f\x95"
-      "\xe4\xa2\x83\xe7\x95\x89\xe7\x95\x91\xe7\x95\x89\x00\x01\x01\x1a\x20\x28"
-      "\x00\x00\x60\x00\x00\x23\x00\xf1\xa0\xb6\x95\xe4\xb5\x89\xe7\x8f\x95\xe4"
-      "\xa2\x83\xe7\x95\x89\xe7\x95\x91\xe7\x81\x00\x00\x01\x01\x1a\x20\x28\x00"
-      "\x00\x60\x00\x00\x23\x00\x2f\x00\x00\x00\x00\x07\x04\x75\xc2\xa0\x34\x2f"
-      "\x00\x00\x00\x00\x07\x04\x75\xc2\xa0\x33\x53\x2b";
-  size_t length = 102;
-  ASSERT_FALSE(implementation.validate_utf8(bad102, length));
-  auto r = implementation.validate_utf8_with_errors(bad102, length);
-  ASSERT_EQUAL(r.error, simdutf::TOO_SHORT);
-  ASSERT_EQUAL(r.count, 62);
-}
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf8_with_errors_tests.cpp

@@ -1,228 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf8.h>
-#include <tests/helpers/test.h>
-
-TEST(validate_utf8_with_errors_cbf29ce4842223f0) {
-  const unsigned char data[] = {
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xff};
-  constexpr std::size_t data_len_bytes = sizeof(data);
-  constexpr std::size_t data_len = data_len_bytes / sizeof(char);
-  const auto validation1 =
-      implementation.validate_utf8_with_errors((const char *)data, data_len);
-  /*
-  got return [count=64, error=SUCCESS] from implementation icelake
-  got return [count=63, error=HEADER_BITS] from implementation haswell
-  got return [count=63, error=HEADER_BITS] from implementation westmere
-  got return [count=63, error=HEADER_BITS] from implementation fallback
-  */
-  ASSERT_EQUAL(validation1.count, 63);
-  ASSERT_EQUAL(validation1.error, simdutf::error_code::HEADER_BITS);
-}
-
-// https://github.com/nodejs/node/issues/48995
-TEST(node48995) {
-  const char bad[1] = {(char)0x80};
-  size_t length = 1;
-  simdutf::result res = implementation.validate_utf8_with_errors(bad, length);
-  ASSERT_TRUE(res.error);
-}
-
-TEST(copyright) {
-  const char good[2] = {'\xC2', '\xA9'};
-  size_t length = 2;
-  simdutf::result res = implementation.validate_utf8_with_errors(good, length);
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-}
-
-TEST_LOOP(no_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  const auto utf8{generator.generate(512, seed)};
-  simdutf::result res = implementation.validate_utf8_with_errors(
-      reinterpret_cast<const char *>(utf8.data()), utf8.size());
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf8.size());
-}
-
-TEST_LOOP(header_bits_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-
-  for (unsigned int i = 0; i < 512; i++) {
-    if ((utf8[i] & 0b11000000) != 0b10000000) { // Only process leading bytes
-      const unsigned char old = utf8[i];
-      utf8[i] = uint8_t(0b11111000);
-      simdutf::result res = implementation.validate_utf8_with_errors(
-          reinterpret_cast<const char *>(utf8.data()), utf8.size());
-      ASSERT_EQUAL(res.error, simdutf::error_code::HEADER_BITS);
-      ASSERT_EQUAL(res.count, i);
-      utf8[i] = old;
-    }
-  }
-}
-
-TEST_LOOP(too_short_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-  int leading_byte_pos = 0;
-  for (int i = 0; i < 512; i++) {
-    if ((utf8[i] & 0b11000000) ==
-        0b10000000) { // Only process continuation bytes by making them leading
-                      // bytes
-      const unsigned char old = utf8[i];
-      utf8[i] = uint8_t(0b11100000);
-      simdutf::result res = implementation.validate_utf8_with_errors(
-          reinterpret_cast<const char *>(utf8.data()), utf8.size());
-      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_SHORT);
-      ASSERT_EQUAL(res.count, static_cast<unsigned>(leading_byte_pos));
-      utf8[i] = old;
-    } else {
-      leading_byte_pos = i;
-    }
-  }
-}
-
-TEST_LOOP(too_long_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-  for (unsigned int i = 1; i < 512; i++) {
-    if (((utf8[i] & 0b11000000) !=
-         0b10000000)) { // Only process leading bytes by making them
-                        // continuation bytes
-      const unsigned char old = utf8[i];
-      utf8[i] = uint8_t(0b10000000);
-      simdutf::result res = implementation.validate_utf8_with_errors(
-          reinterpret_cast<const char *>(utf8.data()), utf8.size());
-      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LONG);
-      ASSERT_EQUAL(res.count, i);
-      utf8[i] = old;
-    }
-  }
-}
-
-TEST_LOOP(overlong_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-  for (unsigned int i = 1; i < 512; i++) {
-    if (utf8[i] >= 0b11000000) { // Only non-ASCII leading bytes can be overlong
-      const unsigned char old = utf8[i];
-      const unsigned char second_old = utf8[i + 1];
-      if ((old & 0b11100000) == 0b11000000) { // two-bytes case, change to a
-                                              // value less or equal than 0x7f
-        utf8[i] = 0b11000000;
-      } else if ((old & 0b11110000) ==
-                 0b11100000) { // three-bytes case, change to a value less or
-                               // equal than 0x7ff
-        utf8[i] = 0b11100000;
-        utf8[i + 1] = utf8[i + 1] & 0b11011111;
-      } else { // four-bytes case, change to a value less or equal than 0xffff
-        utf8[i] = 0b11110000;
-        utf8[i + 1] = utf8[i + 1] & 0b11001111;
-      }
-      simdutf::result res = implementation.validate_utf8_with_errors(
-          reinterpret_cast<const char *>(utf8.data()), utf8.size());
-      ASSERT_EQUAL(res.error, simdutf::error_code::OVERLONG);
-      ASSERT_EQUAL(res.count, i);
-      utf8[i] = old;
-      utf8[i + 1] = second_old;
-    }
-  }
-}
-
-TEST_LOOP(too_large_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-  for (unsigned int i = 1; i < 512; i++) {
-    if ((utf8[i] & 0b11111000) ==
-        0b11110000) { // Can only have too large error in 4-bytes case
-      utf8[i] += ((utf8[i] & 0b100) == 0b100)
-                     ? 0b10
-                     : 0b100; // Make sure we get too large error and not header
-                              // bits error
-      simdutf::result res = implementation.validate_utf8_with_errors(
-          reinterpret_cast<const char *>(utf8.data()), utf8.size());
-      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LARGE);
-      ASSERT_EQUAL(res.count, i);
-      utf8[i] -= 0b100;
-    }
-  }
-}
-
-TEST_LOOP(surrogate_error) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
-  auto utf8{generator.generate(512, seed)};
-  for (unsigned int i = 1; i < 512; i++) {
-    if ((utf8[i] & 0b11110000) ==
-        0b11100000) { // Can only have surrogate error in 3-bytes case
-      const unsigned char old = utf8[i];
-      const unsigned char second_old = utf8[i + 1];
-      utf8[i] = 0b11101101; // Leading byte is always the same
-      for (int s = 0x8; s < 0xf;
-           s++) { // Modify second byte to create a surrogate codepoint
-        utf8[i + 1] = (utf8[i + 1] & 0b11000011) | (s << 2);
-        simdutf::result res = implementation.validate_utf8_with_errors(
-            reinterpret_cast<const char *>(utf8.data()), utf8.size());
-        ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
-        ASSERT_EQUAL(res.count, i);
-      }
-      utf8[i] = old;
-      utf8[i + 1] = second_old;
-    }
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-void compile_time_test_of_good_data() {
-
-  using namespace simdutf::tests::helpers;
-  constexpr auto good = u8"köttbulle"_utf8;
-
-  static_assert(good.size() == 10);
-  static_assert(!simdutf::validate_utf8_with_errors(good).error);
-  static_assert(
-      !simdutf::validate_utf8_with_errors(good.as_array<signed char>()).error);
-  static_assert(
-      !simdutf::validate_utf8_with_errors(good.as_array<unsigned char>())
-           .error);
-  static_assert(
-      !simdutf::validate_utf8_with_errors(good.as_array<std::byte>()).error);
-}
-
-namespace {
-template <typename DestCharType, typename ArrayInput>
-constexpr auto convert_array(const ArrayInput &input) {
-  std::array<DestCharType, ArrayInput{}.size()> ret;
-  for (std::size_t i = 0; i < ArrayInput{}.size(); ++i) {
-    ret[i] = static_cast<DestCharType>(input[i]);
-  }
-  return ret;
-}
-} // namespace
-
-void compile_time_test_of_bad_data() {
-  constexpr std::array bad_utf8{'a', '\xFF'};
-  static_assert(simdutf::validate_utf8_with_errors(bad_utf8).error !=
-                simdutf::SUCCESS);
-  static_assert(simdutf::validate_utf8_with_errors(bad_utf8).count == 1);
-  static_assert(
-      simdutf::validate_utf8_with_errors(convert_array<char>(bad_utf8)).error);
-  static_assert(
-      simdutf::validate_utf8_with_errors(convert_array<signed char>(bad_utf8))
-          .error);
-  static_assert(
-      simdutf::validate_utf8_with_errors(convert_array<unsigned char>(bad_utf8))
-          .error);
-  static_assert(
-      simdutf::validate_utf8_with_errors(convert_array<std::byte>(bad_utf8))
-          .error);
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tools/CMakeLists.txt

@@ -1,85 +0,0 @@
-cmake_minimum_required(VERSION 3.15)
-
-add_executable(sutf sutf.cpp)
-add_executable(fastbase64 fastbase64.cpp)
-
-if(SIMDUTF_ICONV)
-find_package(Iconv)
-if(Iconv_FOUND)
-  message(STATUS "Iconv was found!")
-  target_compile_definitions(sutf 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(sutf PUBLIC ${Iconv_LIBRARY})
-    target_include_directories(sutf 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)
-if(APPLE)
-  message(STATUS "This is an Apple platform " ${CMAKE_CXX_COMPILER_ID})
-
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    message(STATUS "Apple platform detected, using dead_strip and LTO")
-    target_link_options(sutf PRIVATE "-Wl,-dead_strip")
-    target_link_options(fastbase64 PRIVATE "-Wl,-dead_strip")
-    target_compile_options(sutf PRIVATE "-flto")
-    target_link_options(sutf PRIVATE "-flto")
-    target_compile_options(fastbase64 PRIVATE "-flto")
-    target_link_options(fastbase64 PRIVATE "-flto")
-  endif()
-endif()
-
-if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
-  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-libgcc-file-name OUTPUT_VARIABLE SIMDUTF_GCC_LIB)
-  get_filename_component(SIMDUTF_GCC_DIR "${SIMDUTF_GCC_LIB}" DIRECTORY)
-  message(STATUS "looking for static C++ library in " ${SIMDUTF_GCC_DIR})
-  find_library(LIBSTDCPP libstdc++.a PATHS "${SIMDUTF_GCC_DIR}")
-  if(LIBSTDCPP)
-    message(STATUS "libstdc++.a found")
-    target_link_options(sutf PRIVATE "-static-libstdc++")
-    target_link_options(fastbase64 PRIVATE "-static-libstdc++")
-  else()
-    message(STATUS "libstdc++.a not found")
-  endif()
-  if(NOT APPLE)
-    target_link_options(sutf PRIVATE "-Wl,--gc-sections")
-    target_link_options(fastbase64 PRIVATE "-Wl,--gc-sections")
-  endif()
-endif()
-message(STATUS "The tools require C++17. If your system does not support C++17, please set SIMDUTF_TOOLS to OFF.")
-set_property(TARGET sutf PROPERTY CXX_STANDARD 17)
-set_property(TARGET sutf PROPERTY CXX_STANDARD_REQUIRED ON)
-set_property(TARGET fastbase64 PROPERTY CXX_STANDARD 17)
-set_property(TARGET fastbase64 PROPERTY CXX_STANDARD_REQUIRED ON)
-
-target_link_libraries(sutf PUBLIC simdutf)
-target_link_libraries(fastbase64 PUBLIC simdutf)
-
-if(WIN32 AND BUILD_SHARED_LIBS)
-  # Copy the simdutf dll into the directory
-  add_custom_command(TARGET sutf 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:sutf>")                 # <--this is out-file path
-endif()
-install(
-   TARGETS
-    sutf
-   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
-install(
-   TARGETS
-    fastbase64
-   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)

package/deps/simdutf/tools/fastbase64.cpp

@@ -1,250 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <cerrno>
-#include <filesystem>
-#include <vector>
-
-class CommandLine {
-public:
-  std::FILE *current_file{NULL};
-  std::filesystem::path output_file;
-
-  CommandLine() = default;
-  static CommandLine parse_and_validate_arguments(int argc, char *argv[]);
-  bool run_procedure(std::FILE *fpout);
-  bool encode_to(std::FILE *fpout);
-  bool decode_to(std::FILE *fpout);
-  bool run();
-  std::pair<bool, size_t> load_chunk(char *input_data, size_t chunk_size,
-                                     size_t offset);
-  bool write_to_file_descriptor(std::FILE *fp, const char *data, size_t length);
-  static void show_help();
-  bool decode;
-};
-
-CommandLine CommandLine::parse_and_validate_arguments(int argc, char *argv[]) {
-  CommandLine cmdline;
-  std::vector<std::string> arguments;
-
-  for (int i = 1; i < argc; i++) {
-    std::string arg{argv[i]};
-    if ((arg == "-h") || (arg == "--help")) {
-      CommandLine::show_help();
-      return cmdline;
-    } else {
-      arguments.push_back(std::move(arg));
-    }
-  }
-  if (arguments.size() == 0) {
-    throw std::runtime_error("Too few arguments!");
-  }
-  cmdline.decode = false;
-  for (std::string &a : arguments) {
-    if (a == "-d") {
-      cmdline.decode = true;
-    } else if (a == "-e") {
-      cmdline.decode = false;
-    } else if (a[0] == '-') {
-      throw std::runtime_error("Unknown option: " + a);
-    } else {
-      if (cmdline.current_file == NULL) {
-        cmdline.current_file = std::fopen(a.c_str(), "rb");
-        if (cmdline.current_file == NULL) {
-          throw std::runtime_error("Could not open file: " + a + ":" +
-                                   std::string(strerror(errno)));
-        }
-      } else if (cmdline.output_file.empty()) {
-        cmdline.output_file = a;
-      } else {
-        throw std::runtime_error("Too many arguments!");
-      }
-    }
-  }
-  return cmdline;
-}
-
-bool CommandLine::run() {
-  if (current_file == NULL) {
-    throw std::runtime_error("No input file specified!");
-  }
-  if (output_file.empty()) {
-    return run_procedure(stdout);
-  } else {
-    SIMDUTF_PUSH_DISABLE_WARNINGS
-    SIMDUTF_DISABLE_DEPRECATED_WARNING
-    std::FILE *fp = std::fopen(output_file.string().c_str(), "wb");
-    SIMDUTF_POP_DISABLE_WARNINGS
-    if (fp == NULL) {
-      fprintf(stderr, "Could not open %s: %s\n", output_file.string().c_str(),
-              strerror(errno));
-      return false;
-    }
-    bool success = run_procedure(fp);
-    // Let us first try to close the file.
-    if (fclose(fp) != 0) {
-      fprintf(stderr, "Failed to close %s: %s\n", output_file.string().c_str(),
-              strerror(errno));
-      return false;
-    }
-    return success;
-  }
-}
-
-bool CommandLine::run_procedure(std::FILE *fpout) {
-  if (decode) {
-    return decode_to(fpout);
-  } else {
-    return encode_to(fpout);
-  }
-}
-
-// load_chunk returns a pair of a boolean and a size_t, the boolean is true
-// until we reach the end of the stream, the size_t is the number of bytes read.
-std::pair<bool, size_t>
-CommandLine::load_chunk(char *input_data, size_t chunk_size, size_t offset) {
-  size_t bytes_read =
-      std::fread(input_data + offset, 1, chunk_size - offset, current_file);
-  if (std::ferror(current_file)) {
-    std::fclose(current_file);
-    throw std::runtime_error("Error while reading:" +
-                             std::string(strerror(errno)));
-  }
-  if (std::feof(current_file)) { // Check if current_file is done
-    std::fclose(current_file);   // best effort
-    current_file = NULL;
-    return {false, bytes_read};
-  }
-  return {true, bytes_read};
-}
-
-bool CommandLine::write_to_file_descriptor(std::FILE *fp, const char *data,
-                                           size_t length) {
-  if (fp == NULL) {
-    return false;
-  }
-  size_t bytes_written = std::fwrite(data, 1, length, fp);
-  if (bytes_written != length) {
-    throw std::runtime_error("Failed to write:" + std::string(strerror(errno)));
-  }
-  return true;
-}
-
-bool CommandLine::decode_to(std::FILE *fpout) {
-  const size_t chunk_size = 65536;
-  std::array<char, chunk_size> input_data;
-  std::array<char, (chunk_size + 3) / 4 * 3> output_buffer;
-  size_t pos =
-      0; // the pos variable keeps track of the position in the input file.
-  // Its purpose is to provide a position for error messages.
-  size_t offset = 0;
-  // load_chunk returns a pair of a boolean and a size_t, the boolean is true
-  // until we reach the end of the stream, the size_t is the number of bytes
-  // read.
-  for (auto p = load_chunk(input_data.data(), chunk_size, offset); p.second > 0;
-       p = load_chunk(input_data.data(), chunk_size, offset)) {
-    // We convertto base64 the data we have read so far
-    simdutf::result r = simdutf::base64_to_binary(
-        input_data.data(), p.second + offset, output_buffer.data());
-    // If we have encountered an invalid character, we print an error message
-    // and return false.
-    if (r.error == simdutf::error_code::INVALID_BASE64_CHARACTER) {
-      fprintf(stderr, "Invalid base64 character at position %zu\n.",
-              pos + r.count);
-      return false;
-    }
-    // if p.first is false, we have reached the end of the file.
-    if (!p.first) {
-      // At the end of the file, if we are left with one base64 character
-      // leftover, it is a fatal error.
-      if (r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
-        fprintf(stderr, "The base64 input contained an invalid number of "
-                        "characters or could not be read.");
-        return false;
-      }
-      // Otherwise, we write the output and return true.
-      write_to_file_descriptor(fpout, output_buffer.data(), r.count);
-      return true;
-    }
-    // We want to write the data in chunks of 3 bytes and read blocks of
-    // 4 bytes. We keep the last 0, 1, 3 or 4 base64 bytes in the input buffer.
-    // And we write the output in chunks of 3 bytes.
-    offset = 0;
-    if (r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
-      offset = 1;
-    } else {
-      offset = (r.count % 3) == 0 ? 0 : (r.count % 3) + 1;
-    }
-    // Copy 0, 1, 2 or 3 non-space bytes to the input buffer.
-    size_t copied = 0;
-    for (size_t z = p.second - 1; copied < offset; z--) {
-      if (input_data[z] == ' ' || input_data[z] == '\n' ||
-          input_data[z] == '\r' || input_data[z] == '\t') {
-        continue;
-      }
-      copied++;
-      input_data[offset - copied] = input_data[z];
-    }
-    // We write a multiple of 3 bytes to the output buffer, discarding
-    // the last 0, 1 or 2 bytes.
-    r.count -= (r.count % 3);
-    write_to_file_descriptor(fpout, output_buffer.data(), r.count);
-    pos += p.second;
-  }
-  return true;
-}
-
-bool CommandLine::encode_to(std::FILE *fpout) {
-  const size_t chunk_size = 49152;
-  std::array<char, chunk_size> input_data;
-  std::array<char, (chunk_size + 2) / 3 * 4> output_buffer;
-  size_t pos = 0;
-  size_t offset = 0;
-  // load_chunk returns a pair of a boolean and a size_t, the boolean is true
-  // until we reach the end of the stream, the size_t is the number of bytes
-  // read.
-  for (auto p = load_chunk(input_data.data(), chunk_size, offset); p.second > 0;
-       p = load_chunk(input_data.data(), chunk_size, offset)) {
-    // We have read p.second bytes, and we have offset bytes left from the
-    // previous chunk.
-    size_t total_bytes = p.second + offset;
-    // If we have reached the end of the file, we write the output and return
-    // true.
-    if (!p.first) {
-      // We finish the file
-      size_t output_size = simdutf::binary_to_base64(
-          input_data.data(), total_bytes, output_buffer.data());
-      write_to_file_descriptor(fpout, output_buffer.data(), output_size);
-      return true;
-    }
-    // We want to write the data in chunks of 4 bytes and read blocks of
-    // 3 bytes. We keep the last 0, 1 or 2 bytes in the input buffer.
-    offset = total_bytes % 3;
-    total_bytes -= offset;
-    size_t output_size = simdutf::binary_to_base64(
-        input_data.data(), total_bytes, output_buffer.data());
-    write_to_file_descriptor(fpout, output_buffer.data(), output_size);
-    // Copy 0, 1 or 2 bytes to the start of the input buffer.
-    memcpy(input_data.data(), input_data.data() + total_bytes, offset);
-  }
-  return true;
-}
-
-void CommandLine::show_help() {
-  printf("Usage: fastbase64 [OPTIONS...] [INPUTFILE] [OUTPUTFILE]\n\n");
-  printf("  -d       decode base64\n"
-         "  -e       encode base64 (default)\n\n");
-  printf("If output is not specified, the output is redirected to standard "
-         "output.\n");
-}
-
-int main(int argc, char *argv[]) {
-  try {
-    CommandLine cmdline = CommandLine::parse_and_validate_arguments(argc, argv);
-    return cmdline.run() ? EXIT_SUCCESS : EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    fprintf(stderr, "%s\n", e.what());
-    CommandLine::show_help();
-    return EXIT_FAILURE;
-  }
-}