react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/tools/sutf.cpp

@@ -0,0 +1,556 @@
+#include "sutf.h"
+
+#include <vector>
+#include <string>
+#include <set>
+#include <filesystem>
+#include <iterator>
+#include <climits>
+#include <cerrno>
+
+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 if ((arg == "-u") || (arg == "--usage")) {
+      CommandLine::show_usage();
+      return cmdline;
+    } else if ((arg == "-l") || (arg == "--list")) {
+      CommandLine::show_formats();
+      return cmdline;
+    } else {
+      arguments.push_back(std::move(arg));
+    }
+  }
+
+  bool has_from_arg = false;
+  bool has_to_arg = false;
+  bool has_output_arg = false;
+
+  for (size_t i = 0; i < arguments.size();) {
+    const std::string &arg = arguments[i];
+    size_t size = arg.size();
+
+    if (arg == "-f") {
+      if (has_from_arg) {
+        throw std::invalid_argument(
+            "Only a single source encoding argument is allowed.");
+      }
+      const std::string &value = arguments.at(i + 1);
+      cmdline.from_encoding = value;
+      has_from_arg = true;
+      i += 2;
+    } else if (arg == "-t") {
+      if (has_to_arg) {
+        throw std::invalid_argument(
+            "Only a single destination encoding argument is allowed.");
+      }
+      const std::string &value = arguments.at(i + 1);
+      cmdline.to_encoding = value;
+      has_to_arg = true;
+      i += 2;
+    } else if (arg == "-o") {
+      if (has_output_arg) {
+        throw std::invalid_argument("Only a single output file is allowed.");
+      }
+      has_output_arg = true;
+      const std::string &value = arguments.at(i + 1);
+      cmdline.output_file = value;
+      i += 2;
+    } else if (size > 12 && arg.substr(0, 12) == "--from-code=") {
+      if (has_from_arg) {
+        throw std::invalid_argument(
+            "Only a single source encoding argument is allowed.");
+      }
+      cmdline.from_encoding = arg.substr(12);
+      has_from_arg = true;
+      i++;
+    } else if (size > 10 && arg.substr(0, 10) == "--to-code=") {
+      if (has_to_arg) {
+        throw std::invalid_argument(
+            "Only a single destination encoding argument is allowed.");
+      }
+      cmdline.to_encoding = arg.substr(10);
+      has_to_arg = true;
+      i++;
+    } else if (size > 9 && arg.substr(0, 9) == "--output=") {
+      if (has_output_arg) {
+        throw std::invalid_argument("Only a single output file is allowed.");
+      }
+      cmdline.output_file = arg.substr(9);
+      has_output_arg = true;
+      i++;
+    } else {
+      if (!std::filesystem::exists(arg)) {
+        throw std::runtime_error("File " + arg + " does not exist.");
+      }
+      cmdline.input_files.push(arg);
+      i++;
+    }
+  }
+
+  if (!has_from_arg || !has_to_arg) {
+    throw std::invalid_argument("Missing -f ENCODING/--from_code=ENCODING or "
+                                "-t ENCODING/--to_code=ENCODING argument(s).");
+  }
+
+  return cmdline;
+}
+
+void CommandLine::run() {
+  if (output_file.empty()) {
+    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) {
+      printf("Could not open %s\n", output_file.string().c_str());
+      return;
+    }
+    run_procedure(fp);
+    if (fclose(fp) != 0) {
+      printf("Failed to close %s\n", output_file.string().c_str());
+    }
+  }
+}
+
+void CommandLine::run_procedure(std::FILE *fpout) {
+  if (from_encoding == "UTF-8") {
+    if (to_encoding == "UTF-16LE" || to_encoding == "UTF-16") {
+      auto proc = [this, &fpout](size_t size) {
+        if (!(input_files.empty())) {
+          size = find_last_leading_byte(size);
+        }
+        size_t len = simdutf::convert_utf8_to_utf16le(
+            reinterpret_cast<const char *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char16_t));
+        }
+        return size;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-16BE") {
+      auto proc = [this, &fpout](size_t size) {
+        if (!(input_files.empty())) {
+          size = find_last_leading_byte(size);
+        }
+        size_t len = simdutf::convert_utf8_to_utf16be(
+            reinterpret_cast<const char *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char16_t));
+        }
+        return size;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-32LE" || to_encoding == "UTF-32") {
+      auto proc = [this, &fpout](size_t size) {
+        if (!(input_files.empty())) {
+          size = find_last_leading_byte(size);
+        }
+        size_t len = simdutf::convert_utf8_to_utf32(
+            reinterpret_cast<const char *>(input_data.data()), size,
+            reinterpret_cast<char32_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char32_t));
+        }
+        return size;
+      };
+      run_simdutf_procedure(proc);
+    } else {
+      iconv_fallback(fpout);
+    }
+  } else if (from_encoding == "UTF-16LE" || from_encoding == "UTF-16") {
+    if (to_encoding == "UTF-8") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        if (!(input_files.empty()) &&
+            (input_data[size_bytes - 1] & 0xfc) == 0xd8) {
+          size_bytes -= 2;
+        } // Check if last word is a high surrogate
+        const size_t size = size_bytes / 2;
+        size_t len = simdutf::convert_utf16le_to_utf8(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            output_buffer.data());
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-16BE") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        const size_t size = size_bytes / 2;
+        simdutf::change_endianness_utf16(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        write_to_file_descriptor(fpout, output_buffer.data(), size);
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-32LE" || to_encoding == "UTF-32") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        if (!(input_files.empty()) &&
+            (input_data[size_bytes - 1] & 0xfc) == 0xd8) {
+          size_bytes -= 2;
+        } // Check if last word is a high surrogate
+        const size_t size = size_bytes / 2;
+        size_t len = simdutf::convert_utf16le_to_utf32(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            reinterpret_cast<char32_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char32_t));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else {
+      iconv_fallback(fpout);
+    }
+  } else if (from_encoding == "UTF-16BE") {
+    if (to_encoding == "UTF-8") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        if ((input_files.empty()) &&
+            (input_data[size_bytes - 2] & 0xfc) == 0xd8) {
+          size_bytes -= 2;
+        } // Check if last word is a high surrogate
+        const size_t size = size_bytes / 2;
+        size_t len = simdutf::convert_utf16be_to_utf8(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            output_buffer.data());
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-16LE" || to_encoding == "UTF-16") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        const size_t size = size_bytes / 2;
+        simdutf::change_endianness_utf16(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        write_to_file_descriptor(fpout, output_buffer.data(), size);
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-32LE" || to_encoding == "UTF-32") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        if (!(input_files.empty()) &&
+            (input_data[size_bytes - 2] & 0xfc) == 0xd8) {
+          size_bytes -= 2;
+        } // Check if last word is a high surrogate
+        const size_t size = size_bytes / 2;
+        size_t len = simdutf::convert_utf16be_to_utf32(
+            reinterpret_cast<const char16_t *>(input_data.data()), size,
+            reinterpret_cast<char32_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char32_t));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else {
+      iconv_fallback(fpout);
+    }
+  } else if (from_encoding == "UTF-32LE" || from_encoding == "UTF-32") {
+    if (to_encoding == "UTF-8") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        const size_t size = size_bytes / 4;
+        size_t len = simdutf::convert_utf32_to_utf8(
+            reinterpret_cast<const char32_t *>(input_data.data()), size,
+            output_buffer.data());
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-16LE" || to_encoding == "UTF-16") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        const size_t size = size_bytes / 4;
+        size_t len = simdutf::convert_utf32_to_utf16le(
+            reinterpret_cast<const char32_t *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char16_t));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else if (to_encoding == "UTF-16BE") {
+      auto proc = [this, &fpout](size_t size_bytes) {
+        const size_t size = size_bytes / 4;
+        size_t len = simdutf::convert_utf32_to_utf16be(
+            reinterpret_cast<const char32_t *>(input_data.data()), size,
+            reinterpret_cast<char16_t *>(output_buffer.data()));
+        if (len == 0 && size != 0) {
+          printf("Could not convert %s\n",
+                 input_files.front().string().c_str());
+          input_files.pop();
+        } else {
+          write_to_file_descriptor(fpout, output_buffer.data(),
+                                   len * sizeof(char16_t));
+        }
+        return size_bytes;
+      };
+      run_simdutf_procedure(proc);
+    } else {
+      iconv_fallback(fpout);
+    }
+  } else {
+    iconv_fallback(fpout);
+  }
+}
+
+// PROCEDURE takes as parameter the number of bytes to consume in input_data
+// (from the start of input_data). PROCEDURE consumes from the start of
+// input_data buffer. PROCEDURE returns the number of bytes consumed.
+template <typename PROCEDURE>
+void CommandLine::run_simdutf_procedure(PROCEDURE proc) {
+  size_t leftovers{0};
+  while (!(input_files.empty())) {
+    size_t input_size = leftovers;
+    if (!load_chunk(&input_size)) {
+      printf("Could not load %s\n", input_files.front().string().c_str());
+      input_files.pop();
+      continue;
+    }
+    leftovers = input_size - proc(input_size);
+    // Copy leftover bytes to the start of input_data
+    for (size_t i = 0; i < leftovers; i++) {
+      input_data[i] = input_data[input_size - leftovers + i];
+    }
+  }
+}
+
+void CommandLine::iconv_fallback(std::FILE *fpout) {
+#if ICONV_AVAILABLE
+  iconv_t cv = iconv_open(to_encoding.c_str(), from_encoding.c_str());
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr, "[iconv] cannot initialize %s to %s converter\n",
+            from_encoding.c_str(), to_encoding.c_str());
+    return;
+  }
+  size_t leftovers{0};
+  while (!(input_files.empty())) {
+    size_t input_size{leftovers};
+    if (!load_chunk(&input_size)) {
+      printf("Could not load %s\n", input_files.front().string().c_str());
+      input_files.pop();
+      continue;
+    }
+    size_t inbytes = input_size;
+    size_t outbytes = sizeof(uint32_t) * inbytes;
+    size_t start_outbytes = outbytes;
+    // win-iconv includes WINICONV_CONST in its function signatures
+    // https://github.com/simdutf/simdutf/pull/178
+  #ifdef WINICONV_CONST
+    WINICONV_CONST char *inptr =
+        reinterpret_cast<WINICONV_CONST char *>(input_data.data());
+  #else
+    char *inptr = reinterpret_cast<char *>(input_data.data());
+  #endif
+    char *outptr = reinterpret_cast<char *>(output_buffer.data());
+    size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+    if (result == static_cast<size_t>(-1)) {
+      if (errno == EINVAL) { // Incomplete multibyte sequence error is ok
+        // Copy leftover bytes to the start of input_data
+        leftovers = inbytes;
+        for (size_t i = 0; i < leftovers; i++) {
+          input_data[i] = input_data[input_size - leftovers + i];
+        }
+      } else {
+        fprintf(stderr, "[iconv] Error iconv.\n");
+        return;
+      }
+    } else {
+      leftovers = 0;
+    }
+
+    write_to_file_descriptor(fpout, output_buffer.data(),
+                             start_outbytes - outbytes);
+  }
+  iconv_close(cv);
+#else
+  fprintf(stderr,
+          "Conversion from %s to %s is not supported by the simdutf library "
+          "and iconv is not available.\n",
+          from_encoding.c_str(), to_encoding.c_str());
+  show_formats();
+#endif
+}
+
+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) {
+    return false;
+  }
+  return true;
+}
+
+// Loads a chunk of data (CHUNK_SIZE bytes). *input_size is the current input
+// size and is updated to the new input size after.
+bool CommandLine::load_chunk(size_t *input_size) {
+  size_t count = CHUNK_SIZE - *input_size;
+  while (count > 0) {
+    // Open a file if no file is opened
+    if (current_file == NULL) {
+      SIMDUTF_PUSH_DISABLE_WARNINGS
+      SIMDUTF_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC:
+                                         // manually verified this is safe
+          current_file = std::fopen(input_files.front().string().c_str(), "rb");
+      SIMDUTF_POP_DISABLE_WARNINGS
+
+      if (current_file == NULL) {
+        return false;
+      }
+    }
+
+    // Try to read 'count' bytes
+    size_t bytes_read =
+        std::fread(input_data.data() + *input_size, 1, count, current_file);
+    if (std::ferror(current_file)) {
+      return false;
+    }
+
+    count -= bytes_read; // 'count' should never be negative since we read at
+                         // most 'count' bytes
+    *input_size +=
+        bytes_read; // input_size should never exceed count initial value
+    if (std::feof(current_file)) { // Check if current_file is done
+      if (std::fclose(current_file) != 0) {
+        return false;
+      }
+      input_files.pop();
+      current_file = NULL;
+      if (input_files.empty()) {
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+// UNSAFE if size < 4 (should never happen when CHUNK_SIZE >= 4)
+// Given the size of the input from the start of input_data, returns the size
+// just before the last leading bytes
+size_t CommandLine::find_last_leading_byte(size_t size) {
+  // A leading byte cannot be further than 3 bytes away from the end for valid
+  // input
+  for (int i = 0; i < 4; i++) {
+    size--;
+    if ((input_data[size] & 0b11000000) != 0b10000000) {
+      break;
+    }
+  }
+  return size;
+}
+
+void CommandLine::show_help() {
+#if ICONV_AVAILABLE
+  printf(
+      "Convert encoding of input files from one encoding to another using "
+      "simdutf library for supported formats and iconv for other formats.\n");
+#else
+  printf("Convert encoding of input files from one encoding to another using "
+         "simdutf library for supported formats.\n");
+#endif
+  printf("Usage: sutf [OPTIONS...] [INPUTFILES...]\n\n");
+  printf(" Encoding specification(mandatory):\n"
+         "  -f, --from-code=ENCODING       encoding of source text\n"
+         "  -t, --to-code=ENCODING         encoding of output\n\n");
+  printf(" Output(optional):\n"
+         "  -o,--output=FILE               output file\n\n");
+  printf(" Information(optional):\n"
+         "  -h,--help                      Display this help text\n"
+         "  -u,--usage                     Display short usage message\n"
+         "  -l,--list                      Display supported formats by "
+         "simdutf library\n\n");
+  printf("If output is not specified, the output is redirected to standard "
+         "output.\n");
+}
+
+void CommandLine::show_usage() {
+  printf("Usage: sutf [OPTION...] [-f ENCODING] [-t ENCODING] [-o OUTPUTFILE] "
+         "[-l] [-h] [-u]\n"
+         "            [--from-code=ENCODING] [--to-code=ENCODING] "
+         "[--output=OUTPUTFILE] [--list] [--help] [--usage] [INPUTFILES...]\n");
+}
+
+void CommandLine::show_formats() {
+  printf("Formats supported by simdutf library: UTF-8, UTF-16LE, UTF-16BE, "
+         "UTF-32LE\n");
+#if ICONV_AVAILABLE
+  printf("Try \"iconv -l\" or \"iconv --list\" to see formats supported by "
+         "iconv.\n");
+#endif
+}
+
+int main(int argc, char *argv[]) {
+  try {
+    CommandLine cmdline = parse_and_validate_arguments(argc, argv);
+    cmdline.run();
+    return EXIT_SUCCESS;
+  } catch (const std::exception &e) {
+    printf("%s\n", e.what());
+    CommandLine::show_help();
+    return EXIT_FAILURE;
+  }
+}

package/deps/simdutf/tools/sutf.h

@@ -0,0 +1,40 @@
+#include "simdutf.h"
+
+#if !defined(ICONV_AVAILABLE) && __has_include(<iconv.h>)
+  #define ICONV_AVAILABLE 1
+#endif //__has_include (<iconv.h>)
+#if ICONV_AVAILABLE
+  #include <iconv.h>
+#endif
+
+#include <filesystem>
+#include <array>
+#include <memory>
+#include <queue>
+
+constexpr size_t CHUNK_SIZE = 65536; // Must be at least 4
+
+class CommandLine {
+public:
+  std::string from_encoding;
+  std::string to_encoding;
+  std::queue<std::filesystem::path> input_files;
+  std::FILE *current_file{NULL};
+  std::filesystem::path output_file;
+  std::array<uint8_t, CHUNK_SIZE> input_data;
+  std::array<char, CHUNK_SIZE * sizeof(uint32_t)> output_buffer;
+
+  CommandLine() = default;
+  static CommandLine parse_and_validate_arguments(int argc, char *argv[]);
+  static void show_help();
+  static void show_usage();
+  static void show_formats();
+
+  void run();
+  void run_procedure(std::FILE *fp);
+  template <typename PROCEDURE> void run_simdutf_procedure(PROCEDURE proc);
+  void iconv_fallback(std::FILE *fp);
+  bool load_chunk(size_t *input_size);
+  bool write_to_file_descriptor(std::FILE *fp, const char *data, size_t length);
+  size_t find_last_leading_byte(size_t size);
+};

package/lib/commonjs/blake3.js

@@ -10,6 +10,7 @@ exports.createBlake3 = createBlake3;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
 var _utils = require("./utils");
+var _conversion = require("./utils/conversion");
 const BLAKE3_KEY_LEN = 32;
 const BLAKE3_OUT_LEN = 32;
 class Blake3 {
@@ -24,7 +25,7 @@ class Blake3 {
       }
       this.mode = 'keyed';
       this.keyData = opts.key;
-      this.native.initKeyed(opts.key.buffer);
+      this.native.initKeyed((0, _conversion.toArrayBuffer)(opts.key));
     } else if (opts?.context !== undefined) {
       if (typeof opts.context !== 'string' || opts.context.length === 0) {
         throw new Error('BLAKE3: context must be a non-empty string');

package/lib/commonjs/blake3.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_utils","BLAKE3_KEY_LEN","BLAKE3_OUT_LEN","Blake3","constructor","opts","native","NitroModules","createHybridObject","key","context","Error","length","mode","keyData","initKeyed","buffer","undefined","contextData","initDeriveKey","initHash","update","data","inputEncoding","binaryLikeToArrayBuffer","digest","encodingOrLength","encoding","result","ab2str","Buffer","from","digestLength","reset","copy","copied","getVersion","exports","createBlake3","blake3","hasher","dkLen","Uint8Array","create","blake3Exports"],"sourceRoot":"../../src","sources":["blake3.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_utils","_conversion","BLAKE3_KEY_LEN","BLAKE3_OUT_LEN","Blake3","constructor","opts","native","NitroModules","createHybridObject","key","context","Error","length","mode","keyData","initKeyed","toArrayBuffer","undefined","contextData","initDeriveKey","initHash","update","data","inputEncoding","buffer","binaryLikeToArrayBuffer","digest","encodingOrLength","encoding","result","ab2str","Buffer","from","digestLength","reset","copy","copied","getVersion","exports","createBlake3","blake3","hasher","dkLen","Uint8Array","create","blake3Exports"],"sourceRoot":"../../src","sources":["blake3.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/diffie-hellman.js

@@ -9,6 +9,7 @@ exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
 var _dhGroups = require("./dh-groups");
+var _conversion = require("./utils/conversion");
 class DiffieHellman {
   constructor(sizeOrPrime, generator, encoding) {
     this._hybrid = _reactNativeNitroModules.NitroModules.createHybridObject('DiffieHellman');
@@ -32,7 +33,7 @@ class DiffieHellman {
       } else {
         genBuf = _reactNativeBuffer.Buffer.from(generator, encoding);
       }
-      this._hybrid.init(primeBuf.buffer, genBuf.buffer);
+      this._hybrid.init((0, _conversion.toArrayBuffer)(primeBuf), (0, _conversion.toArrayBuffer)(genBuf));
     }
   }
   generateKeys(encoding) {
@@ -47,7 +48,7 @@ class DiffieHellman {
     } else {
       keyBuf = _reactNativeBuffer.Buffer.from(otherPublicKey, inputEncoding);
     }
-    const secret = _reactNativeBuffer.Buffer.from(this._hybrid.computeSecret(keyBuf.buffer));
+    const secret = _reactNativeBuffer.Buffer.from(this._hybrid.computeSecret((0, _conversion.toArrayBuffer)(keyBuf)));
     if (outputEncoding) return secret.toString(outputEncoding);
     return secret;
   }
@@ -78,7 +79,7 @@ class DiffieHellman {
     } else {
       keyBuf = _reactNativeBuffer.Buffer.from(publicKey, encoding);
     }
-    this._hybrid.setPublicKey(keyBuf.buffer);
+    this._hybrid.setPublicKey((0, _conversion.toArrayBuffer)(keyBuf));
   }
   setPrivateKey(privateKey, encoding) {
     let keyBuf;
@@ -87,7 +88,7 @@ class DiffieHellman {
     } else {
       keyBuf = _reactNativeBuffer.Buffer.from(privateKey, encoding);
     }
-    this._hybrid.setPrivateKey(keyBuf.buffer);
+    this._hybrid.setPrivateKey((0, _conversion.toArrayBuffer)(keyBuf));
   }
   get verifyError() {
     return this._hybrid.getVerifyError();