react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/riscv/Dockerfile

@@ -1,16 +0,0 @@
-FROM ubuntu:24.04
- ARG USER_NAME
- ARG USER_ID
- ARG GROUP_ID
-# We install some useful packages
- RUN apt-get update -qq
- RUN apt-get install -y vim git g++-riscv64-linux-gnu qemu-user-static ninja-build valgrind curl  clang++-18 gdb clang-format sudo  wget cmake g++
- RUN addgroup --gid $GROUP_ID user; exit 0
- RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID $USER_NAME; exit 0
- RUN echo "$USER_NAME:$USER_NAME" | chpasswd && adduser $USER_NAME sudo
- RUN echo '----->'
- RUN echo 'root:Docker!' | chpasswd
- ENV TERM xterm-256color
- USER $USER_NAME
- RUN gcc --version
- RUN cmake --version

package/deps/simdutf/riscv/README.md

@@ -1,24 +0,0 @@
-# RISC-V
-
-We assume that you have a docker or docker-like system.
-
-First initialize the required docker image. Stay in the root directory of the simdutf project and type:
-
-```
-./riscv/run-docker-station bash
-```
-
-You will now be inside the container.
-
-You can now build and run the RISC-V code as needed:
-
-```
-CXX=clang++-18 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" cmake -DCMAKE_CROSSCOMPILING_EMULATOR=qemu-riscv64-static -DCMAKE_SYSTEM_PROCESSOR=riscv64 -DCMAKE_BUILD_TYPE=Release -B buildriscv
-cmake --build buildriscv
-export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-export QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-ctest --output-on-failure --test-dir buildriscv
-/usr/bin/qemu-riscv64-static buildriscv/tools/sutf
-```
-
-Quitting the shell will exit from the container.

package/deps/simdutf/riscv/remove-docker-station

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-tuser=$(echo $USER | tr -dc 'a-z')
-container_name=${CONTAINER_NAME:-"risc-programming_station-for-$tuser"}
-echo $container_name
-echo " Removing the container "
-docker ps -a | awk '{ print $1,$2 }' | grep $container_name| awk '{print $1 }' | xargs -I {} docker stop -t 1 {} | xargs docker rm 
-# removing image
-docker image rm $container_name

package/deps/simdutf/riscv/run-docker-station

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-if [ -z "$1" ]
-  then
-    echo "The run-docker-station script takes a command as a argument. E.g., try ./run-docker-station 'ls' "
-    exit 1
-fi
-
-set -o noglob
-SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
-
-COMMAND=$@
-
-tuser=$(echo $USER | tr -dc 'a-z')
-
-container_name=${CONTAINER_NAME:-"risc-programming_station-for-$tuser"}
-
-command -v docker >/dev/null 2>&1 || { echo >&2 "Please install docker. E.g., go to https://www.docker.com/products/docker-desktop Type 'docker' to diagnose the problem."; exit 1; }
-
-docker info >/dev/null 2>&1 || { echo >&2 "Docker server is not running? type 'docker info'."; exit 1; }
-
-SSHPARAM=""
-[ -e "${SSH_AUTH_SOCK}" ] && SSHPARAM="--volume /run/host-services/ssh-auth.sock:/run/host-services/ssh-auth.sock  --env SSH_AUTH_SOCK=/run/host-services/ssh-auth.sock"
-[ -e "${HOME}/.ssh" ] && SSHPARAM="--volume ${HOME}/.ssh:/home/$tuser/.ssh:ro"  
-
-
-docker image inspect $container_name >/dev/null 2>&1 || ( echo "instantiating the container" ; docker build --no-cache -t $container_name -f $SCRIPTPATH/Dockerfile --build-arg USER_NAME="$tuser"  --build-arg USER_ID=$(id -u)  --build-arg GROUP_ID=$(id -g) .  )
-
-if [ -t 0 ]; then DOCKER_ARGS=-it; fi
-docker run --rm $DOCKER_ARGS -h $container_name $SSHPARAM -v $(pwd):$(pwd):Z --privileged  -w $(pwd)  $container_name sh -c "$COMMAND"
-

package/deps/simdutf/scripts/.flake8

@@ -1,2 +0,0 @@
-[flake8]
-extend-ignore = E501, E221

package/deps/simdutf/scripts/Makefile

@@ -1,2 +0,0 @@
-lint:
-	python -m mypy *.py

package/deps/simdutf/scripts/README_ADD_FUNCTION.md

@@ -1,49 +0,0 @@
-# Adding a New Function to simdutf
-
-This guide explains how to use the `add_function.py` script to automate adding a new function to the simdutf library.
-
-## Prerequisites
-- Python 3 installed.
-- The script assumes the repository structure is intact (e.g., `include/simdutf/implementation.h`, `src/implementation.cpp`, etc.).
-
-## Steps
-1. **Create a Signature File**: Create a text file (e.g., `new_function.sig`) containing the function signatures, wrapped in the appropriate feature macro block. You can include multiple functions in one block. Most functions in simdutf are marked `noexcept` and you should mark them `noexcept`. If they return a value, we typically marked the return value `simdutf_warn_unused`. Example:
-   ```C++
-   #if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16
-   /**
-    * Documentation for first function.
-    */
-   simdutf_warn_unused size_t utf8_length_from_utf16le(
-       const char16_t *buf, size_t len) noexcept;
-
-   /**
-    * Documentation for second function.
-    */
-   simdutf_warn_unused size_t utf8_length_from_utf16be(
-       const char16_t *buf, size_t len) noexcept;
-   #endif
-   ```
-
-2. **Run the Script**: Execute the script with the signature file as argument:
-   ```shell
-   python scripts/add_function.py new_function.sig
-   ```
-
-3. **What the Script Does**:
-   - Parses the signature file to extract the feature macro and all function signatures with their documentation.
-   - Adds each function as a standalone function in the `simdutf` namespace in `include/simdutf/implementation.h`.
-   - Adds each as a virtual function in the `implementation` class.
-   - Adds implementations in `src/implementation.cpp` (detect, unsupported, and standalone).
-   - Adds stub implementations (`// TODO: implement`) in all `src/*/implementation.cpp` files.
-
-4. **Post-Script Steps**:
-   - Implement the actual function logic in each `src/*/implementation.cpp` file.
-   - Update any tests or documentation as needed.
-   - Rebuild and test the library.
-
-## Warnings
-- This script modifies source files directly. Back up your repository before running it.
-- The script uses simple text manipulation; complex signatures may require manual adjustments.
-- Ensure the feature macro is correctly defined in the build system.
-
-If you encounter issues, check the script's output and verify the file paths.

package/deps/simdutf/scripts/add_function.py

@@ -1,330 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to automate adding a new function to the simdutf library.
-This script reads a file containing the function signatures and documentation,
-then adds the functions to the appropriate files in the codebase.
-
-Usage:
-    python add_function.py <signature_file>
-
-Where <signature_file> is a file containing the function signatures, wrapped in a feature macro block, e.g.:
-    #if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16
-    /**
-     * Documentation for first function.
-     */
-    simdutf_warn_unused size_t utf8_length_from_utf16le(
-        const char16_t *buf, size_t len) noexcept;
-
-    /**
-     * Documentation for second function.
-     */
-    simdutf_warn_unused size_t utf8_length_from_utf16be(
-        const char16_t *buf, size_t len) noexcept;
-    #endif
-"""
-
-import sys
-import os
-import re
-import glob
-
-def read_signature_file(file_path):
-    """Read and parse the signature file."""
-    with open(file_path, 'r') as f:
-        content = f.read()
-    
-    # Extract the feature macro (e.g., SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16)
-    feature_match = re.search(r'#if\s+(.+)', content)
-    feature_macro = feature_match.group(1).strip() if feature_match else None
-    
-    # Extract the content between #if and #endif
-    if_match = re.search(r'#if\s+.+?(#endif)', content, re.DOTALL)
-    if not if_match:
-        raise ValueError("Could not find #if/#endif block.")
-    
-    block_content = if_match.group(0)
-    
-    # Extract all function signatures (documentation + signature)
-    sig_matches = re.findall(r'(/\*\*.*?\*/)\s*(.*?);', block_content, re.DOTALL)
-    if not sig_matches:
-        raise ValueError("Could not parse function signatures from file.")
-    
-    functions = []
-    for doc, sig in sig_matches:
-        doc = doc.strip()
-        signature = sig.strip() + ';'
-        # Extract function name
-        name_match = re.search(r'\s+(\w+)\s*\(', signature)
-        func_name = name_match.group(1) if name_match else None
-        functions.append((doc, signature, func_name))
-    
-    return feature_macro, functions
-
-def add_to_implementation_h(repo_root, feature_macro, functions):
-    """Add to include/simdutf/implementation.h"""
-    file_path = os.path.join(repo_root, 'include/simdutf/implementation.h')
-    
-    with open(file_path, 'r') as f:
-        content = f.read()
-    
-    # Check for existing #if block for standalone functions (after namespace)
-    ns_start = content.find('namespace simdutf {')
-    if ns_start == -1:
-        raise ValueError("Could not find namespace in implementation.h")
-    
-    existing_if = content.find(f'#if {feature_macro}', ns_start)
-    if existing_if != -1:
-        # Find the corresponding #endif
-        endif_pos = content.find('#endif', existing_if)
-        if endif_pos != -1:
-            insert_pos = endif_pos
-        else:
-            insert_pos = len(content)
-    else:
-        insert_pos = ns_start + len('namespace simdutf {')
-    
-    # Insert standalone functions
-    standalone = ""
-    for doc, signature, func_name in functions:
-        standalone_sig = signature.replace(' const ', ' ')
-        standalone += f"""{doc}
-
-{standalone_sig}
-
-
-"""
-    content = content[:insert_pos] + standalone + content[insert_pos:]
-    
-    # Now for virtual functions in class
-    class_start = content.find('class implementation {')
-    public_start = content.find('public:', class_start)
-    if public_start == -1:
-        raise ValueError("Could not find public section in implementation class")
-    
-    existing_if_class = content.find(f'#if {feature_macro}', public_start)
-    if existing_if_class != -1:
-        endif_pos_class = content.find('#endif', existing_if_class)
-        if endif_pos_class != -1:
-            insert_pos_class = endif_pos_class
-        else:
-            insert_pos_class = len(content)
-    else:
-        insert_pos_class = public_start + len('public:')
-    
-    # Insert virtual functions
-    virtual = ""
-    for doc, signature, func_name in functions:
-        # Normalize signature for virtual
-        clean_sig = re.sub(r'\s*;?\s*$', '', signature).strip()
-        virtual += f"""{doc}
-  virtual {clean_sig} = 0;
-
-
-"""
-    content = content[:insert_pos_class] + virtual + content[insert_pos_class:]
-    
-    with open(file_path, 'w') as f:
-        f.write(content)
-
-def add_to_src_implementation_cpp(repo_root, feature_macro, functions):
-    """Add to src/implementation.cpp"""
-    file_path = os.path.join(repo_root, 'src/implementation.cpp')
-    
-    with open(file_path, 'r') as f:
-        content = f.read()
-    
-    # For detect class
-    detect_start = content.find('class detect_best_supported_implementation_on_first_use')
-    if detect_start != -1:
-        existing_if = content.find(f'#if {feature_macro}', detect_start)
-        if existing_if != -1:
-            endif_pos = content.find('#endif', existing_if)
-            insert_pos = endif_pos if endif_pos != -1 else len(content)
-        else:
-            brace_pos = content.find('{', detect_start)
-            insert_pos = brace_pos + 1 if brace_pos != -1 else len(content)
-    else:
-        insert_pos = len(content)
-    
-    detect_impl = ""
-    for doc, signature, func_name in functions:
-        params = [p.strip().split()[-1].lstrip('*') for p in signature.split('(')[1].split(')')[0].split(',') if p.strip()]
-        param_list = ', '.join(params)
-        detect_impl += f"""{re.sub(r';$', ' {', signature.replace(' const noexcept', ' const noexcept final override'))}
-  return set_best()->{func_name}({param_list});
-}}
-
-
-"""
-    content = content[:insert_pos] + detect_impl + content[insert_pos:]
-    
-    # For unsupported class
-    unsupported_start = content.find('class unsupported_implementation final : public implementation {')
-    if unsupported_start != -1:
-        existing_if = content.find(f'#if {feature_macro}', unsupported_start)
-        if existing_if != -1:
-            endif_pos = content.find('#endif', existing_if)
-            insert_pos_unsup = endif_pos if endif_pos != -1 else len(content)
-        else:
-            insert_pos_unsup = unsupported_start + len('class unsupported_implementation final : public implementation {')
-    else:
-        insert_pos_unsup = len(content)
-    
-    unsupported_impl = ""
-    for doc, signature, func_name in functions:
-        return_stmt = "return nullptr;" if "const char" in signature.split('(')[0] or "char16_t" in signature.split('(')[0] else "return 0;"
-        unsupported_impl += f"""{re.sub(r';$', ' {', signature.replace(' const noexcept', ' const noexcept final override'))}
-  {return_stmt}  // Not supported
-}}
-
-
-"""
-    content = content[:insert_pos_unsup] + unsupported_impl + content[insert_pos_unsup:]
-    
-    # For standalone functions at end
-    existing_if_end = content.rfind(f'#if {feature_macro}')
-    if existing_if_end != -1:
-        endif_pos = content.find('#endif', existing_if_end)
-        insert_pos_end = endif_pos if endif_pos != -1 else len(content)
-    else:
-        insert_pos_end = len(content)
-    
-    standalone = ""
-    for doc, signature, func_name in functions:
-        params = [p.strip().split()[-1].lstrip('*') for p in signature.split('(')[1].split(')')[0].split(',') if p.strip()]
-        param_list = ', '.join(params)
-        # Remove const for standalone functions
-        standalone_sig = signature.replace(' const noexcept', ' noexcept')
-        standalone += f"""{re.sub(r';$', ' {', standalone_sig)}
-  return get_default_implementation()->{func_name}({param_list});
-}}
-
-
-"""
-    content = content[:insert_pos_end] + standalone + content[insert_pos_end:]
-    
-    with open(file_path, 'w') as f:
-        f.write(content)
-
-def add_to_impl_files(file_path, functions, feature_macro):
-    with open(file_path, 'r') as f:
-        content = f.read()
-    
-    impl = ""
-    for doc, signature, func_name in functions:
-        modified_signature = re.sub(re.escape(func_name), f'implementation::{func_name}', signature)
-        if ' const ' not in modified_signature:
-            modified_signature = modified_signature.replace(' noexcept', ' const noexcept')
-        modified_signature = modified_signature.replace(' const noexcept', ' const noexcept final override')
-        impl += f"""{re.sub(r';$', ' {', modified_signature)}
-  // TODO: implement
-}}
-
-
-"""
-    
-    existing_if = content.rfind(f'#if {feature_macro}')
-    if existing_if != -1:
-        endif_pos = content.find('#endif', existing_if)
-        insert_pos = endif_pos if endif_pos != -1 else len(content)
-        content = content[:insert_pos] + impl + content[insert_pos:]
-    else:
-        impl = f"#if {feature_macro}\n{impl}#endif // {feature_macro}\n"
-        content += impl
-    
-    with open(file_path, 'w') as f:
-        f.write(content)
-
-def add_declarations_to_impl_h(file_path, functions, feature_macro):
-    print(f"Adding declarations to {file_path}...")
-    # Now add declarations to the corresponding .h file
-    arch = os.path.basename(os.path.dirname(file_path))
-    h_file = file_path
-    with open(h_file, 'r') as f:
-        h_content = f.read()
-        
-    
-    insert_pos = h_content.rfind('};')
-    if insert_pos == -1:
-        print(f"}}; in {h_file}")
-    if insert_pos != -1:
-        print(f"Inserting declarations at position {insert_pos}...")
-        decl = ""
-        for doc, signature, func_name in functions:
-            modified_signature = signature
-            if ' const ' not in modified_signature:
-                modified_signature = modified_signature.replace(' noexcept', ' const noexcept')
-            decl += f"{modified_signature};\n"
-        
-        # Wrap with #if
-        existing_if_h = h_content.rfind(f'#if {feature_macro}')
-        if existing_if_h != -1:
-            endif_pos_h = h_content.find('#endif', existing_if_h)
-            insert_pos_h = endif_pos_h if endif_pos_h != -1 else insert_pos
-            h_content = h_content[:insert_pos_h] + decl + h_content[insert_pos_h:]
-        else:
-            decl = f"#if {feature_macro}\n{decl}#endif // {feature_macro}\n"
-            h_content = h_content[:insert_pos] + decl + h_content[insert_pos:]
-        print(f"Updating {h_file}...")
-        with open(h_file, 'w') as f:
-            f.write(h_content)
-
-def add_to_all_impl_files(repo_root, feature_macro, functions):
-    """Add to all src/**/implementation.cpp files"""
-    impl_files = glob.glob(os.path.join(repo_root, 'src', '**', 'implementation.cpp'), recursive=True)
-    # Exclude src/implementation.cpp as it's handled separately
-    impl_files = [f for f in impl_files if os.path.dirname(f) != os.path.join(repo_root, 'src')]
-    print(f"Found {len(impl_files)} implementation.cpp files to update.")
-    
-    for file_path in impl_files:
-        print(f"Updating {file_path}...")
-        add_to_impl_files(file_path, functions, feature_macro)
-
-def add_declaration_to_all_impl_files(repo_root, feature_macro, functions):
-    """Add declarations to all src/simdutf/**/implementation.h files"""
-    impl_files = glob.glob(os.path.join(repo_root, 'src/simdutf', '**', 'implementation.h'), recursive=True)
-    # Exclude src/implementation.cpp as it's handled separately
-    impl_files = [f for f in impl_files if os.path.dirname(f) != os.path.join(repo_root, 'src')]
-    print(f"Found {len(impl_files)} implementation.h files to update.")
-    
-    for file_path in impl_files:
-        print(f"Updating declarations for {file_path}...")
-        add_declarations_to_impl_h(file_path, functions, feature_macro)
-
-def main():
-    if len(sys.argv) != 2:
-        print("Usage: python add_function.py <signature_file>")
-        sys.exit(1)
-    
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    repo_root = os.path.abspath(os.path.join(script_dir, '..'))
-    
-    sig_file = sys.argv[1]
-    feature_macro, functions = read_signature_file(sig_file)
-    
-    # Ensure all signatures have const
-    updated_functions = []
-    for doc, sig, name in functions:
-        if ' const ' not in sig:
-            sig = sig.replace(' noexcept', ' const noexcept')
-        updated_functions.append((doc, sig, name))
-    functions = updated_functions
-    
-    if not feature_macro or not functions:
-        print("Error: Could not extract feature macro or functions.")
-        sys.exit(1)
-    
-    #add_to_implementation_h(repo_root, feature_macro, functions)
-    #add_to_src_implementation_cpp(repo_root, feature_macro, functions)
-    #add_to_all_impl_files(repo_root, feature_macro, functions)
-    add_declaration_to_all_impl_files(repo_root, feature_macro, functions)
-    
-    func_names = [name for _, _, name in functions]
-    print(f"Functions '{', '.join(func_names)}' added successfully.")
-    print("Please remember to implement the functions in the respective implementation.cpp files.")
-    print("Also, consider adding tests for the new functions.")
-    print("Run formatting tools to ensure code style consistency: ./scripts/clang_format_docker.sh ")
-    print("Done.")
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/amalgamation_tests.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-#
-# runs a test to ensure amalagamation works
-
-import subprocess
-import tempfile
-import argparse
-import datetime
-import itertools
-import math
-import random
-
-
-def test_one(args, features):
-    print(f"testing with these features enabled: {', '.join(features)}")
-    builddir = tempfile.TemporaryDirectory(delete=not args.keep_tmpdirs)
-    t0 = datetime.datetime.now()
-    subprocess.run(
-        [
-            "python3",
-            "singleheader/amalgamate.py",
-            "--source-dir",
-            "src",
-            "--include-dir",
-            "include",
-            "--output-dir",
-            builddir.name,
-            "--no-zip",
-            "--no-readme",
-        ]
-        + [f"--with-{feature}" for feature in features],
-        stdout=subprocess.DEVNULL,
-        check=True,
-    )
-    print(f"amalgamated in {builddir.name}")
-    if args.warnings:
-        warnings = [
-            "-Wall",
-            "-Wextra",
-            "-Werror",
-            "-Wno-error=unused-function",
-            "-Wno-error=unused-const-variable",
-        ]
-    else:
-        warnings = []
-    subprocess.run(
-        [args.compiler, "-c", "simdutf.cpp", "-I", ".", f"-std=c++{args.standard}"]
-        + warnings,
-        check=True,
-        cwd=builddir.name,
-    )
-    print(f"compiled in {builddir.name}")
-
-
-allfeatures = ["utf8", "utf16", "utf32", "base64", "detect-enc", "ascii", "latin1"]
-
-
-def test_combinations(args, include_count):
-    total = math.comb(len(allfeatures), include_count)
-    print(f"testing all {total} possible selections of {include_count} features")
-    for i, combo in enumerate(itertools.combinations(allfeatures, include_count)):
-        test_one(args, combo)
-        print(f"tested {i + 1} of {total}")
-
-
-def generate_subset():
-    s = allfeatures
-    for subset in itertools.chain.from_iterable(
-        itertools.combinations(s, r) for r in range(len(s) + 1)
-    ):
-        yield subset
-
-
-def test_random(args, N):
-    subsets = [s for s in generate_subset()]
-    random.shuffle(subsets)
-    if N > 0 and N < len(subsets):
-        subsets = subsets[0:N]
-    total = len(subsets)
-    for i, subset in enumerate(subsets):
-        print(f"testing {i + 1} of {total} subsets: {subset}")
-        test_one(args, subset)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        prog="amalgamation test", description="ensures that amalgamation works"
-    )
-    parser.add_argument("--standard", type=int, default=23)
-    parser.add_argument("--keep-tmpdirs", action="store_true")
-    parser.add_argument("--compiler", type=str, default="c++")
-    parser.add_argument("--warnings", action="store_true")
-    parser.add_argument(
-        "--test-implicit-all",
-        action="store_true",
-        help="test giving no features, meaning all features are implicitly on",
-    )
-    parser.add_argument(
-        "--test-explicit-all", action="store_true", help="test giving all features"
-    )
-    parser.add_argument(
-        "--test-singles", action="store_true", help="test one feature at a time"
-    )
-    parser.add_argument(
-        "--test-random",
-        type=int,
-        default=-1,
-        help="tests up to the given amount of random subsets. 0 means all. negative means don't do this.",
-    )
-    parser.add_argument(
-        "--test-pairs", action="store_true", help="tests all pairs of features"
-    )
-    parser.add_argument(
-        "--test-triplets", action="store_true", help="tests all triplets of features"
-    )
-    parser.add_argument(
-        "--test-all-but-one",
-        action="store_true",
-        help="tests all possible feature sets with one disabled",
-    )
-
-    args = parser.parse_args()
-
-    if args.test_implicit_all:
-        print("test all enabled, implicitly")
-        test_one(args, [])
-
-    if args.test_explicit_all:
-        print("test all enabled, explicitly")
-        test_one(args, allfeatures)
-
-    if args.test_singles:
-        print("test one single feature at a time")
-        test_combinations(args, 1)
-
-    if args.test_random >= 0:
-        print("test random")
-        test_random(args, args.test_random)
-
-    if args.test_pairs:
-        print("test all pairs")
-        test_combinations(args, 2)
-
-    if args.test_triplets:
-        print("test all triplets")
-        test_combinations(args, 3)
-
-    if args.test_all_but_one:
-        print("test all but one single feature at a time")
-        test_combinations(args, len(allfeatures) - 1)
-
-    print("all seems to have gone well. bye bye!")
-
-
-if __name__ == "__main__":
-    main()

package/deps/simdutf/scripts/base64/Makefile

@@ -1,2 +0,0 @@
-lint:
-	python -m mypy *.py

package/deps/simdutf/scripts/base64/README.md

@@ -1,2 +0,0 @@
-The scripts in this directory are for reference only. They were use to check
-the algorithms we are using.