react-native-quick-crypto 1.0.19 → 1.1.0

package/QuickCrypto.podspec

@@ -42,41 +42,14 @@ Pod::Spec.new do |s|
     end
   end
 
-  # OpenSSL 3.6+ vendored xcframework (not yet on CocoaPods trunk)
-  openssl_version = "3.6.0001"
-  openssl_url = "https://github.com/krzyzanowskim/OpenSSL/releases/download/#{openssl_version}/OpenSSL.xcframework.zip"
-
-  # Ensure OpenSSL.xcframework is present during podspec evaluation.
-  # This is necessary because prepare_command is skipped for :path pods,
-  # which is how React Native native modules are installed.
-  # See: https://github.com/margelo/react-native-quick-crypto/issues/882
-  openssl_dir = File.join(__dir__, "OpenSSL.xcframework")
-  openssl_plist = File.join(openssl_dir, "Info.plist")
-  unless File.exist?(openssl_plist)
-    # Clean up any partial download
-    FileUtils.rm_rf(openssl_dir) if File.directory?(openssl_dir)
-    FileUtils.rm_f(File.join(__dir__, "OpenSSL.xcframework.zip"))
-
-    Pod::UI.puts "[QuickCrypto] ⬇️  Downloading OpenSSL.xcframework..."
-    Dir.chdir(__dir__) do
-      system("curl -sSfL --connect-timeout 30 --max-time 300 -o OpenSSL.xcframework.zip #{openssl_url}") || raise("Failed to download OpenSSL")
-      system("unzip -q -o OpenSSL.xcframework.zip") || raise("Failed to unzip OpenSSL")
-      File.delete("OpenSSL.xcframework.zip") if File.exist?("OpenSSL.xcframework.zip")
-    end
-    Pod::UI.puts "[QuickCrypto] ✅ OpenSSL.xcframework downloaded successfully"
-  end
-
   if sodium_enabled
     # Build libsodium from source for XSalsa20 cipher support
     # CocoaPods packages are outdated (1.0.12) and SPM causes module conflicts
     s.prepare_command = <<-CMD
       set -e
-      # Download OpenSSL.xcframework
-      if [ ! -d "OpenSSL.xcframework" ]; then
-        curl -L -o OpenSSL.xcframework.zip #{openssl_url}
-        unzip -o OpenSSL.xcframework.zip
-        rm -f OpenSSL.xcframework.zip
-      fi
+      # Clean up vendored OpenSSL.xcframework from pre-1.0.20 installs
+      rm -rf OpenSSL.xcframework
+      rm -f OpenSSL.xcframework.zip
       # Build libsodium
       mkdir -p ios
       curl -L -o ios/libsodium.tar.gz https://download.libsodium.org/libsodium/releases/libsodium-1.0.20-stable.tar.gz
@@ -90,20 +63,15 @@ Pod::Spec.new do |s|
   else
     s.prepare_command = <<-CMD
       set -e
-      # Download OpenSSL.xcframework
-      if [ ! -d "OpenSSL.xcframework" ]; then
-        curl -L -o OpenSSL.xcframework.zip #{openssl_url}
-        unzip -o OpenSSL.xcframework.zip
-        rm -f OpenSSL.xcframework.zip
-      fi
       # Clean up libsodium if previously built
       rm -rf ios/libsodium-stable
       rm -f ios/libsodium.tar.gz
+      # Clean up vendored OpenSSL.xcframework from pre-1.0.20 installs
+      rm -rf OpenSSL.xcframework
+      rm -f OpenSSL.xcframework.zip
     CMD
   end
 
-  s.vendored_frameworks = "OpenSSL.xcframework"
-
   base_source_files = [
     # implementation (Swift)
     "ios/**/*.{swift}",
@@ -114,6 +82,9 @@ Pod::Spec.new do |s|
     # dependencies (C++) - ncrypto
     "deps/ncrypto/include/**/*.{h}",
     "deps/ncrypto/src/*.{cpp}",
+    # dependencies (C++) - simdutf
+    "deps/simdutf/include/**/*.{h}",
+    "deps/simdutf/src/simdutf.cpp",
     # dependencies (C) - exclude BLAKE3 x86 SIMD files (only use portable + NEON for ARM)
     "deps/blake3/c/*.{h,c}",
     "deps/fastpbkdf2/*.{h,c}",
@@ -183,6 +154,8 @@ Pod::Spec.new do |s|
     "\"$(PODS_TARGET_SRCROOT)/cpp/ecdh\"",
     "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared/c++\"",
     "\"$(PODS_TARGET_SRCROOT)/deps/ncrypto/include\"",
+    "\"$(PODS_TARGET_SRCROOT)/deps/simdutf/include\"",
+    "\"$(PODS_TARGET_SRCROOT)/deps/simdutf/src\"",
     "\"$(PODS_TARGET_SRCROOT)/deps/blake3/c\"",
     "\"$(PODS_TARGET_SRCROOT)/deps/fastpbkdf2\""
   ]
@@ -210,6 +183,7 @@ Pod::Spec.new do |s|
   load "nitrogen/generated/ios/QuickCrypto+autolinking.rb"
   add_nitrogen_files(s)
 
+  s.dependency "OpenSSL-Universal", "~> 3.6"
   s.dependency "React-jsi"
   s.dependency "React-callinvoker"
 

package/README.md

@@ -143,6 +143,8 @@ const hashed = QuickCrypto.createHash('sha256')
   .digest('hex');
 ```
 
+More details can be found on the [documentation](https://margelo.github.io/react-native-quick-crypto/).
+
 ## Limitations
 
 Not all cryptographic algorithms are supported yet. See the [implementation coverage](./.docs/implementation-coverage.md) document for more details. If you need a specific algorithm, please open a `feature request` issue and we'll see what we can do.

package/android/CMakeLists.txt

@@ -67,6 +67,7 @@ add_library(
   ../deps/ncrypto/src/aead.cpp
   ../deps/ncrypto/src/engine.cpp
   ../deps/ncrypto/src/ncrypto.cpp
+  ../deps/simdutf/src/simdutf.cpp
 )
 
 # add Nitrogen specs
@@ -102,6 +103,8 @@ include_directories(
   "../deps/blake3/c"
   "../deps/fastpbkdf2"
   "../deps/ncrypto/include"
+  "../deps/simdutf/include"
+  "../deps/simdutf/src"
 )
 
 # Third party libraries (Prefabs)

package/cpp/utils/HybridUtils.cpp

@@ -1,12 +1,12 @@
 #include "HybridUtils.hpp"
 
-#include <limits>
 #include <openssl/crypto.h>
-#include <openssl/evp.h>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "QuickCryptoUtils.hpp"
+#include "simdutf.h"
 
 namespace margelo::nitro::crypto {
 
@@ -35,16 +35,13 @@ namespace {
   }
 
   std::vector<uint8_t> decodeHex(const std::string& hex) {
-    if (hex.length() % 2 != 0) {
-      throw std::runtime_error("Invalid hex string length");
-    }
     std::vector<uint8_t> result;
     result.reserve(hex.length() / 2);
-    for (size_t i = 0; i < hex.length(); i += 2) {
+    for (size_t i = 0; i + 1 < hex.length(); i += 2) {
       int hi = hexCharToVal(hex[i]);
       int lo = hexCharToVal(hex[i + 1]);
       if (hi < 0 || lo < 0) {
-        throw std::runtime_error("Invalid hex character");
+        break;
       }
       result.push_back(static_cast<uint8_t>((hi << 4) | lo));
     }
@@ -52,67 +49,41 @@ namespace {
   }
 
   std::string encodeBase64(const uint8_t* data, size_t len) {
-    if (len > static_cast<size_t>(std::numeric_limits<int>::max())) {
-      throw std::runtime_error("Input too large for base64 encoding");
-    }
-    size_t encodedLen = ((len + 2) / 3) * 4;
-    std::string result(encodedLen + 1, '\0');
-    int written = EVP_EncodeBlock(reinterpret_cast<unsigned char*>(result.data()), data, static_cast<int>(len));
-    if (written < 0) {
-      throw std::runtime_error("Base64 encoding failed");
+    if (len == 0) {
+      return {};
     }
-    result.resize(static_cast<size_t>(written));
+
+    size_t encodedLen = simdutf::base64_length_from_binary(len, simdutf::base64_default);
+    std::string result(encodedLen, '\0');
+    simdutf::binary_to_base64(reinterpret_cast<const char*>(data), len, result.data(), simdutf::base64_default);
     return result;
   }
 
   std::vector<uint8_t> decodeBase64(const std::string& b64) {
-    if (b64.length() > static_cast<size_t>(std::numeric_limits<int>::max())) {
-      throw std::runtime_error("Input too large for base64 decoding");
+    if (b64.empty()) {
+      return {};
     }
-    size_t maxLen = ((b64.length() + 3) / 4) * 3;
+
+    size_t maxLen = simdutf::maximal_binary_length_from_base64(b64.data(), b64.length());
     std::vector<uint8_t> result(maxLen);
-    int written = EVP_DecodeBlock(result.data(), reinterpret_cast<const unsigned char*>(b64.data()), static_cast<int>(b64.length()));
-    if (written < 0) {
+    auto decodeResult = simdutf::base64_to_binary(b64.data(), b64.size(), reinterpret_cast<char*>(result.data()),
+                                                  simdutf::base64_default_or_url_accept_garbage);
+    if (decodeResult.error != simdutf::error_code::SUCCESS) {
       throw std::runtime_error("Base64 decoding failed");
     }
-    // EVP_DecodeBlock doesn't account for padding — trim trailing zeros from padding
-    size_t padding = 0;
-    if (b64.length() >= 1 && b64[b64.length() - 1] == '=')
-      padding++;
-    if (b64.length() >= 2 && b64[b64.length() - 2] == '=')
-      padding++;
-    result.resize(static_cast<size_t>(written) - padding);
+    result.resize(decodeResult.count);
     return result;
   }
 
   std::string encodeBase64Url(const uint8_t* data, size_t len) {
-    std::string b64 = encodeBase64(data, len);
-    for (auto& c : b64) {
-      if (c == '+')
-        c = '-';
-      else if (c == '/')
-        c = '_';
-    }
-    // Remove trailing '=' padding
-    while (!b64.empty() && b64.back() == '=') {
-      b64.pop_back();
+    if (len == 0) {
+      return {};
     }
-    return b64;
-  }
 
-  std::vector<uint8_t> decodeBase64Url(const std::string& b64url) {
-    std::string b64 = b64url;
-    for (auto& c : b64) {
-      if (c == '-')
-        c = '+';
-      else if (c == '_')
-        c = '/';
-    }
-    // Add back padding
-    while (b64.length() % 4 != 0) {
-      b64.push_back('=');
-    }
-    return decodeBase64(b64);
+    size_t encodedLen = simdutf::base64_length_from_binary(len, simdutf::base64_url);
+    std::string result(encodedLen, '\0');
+    simdutf::binary_to_base64(reinterpret_cast<const char*>(data), len, result.data(), simdutf::base64_url);
+    return result;
   }
 
   std::vector<uint8_t> decodeLatin1(const std::string& str) {
@@ -145,17 +116,15 @@ namespace {
   }
 
   std::string encodeLatin1(const uint8_t* data, size_t len) {
-    std::string result;
-    result.reserve(len * 2);
-    for (size_t i = 0; i < len; i++) {
-      uint8_t byte = data[i];
-      if (byte < 0x80) {
-        result.push_back(static_cast<char>(byte));
-      } else {
-        // Latin1 byte 0x80-0xFF → UTF-8 two-byte sequence
-        result.push_back(static_cast<char>(0xC0 | (byte >> 6)));
-        result.push_back(static_cast<char>(0x80 | (byte & 0x3F)));
-      }
+    if (len == 0) {
+      return {};
+    }
+
+    size_t utf8Len = simdutf::utf8_length_from_latin1(reinterpret_cast<const char*>(data), len);
+    std::string result(utf8Len, '\0');
+    size_t written = simdutf::convert_latin1_to_utf8(reinterpret_cast<const char*>(data), len, result.data());
+    if (written == 0) {
+      throw std::runtime_error("Latin1 encoding failed");
     }
     return result;
   }
@@ -205,29 +174,22 @@ std::string HybridUtils::bufferToString(const std::shared_ptr<ArrayBuffer>& buff
 std::shared_ptr<ArrayBuffer> HybridUtils::stringToBuffer(const std::string& str, const std::string& encoding) {
   if (encoding == "hex") {
     auto decoded = decodeHex(str);
-    return ToNativeArrayBuffer(decoded);
+    return ArrayBuffer::move(std::move(decoded));
   }
-  if (encoding == "base64") {
+  if (encoding == "base64" || encoding == "base64url") {
     auto decoded = decodeBase64(str);
-    return ToNativeArrayBuffer(decoded);
-  }
-  if (encoding == "base64url") {
-    auto decoded = decodeBase64Url(str);
-    return ToNativeArrayBuffer(decoded);
+    return ArrayBuffer::move(std::move(decoded));
   }
   if (encoding == "utf8" || encoding == "utf-8") {
-    return ToNativeArrayBuffer(str);
+    return ArrayBuffer::copy(reinterpret_cast<const uint8_t*>(str.data()), str.size());
   }
   if (encoding == "latin1" || encoding == "binary") {
     auto decoded = decodeLatin1(str);
-    return ToNativeArrayBuffer(decoded);
+    return ArrayBuffer::move(std::move(decoded));
   }
   if (encoding == "ascii") {
     auto decoded = decodeLatin1(str);
-    for (auto& b : decoded) {
-      b &= 0x7F;
-    }
-    return ToNativeArrayBuffer(decoded);
+    return ArrayBuffer::move(std::move(decoded));
   }
   throw std::runtime_error("Unsupported encoding: " + encoding);
 }

package/deps/simdutf/.clang-format

@@ -0,0 +1,4 @@
+BasedOnStyle: LLVM
+SortIncludes: false
+InsertNewlineAtEOF: true
+IndentPPDirectives: BeforeHash

package/deps/simdutf/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,62 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug (unverified)
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* README.md : https://github.com/simdutf/simdutf/blob/master/README.md 
+* Contributing: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md
+
+
+**Describe the bug**
+A clear and concise description of what the bug is. A bug is a failure to build with normal compiler settings or a misbehaviour: when running the code, you get a result that differs from the expected result from our documentation.
+
+A compiler or static-analyzer warning is not a bug. It is possible with tools such as Visual Studio to require that rarely enabled warnings are considered errors. Do not report such cases as bugs. We do accept pull requests if you want to silence warnings issued by code analyzers, however.
+
+We are committed to providing good documentation. We accept the lack of documentation or a misleading documentation as a bug (a 'documentation bug').
+
+An unexpected poor software performance can be accepted as a bug (a 'performance bug').
+
+We accept the identification of an issue by a sanitizer or some checker tool (e.g., valgrind) as a bug, but you must first ensure that it is not a false positive.
+
+We recommend that you run your tests using different optimization levels. In particular, we recommend your run tests with the simdutf library and you code compiled in debug mode. If possible, we recommend that you run tests with sanitizers (e.g., see [No more leaks with sanitize flags in gcc and clang](https://lemire.me/blog/2016/04/20/no-more-leaks-with-sanitize-flags-in-gcc-and-clang/)).  You can compile the library with sanitizers for debugging purposes (e.g., set SIMDUTF_SANITIZE to ON using CMake), but you should also turn on sanitizers on your own code. You may also use tools like valgrind or the commercial equivalent.
+
+Before reporting a bug, please ensure that you have read our documentation.
+
+**To Reproduce**
+Steps to reproduce the behaviour: provide a code sample if possible. Please provide a complete test with data. Remember that a bug is either a failure to build or an unexpected result when running the code.
+
+If we cannot reproduce the issue, then we cannot address it. Note that a stack trace from your own program is not enough. A sample of your source code is insufficient: please provide a complete test for us to reproduce the issue. Please reduce the issue: use as small and as simple an example of the bug as possible.
+
+It should be possible to trigger the bug by using solely simdutf with our default build setup. If you can only observe the bug within some specific context, with some other software, please reduce the issue first.
+
+**simdutf release**
+
+Unless you plan to contribute to simdutf, you should only work from releases. Please be mindful that our main branch may have additional features, bugs and documentation items.
+
+It is fine to report bugs against our main branch, but if that is what you are doing, please be explicit.
+
+**Configuration (please complete the following information if relevant)**
+ - OS: [e.g. Ubuntu 16.04.6 LTS]
+ - Compiler* [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
+ - Version [e.g. 22]
+ - Optimization setting (e.g., -O3)
+
+We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug.
+
+* We do not support unreleased or experimental compilers. If you encounter an issue with a
+pre-release version of a compiler, do not report it as a bug to simdutf. However, we always
+invite contributions either in the form an analysis or of a code contribution.
+* Vendors (e.g., Apple and Microsoft) stop supporting old systems. Once a compiler system is no longer supported by its vendor, we no longer support it. We will gladly accept code contributions, but we do not consider it a *bug* if you have issues with an obsolete compiler systems. This policy extends to obsolete standard libraries, linkers and other build tools. Please do not report it as an issue. If you cannot resolve the issue yourself, we encourage you to reach out to the vendor for legacy support.
+
+Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
+
+**Indicate whether you are willing or able to provide a bug fix as a pull request**
+
+If you plan to contribute to simdutf, please read our guide:
+* CONTRIBUTING guide: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md

package/deps/simdutf/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

package/deps/simdutf/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,35 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* README.md : https://github.com/simdutf/simdutf/blob/master/README.md 
+* Contributing: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md
+
+
+We do not make changes to simdutf without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdutf objectively better.
+
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+ Please provide a clear rationale for the feature. Be advised that simdutf is a community-based project: you should consider providing help.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
+
+**Are you willing to contribute code or documentation toward this new feature?**
+If you plan to contribute to simdutf, please read our
+* CONTRIBUTING guide: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md

package/deps/simdutf/.github/ISSUE_TEMPLATE/standard-issue-template.md

@@ -0,0 +1,29 @@
+---
+name: Standard issue template
+about: Issue
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* README.md : https://github.com/simdutf/simdutf/blob/master/README.md 
+* Contributing: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md
+
+We do not make changes to simdutf without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdutf objectively better.
+
+Is your issue:
+
+1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request. As a matter of policy, we do not consider a compiler warning to be a bug.
+
+2. A build issue? If so, provide all possible details regarding your system configuration. If we cannot reproduce your issue, we cannot fix it.
+
+3. A feature request? Please provide a clear rationale for the feature. Be advised that simdutf is a community-based project: you should consider providing help.
+
+4. A documentation issue? Can you suggest an improvement?
+
+
+If you plan to contribute to simdutf, please read our
+* CONTRIBUTING guide: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md

package/deps/simdutf/.github/pull_request_template.md

@@ -0,0 +1,51 @@
+Short title (summary):
+
+Description
+- What did you change and why? (1-3 sentences)
+- Issue reproduced / related issue: link the issue if relevant (e.g. #123)
+
+Type of change
+- [ ] Bug fix
+- [ ] Optimization
+- [ ] New feature
+- [ ] Refactor / cleanup
+- [ ] Documentation / tests
+- [ ] Other (please describe):
+
+How to verify / test
+- Add additional tests to verify bugs or new features.
+- If you claim performance gains, you should provide benchmark numbers using high quality benchmarking code.
+
+
+Please read before contributing:
+- CONTRIBUTING: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md
+- AI Usage Policy: https://github.com/simdutf/simdutf/blob/master/AI_USAGE_POLICY.md
+
+
+
+If you can, we recommend running our tests with the sanitizers turned on.
+For non-Visual Studio users, it is as easy as doing:
+
+
+
+```bash
+cmake -B build -D SIMDUTF_SANITIZE=ON
+cmake --build build
+ctest --test-dir build
+```
+
+
+Our CI checks, among other things, for trailing whitespace.
+
+
+Checklist before submitting
+- [ ] I added/updated tests covering my change (if applicable)
+- [ ] Code builds locally and passes my check
+- [ ] Documentation / README updated if needed
+- [ ] Commits are atomic and messages are clear
+- [ ] I linked the related issue (if applicable)
+
+Final notes
+- For large PRs, prefer smaller incremental PRs or request staged review.
+
+Thanks for the contribution!

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

@@ -0,0 +1,39 @@
+name: Ubuntu aarch64
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build-22:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cxxversion: [11, 17, 20]
+        compiler: [g++, clang++-19]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: aarch64
+          githubToken: ${{ github.token }}
+          distro: ubuntu24.04
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++ clang-19
+          run: |
+            cmake \
+               -DCMAKE_BUILD_TYPE=Release \
+               -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} \
+               -DSIMDUTF_ALWAYS_INCLUDE_FALLBACK=ON \
+               -DSIMDUTF_FAST_TESTS=On \
+               -DSIMDUTF_CXX_STANDARD=${{ matrix.cxxversion }} \
+               -B build
+            cmake --build build -j=$(nproc)
+            ctest --output-on-failure --test-dir build -j=$(nproc)

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

@@ -0,0 +1,27 @@
+name: Alpine Linux
+'on':
+  - push
+  - pull_request
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: start docker
+        run: |
+          docker run -w /src -dit --name alpine -v $PWD:/src alpine:latest
+          echo 'docker exec alpine "$@";' > ./alpine.sh
+          chmod +x ./alpine.sh
+      - name: install packages
+        run: |
+          ./alpine.sh apk update
+          ./alpine.sh apk add build-base cmake g++ linux-headers git bash
+      - name: cmake
+        run: |
+          ./alpine.sh cmake  -B build_for_alpine -DSIMDUTF_FAST_TESTS=On
+      - name: build
+        run: |
+          ./alpine.sh cmake --build build_for_alpine
+      - name: test
+        run: |
+          ./alpine.sh bash -c "cd build_for_alpine && ctest"

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

@@ -0,0 +1,34 @@
+name: amalgamation demos
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  cpp_amalgamation:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: C++ amalgamation demo
+        run: |
+          cd singleheader
+          ./amalgamate.py
+          c++ -o amalgamation_demo amalgamation_demo.cpp -std=c++17
+          ./amalgamation_demo
+
+  c_amalgamation:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: c amalgamation demo
+        run: |
+          cd singleheader
+          ./amalgamate.py
+          c++ -c simdutf.cpp
+          cc -c ./amalgamation_demo.c
+          c++ amalgamation_demo.o simdutf.o -o cdemo
+          ./cdemo

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

@@ -0,0 +1,32 @@
+name: Ubuntu armv7 (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: armv7
+          githubToken: ${{ github.token }}
+          distro: ubuntu24.04
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -B build -DSIMDUTF_FAST_TESTS=On
+            cmake --build build -j=$(nproc)
+            ctest --output-on-failure --test-dir build -j=$(nproc)
+            cmake -DCMAKE_CXX_FLAGS="-fstack-protector-strong -fno-strict-aliasing" -B buildprotected -DSIMDUTF_FAST_TESTS=On
+            cmake --build buildprotected -j=$(nproc)
+            ctest --output-on-failure --test-dir buildprotected -j=$(nproc)

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

@@ -0,0 +1,25 @@
+name: atomic base64 fuzz
+
+# this runs the atomic base64 fuzzer for a short while.
+# it is not covered by the CIFuzz job, since that does not support C++20 fully
+
+on:
+    push:
+        branches:
+        - master
+    pull_request:
+        branches:
+        - master
+
+jobs:
+    ubuntu-build:
+        runs-on: ubuntu-24.04
+        steps:
+        - uses: actions/checkout@v4
+        - name: install clang
+          run: sudo apt install -y clang-18 ccache
+        - name: compile and run atomic base64 fuzzer
+          run: |
+            fuzz/build.sh
+            mkdir -p /tmp/atomic_out
+            fuzz/out/atomic_base64 -max_len=20000 -timeout=10 -max_total_time=300 -jobs=$(nproc) -workers=$(nproc) /tmp/atomic_out