Fix `Buffer.from(text, "base64")` and `Buffer.toString("base64")`

13 files changed, 513 insertions, 1036 deletions

diff --git a/.vscode/settings.json b/.vscode/settings.json
index c3541749a..0e0f09688 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -182,5 +182,6 @@
     "packet.h": "c",
     "queue": "cpp"
   },
-  "cmake.configureOnOpen": false
+  "cmake.configureOnOpen": false,
+  "C_Cpp.errorSquiggles": "Enabled"
 }
diff --git a/Makefile b/Makefile
index 56633ba2a..b45e12327 100644
--- a/Makefile
+++ b/Makefile
@@ -402,7 +402,6 @@ MINIMUM_ARCHIVE_FILES = -L$(BUN_DEPS_OUT_DIR) \
 
 ARCHIVE_FILES_WITHOUT_LIBCRYPTO = $(MINIMUM_ARCHIVE_FILES) \
 		-larchive \
-		-lbase64 \
 		-ltcc \
 		-lusockets \
 		$(BUN_DEPS_OUT_DIR)/libuwsockets.o
@@ -457,13 +456,7 @@ npm-install:
 	$(NPM_CLIENT) install
 
 
-.PHONY: base64
-base64:
-	cd src/base64 && \
-		rm -rf src/base64/*.{o,ll,bc} && \
-	   $(CC) $(EMIT_LLVM_FOR_RELEASE) $(BUN_CFLAGS) $(OPTIMIZATION_LEVEL) -g -fPIC -c *.c -I$(SRC_DIR)/base64  && \
-	   $(CXX) $(EMIT_LLVM_FOR_RELEASE) $(CXXFLAGS) $(BUN_CFLAGS) -c neonbase64.cc -g -fPIC  && \
-	   $(AR) rcvs $(BUN_DEPS_OUT_DIR)/libbase64.a ./*.o
+
 
 # Prevent dependency on libtcc1 so it doesn't do filesystem lookups
 TINYCC_CFLAGS= -DTCC_LIBTCC1=\"\0\"
@@ -502,7 +495,7 @@ builtins: ## to generate builtins
 generate-builtins: builtins
 
 .PHONY: vendor-without-check
-vendor-without-check: npm-install node-fallbacks runtime_js fallback_decoder bun_error mimalloc picohttp zlib boringssl libarchive libbacktrace lolhtml usockets uws base64 tinycc oniguruma
+vendor-without-check: npm-install node-fallbacks runtime_js fallback_decoder bun_error mimalloc picohttp zlib boringssl libarchive libbacktrace lolhtml usockets uws tinycc oniguruma
 
 BUN_TYPES_REPO_PATH ?= $(realpath ../bun-types)
 
@@ -854,7 +847,7 @@ clone-submodules:
 	git -c submodule."src/bun.js/WebKit".update=none submodule update --init --recursive --depth=1 --progress
 
 .PHONY: devcontainer
-devcontainer: $(OBJ_DIR) $(DEBUG_OBJ_DIR) clone-submodules libbacktrace mimalloc zlib libarchive boringssl picohttp identifier-cache node-fallbacks npm-install api analytics bun_error fallback_decoder bindings uws lolhtml usockets base64 tinycc runtime_js_dev sqlite oniguruma webcrypto-debug webcrypto
+devcontainer: $(OBJ_DIR) $(DEBUG_OBJ_DIR) clone-submodules libbacktrace mimalloc zlib libarchive boringssl picohttp identifier-cache node-fallbacks npm-install api analytics bun_error fallback_decoder bindings uws lolhtml usockets tinycc runtime_js_dev sqlite oniguruma webcrypto-debug webcrypto
 
 .PHONY: devcontainer-build
 devcontainer-build:
diff --git a/src/base64/README.md b/src/base64/README.md
deleted file mode 100644
index 82bfb8ba2..000000000
--- a/src/base64/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Base64
-
-This uses https://github.com/lemire/fastbase64
-
-Changes:
-
-- chromiumbase64 doesn't add a null byte
-- chromiumbase64 handles some whitespace characters more loosely
diff --git a/src/base64/base64.zig b/src/base64/base64.zig
index 3210eff29..963096a26 100644
--- a/src/base64/base64.zig
+++ b/src/base64/base64.zig
@@ -1,33 +1,42 @@
 const std = @import("std");
 
-extern fn bun_base64_encode(dest: [*]u8, src: [*]const u8, len: usize) usize;
-extern fn bun_base64_decode(dest: [*]u8, src: [*]const u8, len: usize, out_len: *usize) usize;
-
 pub const DecodeResult = struct {
     written: usize,
     fail: bool = false,
 };
 
 pub fn decode(destination: []u8, source: []const u8) DecodeResult {
-    var out: usize = 0;
-    const ret = bun_base64_decode(destination.ptr, source.ptr, source.len, &out);
-    if (ret == std.math.maxInt(usize) - 1) {
+    var wrote: usize = 0;
+    const result = zig_base64.standard.decoderWithIgnore(&[_]u8{
+        ' ',
+        '\n',
+        '\r',
+        '\t',
+        std.ascii.control_code.VT,
+    }).decode(destination, source, &wrote) catch {
         return .{
-            .written = out,
+            .written = wrote,
             .fail = true,
         };
-    }
+    };
 
-    // std.debug.assert(out == ret);
+    return .{ .written = result, .fail = false };
+}
 
-    return .{
-        .written = out,
-        .fail = false,
+pub fn decodeURLSafe(destination: []u8, source: []const u8) DecodeResult {
+    var wrote: usize = 0;
+    const result = urlsafe.decode(destination, source, &wrote) catch {
+        return .{
+            .written = wrote,
+            .fail = true,
+        };
     };
+
+    return .{ .written = result, .fail = false };
 }
 
 pub fn encode(destination: []u8, source: []const u8) usize {
-    return bun_base64_encode(destination.ptr, source.ptr, source.len);
+    return zig_base64.standard.Encoder.encode(destination, source).len;
 }
 
 /// Given a source string of length len, this returns the amount of
@@ -46,10 +55,468 @@ pub fn encodeLen(source: anytype) usize {
     return (source.len + 2) / 3 * 4;
 }
 
-pub const urlsafe = std.base64.Base64DecoderWithIgnore.init(
-    std.base64.url_safe_alphabet_chars,
+pub const urlsafe = zig_base64.Base64DecoderWithIgnore.init(
+    zig_base64.url_safe_alphabet_chars,
     null,
     "= \t\r\n" ++ [_]u8{ std.ascii.control_code.VT, std.ascii.control_code.FF },
 );
 
-pub const urlsafeEncoder = std.base64.url_safe_no_pad.Encoder;
+pub const urlsafeEncoder = zig_base64.url_safe_no_pad.Encoder;
+
+// This is just std.base64 copy-pasted
+// with support for returning how many bytes were decoded
+const zig_base64 = struct {
+    const assert = std.debug.assert;
+    const testing = std.testing;
+    const mem = std.mem;
+
+    pub const Error = error{
+        InvalidCharacter,
+        InvalidPadding,
+        NoSpaceLeft,
+    };
+
+    const decoderWithIgnoreProto = switch (@import("builtin").zig_backend) {
+        .stage1 => fn (ignore: []const u8) Base64DecoderWithIgnore,
+        else => *const fn (ignore: []const u8) Base64DecoderWithIgnore,
+    };
+
+    /// Base64 codecs
+    pub const Codecs = struct {
+        alphabet_chars: [64]u8,
+        pad_char: ?u8,
+        decoderWithIgnore: decoderWithIgnoreProto,
+        Encoder: Base64Encoder,
+        Decoder: Base64Decoder,
+    };
+
+    pub const standard_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".*;
+    fn standardBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
+        return Base64DecoderWithIgnore.init(standard_alphabet_chars, '=', ignore);
+    }
+
+    /// Standard Base64 codecs, with padding
+    pub const standard = Codecs{
+        .alphabet_chars = standard_alphabet_chars,
+        .pad_char = '=',
+        .decoderWithIgnore = standardBase64DecoderWithIgnore,
+        .Encoder = Base64Encoder.init(standard_alphabet_chars, '='),
+        .Decoder = Base64Decoder.init(standard_alphabet_chars, '='),
+    };
+
+    /// Standard Base64 codecs, without padding
+    pub const standard_no_pad = Codecs{
+        .alphabet_chars = standard_alphabet_chars,
+        .pad_char = null,
+        .decoderWithIgnore = standardBase64DecoderWithIgnore,
+        .Encoder = Base64Encoder.init(standard_alphabet_chars, null),
+        .Decoder = Base64Decoder.init(standard_alphabet_chars, null),
+    };
+
+    pub const url_safe_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".*;
+    fn urlSafeBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
+        return Base64DecoderWithIgnore.init(url_safe_alphabet_chars, null, ignore);
+    }
+
+    /// URL-safe Base64 codecs, with padding
+    pub const url_safe = Codecs{
+        .alphabet_chars = url_safe_alphabet_chars,
+        .pad_char = '=',
+        .decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
+        .Encoder = Base64Encoder.init(url_safe_alphabet_chars, '='),
+        .Decoder = Base64Decoder.init(url_safe_alphabet_chars, '='),
+    };
+
+    /// URL-safe Base64 codecs, without padding
+    pub const url_safe_no_pad = Codecs{
+        .alphabet_chars = url_safe_alphabet_chars,
+        .pad_char = null,
+        .decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
+        .Encoder = Base64Encoder.init(url_safe_alphabet_chars, null),
+        .Decoder = Base64Decoder.init(url_safe_alphabet_chars, null),
+    };
+
+    pub const standard_pad_char = @compileError("deprecated; use standard.pad_char");
+    pub const standard_encoder = @compileError("deprecated; use standard.Encoder");
+    pub const standard_decoder = @compileError("deprecated; use standard.Decoder");
+
+    pub const Base64Encoder = struct {
+        alphabet_chars: [64]u8,
+        pad_char: ?u8,
+
+        /// A bunch of assertions, then simply pass the data right through.
+        pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Encoder {
+            assert(alphabet_chars.len == 64);
+            var char_in_alphabet = [_]bool{false} ** 256;
+            for (alphabet_chars) |c| {
+                assert(!char_in_alphabet[c]);
+                assert(pad_char == null or c != pad_char.?);
+                char_in_alphabet[c] = true;
+            }
+            return Base64Encoder{
+                .alphabet_chars = alphabet_chars,
+                .pad_char = pad_char,
+            };
+        }
+
+        /// Compute the encoded length
+        pub fn calcSize(encoder: *const Base64Encoder, source_len: usize) usize {
+            if (encoder.pad_char != null) {
+                return @divTrunc(source_len + 2, 3) * 4;
+            } else {
+                const leftover = source_len % 3;
+                return @divTrunc(source_len, 3) * 4 + @divTrunc(leftover * 4 + 2, 3);
+            }
+        }
+
+        /// dest.len must at least be what you get from ::calcSize.
+        pub fn encode(encoder: *const Base64Encoder, dest: []u8, source: []const u8) []const u8 {
+            const out_len = encoder.calcSize(source.len);
+            assert(dest.len >= out_len);
+
+            var acc: u12 = 0;
+            var acc_len: u4 = 0;
+            var out_idx: usize = 0;
+            for (source) |v| {
+                acc = (acc << 8) + v;
+                acc_len += 8;
+                while (acc_len >= 6) {
+                    acc_len -= 6;
+                    dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc >> acc_len))];
+                    out_idx += 1;
+                }
+            }
+            if (acc_len > 0) {
+                dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc << 6 - acc_len))];
+                out_idx += 1;
+            }
+            if (encoder.pad_char) |pad_char| {
+                for (dest[out_idx..]) |*pad| {
+                    pad.* = pad_char;
+                }
+            }
+            return dest[0..out_len];
+        }
+    };
+
+    pub const Base64Decoder = struct {
+        const invalid_char: u8 = 0xff;
+
+        /// e.g. 'A' => 0.
+        /// `invalid_char` for any value not in the 64 alphabet chars.
+        char_to_index: [256]u8,
+        pad_char: ?u8,
+
+        pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Decoder {
+            var result = Base64Decoder{
+                .char_to_index = [_]u8{invalid_char} ** 256,
+                .pad_char = pad_char,
+            };
+
+            var char_in_alphabet = [_]bool{false} ** 256;
+            for (alphabet_chars) |c, i| {
+                assert(!char_in_alphabet[c]);
+                assert(pad_char == null or c != pad_char.?);
+
+                result.char_to_index[c] = @intCast(u8, i);
+                char_in_alphabet[c] = true;
+            }
+            return result;
+        }
+
+        /// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding.
+        /// `InvalidPadding` is returned if the input length is not valid.
+        pub fn calcSizeUpperBound(decoder: *const Base64Decoder, source_len: usize) Error!usize {
+            var result = source_len / 4 * 3;
+            const leftover = source_len % 4;
+            if (decoder.pad_char != null) {
+                if (leftover % 4 != 0) return error.InvalidPadding;
+            } else {
+                if (leftover % 4 == 1) return error.InvalidPadding;
+                result += leftover * 3 / 4;
+            }
+            return result;
+        }
+
+        /// Return the exact decoded size for a slice.
+        /// `InvalidPadding` is returned if the input length is not valid.
+        pub fn calcSizeForSlice(decoder: *const Base64Decoder, source: []const u8) Error!usize {
+            const source_len = source.len;
+            var result = try decoder.calcSizeUpperBound(source_len);
+            if (decoder.pad_char) |pad_char| {
+                if (source_len >= 1 and source[source_len - 1] == pad_char) result -= 1;
+                if (source_len >= 2 and source[source_len - 2] == pad_char) result -= 1;
+            }
+            return result;
+        }
+
+        /// dest.len must be what you get from ::calcSize.
+        /// invalid characters result in error.InvalidCharacter.
+        /// invalid padding results in error.InvalidPadding.
+        pub fn decode(decoder: *const Base64Decoder, dest: []u8, source: []const u8) Error!void {
+            if (decoder.pad_char != null and source.len % 4 != 0) return error.InvalidPadding;
+            var acc: u12 = 0;
+            var acc_len: u4 = 0;
+            var dest_idx: usize = 0;
+            var leftover_idx: ?usize = null;
+            for (source) |c, src_idx| {
+                const d = decoder.char_to_index[c];
+                if (d == invalid_char) {
+                    if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
+                    leftover_idx = src_idx;
+                    break;
+                }
+                acc = (acc << 6) + d;
+                acc_len += 6;
+                if (acc_len >= 8) {
+                    acc_len -= 8;
+                    dest[dest_idx] = @truncate(u8, acc >> acc_len);
+                    dest_idx += 1;
+                }
+            }
+            if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
+                return error.InvalidPadding;
+            }
+            if (leftover_idx == null) return;
+            var leftover = source[leftover_idx.?..];
+            if (decoder.pad_char) |pad_char| {
+                const padding_len = acc_len / 2;
+                var padding_chars: usize = 0;
+                for (leftover) |c| {
+                    if (c != pad_char) {
+                        return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
+                    }
+                    padding_chars += 1;
+                }
+                if (padding_chars != padding_len) return error.InvalidPadding;
+            }
+        }
+    };
+
+    pub const Base64DecoderWithIgnore = struct {
+        decoder: Base64Decoder,
+        char_is_ignored: [256]bool,
+
+        pub fn init(alphabet_chars: [64]u8, pad_char: ?u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
+            var result = Base64DecoderWithIgnore{
+                .decoder = Base64Decoder.init(alphabet_chars, pad_char),
+                .char_is_ignored = [_]bool{false} ** 256,
+            };
+            for (ignore_chars) |c| {
+                assert(result.decoder.char_to_index[c] == Base64Decoder.invalid_char);
+                assert(!result.char_is_ignored[c]);
+                assert(result.decoder.pad_char != c);
+                result.char_is_ignored[c] = true;
+            }
+            return result;
+        }
+
+        /// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding
+        /// `InvalidPadding` is returned if the input length is not valid.
+        pub fn calcSizeUpperBound(decoder_with_ignore: *const Base64DecoderWithIgnore, source_len: usize) Error!usize {
+            var result = source_len / 4 * 3;
+            if (decoder_with_ignore.decoder.pad_char == null) {
+                const leftover = source_len % 4;
+                result += leftover * 3 / 4;
+            }
+            return result;
+        }
+
+        /// Invalid characters that are not ignored result in error.InvalidCharacter.
+        /// Invalid padding results in error.InvalidPadding.
+        /// Decoding more data than can fit in dest results in error.NoSpaceLeft. See also ::calcSizeUpperBound.
+        /// Returns the number of bytes written to dest.
+        pub fn decode(decoder_with_ignore: *const Base64DecoderWithIgnore, dest: []u8, source: []const u8, wrote: *usize) Error!usize {
+            const decoder = &decoder_with_ignore.decoder;
+            var acc: u12 = 0;
+            var acc_len: u4 = 0;
+            var dest_idx: usize = 0;
+            var leftover_idx: ?usize = null;
+
+            defer {
+                wrote.* = leftover_idx orelse dest_idx;
+            }
+
+            for (source) |c, src_idx| {
+                if (decoder_with_ignore.char_is_ignored[c]) continue;
+                const d = decoder.char_to_index[c];
+                if (d == Base64Decoder.invalid_char) {
+                    if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
+                    leftover_idx = src_idx;
+                    break;
+                }
+                acc = (acc << 6) + d;
+                acc_len += 6;
+                if (acc_len >= 8) {
+                    if (dest_idx == dest.len) return error.NoSpaceLeft;
+                    acc_len -= 8;
+                    dest[dest_idx] = @truncate(u8, acc >> acc_len);
+                    dest_idx += 1;
+                }
+            }
+            if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
+                return error.InvalidPadding;
+            }
+            const padding_len = acc_len / 2;
+            if (leftover_idx == null) {
+                if (decoder.pad_char != null and padding_len != 0) return error.InvalidPadding;
+                return dest_idx;
+            }
+            var leftover = source[leftover_idx.?..];
+            if (decoder.pad_char) |pad_char| {
+                var padding_chars: usize = 0;
+                for (leftover) |c| {
+                    if (decoder_with_ignore.char_is_ignored[c]) continue;
+                    if (c != pad_char) {
+                        return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
+                    }
+                    padding_chars += 1;
+                }
+                if (padding_chars != padding_len) return error.InvalidPadding;
+            }
+            return dest_idx;
+        }
+    };
+
+    test "base64" {
+        @setEvalBranchQuota(8000);
+        try testBase64();
+        comptime try testAllApis(standard, "comptime", "Y29tcHRpbWU=");
+    }
+
+    test "base64 url_safe_no_pad" {
+        @setEvalBranchQuota(8000);
+        try testBase64UrlSafeNoPad();
+        comptime try testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU");
+    }
+
+    fn testBase64() !void {
+        const codecs = standard;
+
+        try testAllApis(codecs, "", "");
+        try testAllApis(codecs, "f", "Zg==");
+        try testAllApis(codecs, "fo", "Zm8=");
+        try testAllApis(codecs, "foo", "Zm9v");
+        try testAllApis(codecs, "foob", "Zm9vYg==");
+        try testAllApis(codecs, "fooba", "Zm9vYmE=");
+        try testAllApis(codecs, "foobar", "Zm9vYmFy");
+
+        try testDecodeIgnoreSpace(codecs, "", " ");
+        try testDecodeIgnoreSpace(codecs, "f", "Z g= =");
+        try testDecodeIgnoreSpace(codecs, "fo", "    Zm8=");
+        try testDecodeIgnoreSpace(codecs, "foo", "Zm9v    ");
+        try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg = = ");
+        try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE=");
+        try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
+
+        // test getting some api errors
+        try testError(codecs, "A", error.InvalidPadding);
+        try testError(codecs, "AA", error.InvalidPadding);
+        try testError(codecs, "AAA", error.InvalidPadding);
+        try testError(codecs, "A..A", error.InvalidCharacter);
+        try testError(codecs, "AA=A", error.InvalidPadding);
+        try testError(codecs, "AA/=", error.InvalidPadding);
+        try testError(codecs, "A/==", error.InvalidPadding);
+        try testError(codecs, "A===", error.InvalidPadding);
+        try testError(codecs, "====", error.InvalidPadding);
+
+        try testNoSpaceLeftError(codecs, "AA==");
+        try testNoSpaceLeftError(codecs, "AAA=");
+        try testNoSpaceLeftError(codecs, "AAAA");
+        try testNoSpaceLeftError(codecs, "AAAAAA==");
+    }
+
+    fn testBase64UrlSafeNoPad() !void {
+        const codecs = url_safe_no_pad;
+
+        try testAllApis(codecs, "", "");
+        try testAllApis(codecs, "f", "Zg");
+        try testAllApis(codecs, "fo", "Zm8");
+        try testAllApis(codecs, "foo", "Zm9v");
+        try testAllApis(codecs, "foob", "Zm9vYg");
+        try testAllApis(codecs, "fooba", "Zm9vYmE");
+        try testAllApis(codecs, "foobar", "Zm9vYmFy");
+
+        try testDecodeIgnoreSpace(codecs, "", " ");
+        try testDecodeIgnoreSpace(codecs, "f", "Z g ");
+        try testDecodeIgnoreSpace(codecs, "fo", "    Zm8");
+        try testDecodeIgnoreSpace(codecs, "foo", "Zm9v    ");
+        try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg   ");
+        try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE");
+        try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
+
+        // test getting some api errors
+        try testError(codecs, "A", error.InvalidPadding);
+        try testError(codecs, "AAA=", error.InvalidCharacter);
+        try testError(codecs, "A..A", error.InvalidCharacter);
+        try testError(codecs, "AA=A", error.InvalidCharacter);
+        try testError(codecs, "AA/=", error.InvalidCharacter);
+        try testError(codecs, "A/==", error.InvalidCharacter);
+        try testError(codecs, "A===", error.InvalidCharacter);
+        try testError(codecs, "====", error.InvalidCharacter);
+
+        try testNoSpaceLeftError(codecs, "AA");
+        try testNoSpaceLeftError(codecs, "AAA");
+        try testNoSpaceLeftError(codecs, "AAAA");
+        try testNoSpaceLeftError(codecs, "AAAAAA");
+    }
+
+    fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: []const u8) !void {
+        // Base64Encoder
+        {
+            var buffer: [0x100]u8 = undefined;
+            const encoded = codecs.Encoder.encode(&buffer, expected_decoded);
+            try testing.expectEqualSlices(u8, expected_encoded, encoded);
+        }
+
+        // Base64Decoder
+        {
+            var buffer: [0x100]u8 = undefined;
+            var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)];
+            try codecs.Decoder.decode(decoded, expected_encoded);
+            try testing.expectEqualSlices(u8, expected_decoded, decoded);
+        }
+
+        // Base64DecoderWithIgnore
+        {
+            const decoder_ignore_nothing = codecs.decoderWithIgnore("");
+            var buffer: [0x100]u8 = undefined;
+            var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)];
+            var written = try decoder_ignore_nothing.decode(decoded, expected_encoded);
+            try testing.expect(written <= decoded.len);
+            try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
+        }
+    }
+
+    fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded: []const u8) !void {
+        const decoder_ignore_space = codecs.decoderWithIgnore(" ");
+        var buffer: [0x100]u8 = undefined;
+        var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)];
+        var written = try decoder_ignore_space.decode(decoded, encoded);
+        try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
+    }
+
+    fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void {
+        const decoder_ignore_space = codecs.decoderWithIgnore(" ");
+        var buffer: [0x100]u8 = undefined;
+        if (codecs.Decoder.calcSizeForSlice(encoded)) |decoded_size| {
+            var decoded = buffer[0..decoded_size];
+            if (codecs.Decoder.decode(decoded, encoded)) |_| {
+                return error.ExpectedError;
+            } else |err| if (err != expected_err) return err;
+        } else |err| if (err != expected_err) return err;
+
+        if (decoder_ignore_space.decode(buffer[0..], encoded)) |_| {
+            return error.ExpectedError;
+        } else |err| if (err != expected_err) return err;
+    }
+
+    fn testNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void {
+        const decoder_ignore_space = codecs.decoderWithIgnore(" ");
+        var buffer: [0x100]u8 = undefined;
+        var decoded = buffer[0 .. (try codecs.Decoder.calcSizeForSlice(encoded)) - 1];
+        if (decoder_ignore_space.decode(decoded, encoded)) |_| {
+            return error.ExpectedError;
+        } else |err| if (err != error.NoSpaceLeft) return err;
+    }
+};
diff --git a/src/base64/bun-base64.c b/src/base64/bun-base64.c
deleted file mode 100644
index 6cf11bbe7..000000000
--- a/src/base64/bun-base64.c
+++ /dev/null
@@ -1,46 +0,0 @@
-
-#include "bun-base64.h"
-
-#if defined(__GNUC__) && defined(__ARM_NEON__)
-
-int neon_base64_decode(char *out, const char *src, size_t srclen,
-                       size_t *outlen);
-
-#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-
-#include "fastavxbase64.h"
-
-#endif
-
-#if defined(__GNUC__) && defined(__ARM_NEON__)
-size_t bun_base64_decode(char *dest, const char *src, size_t len,
-                         size_t *outlen) {
-  // neon base64 is decode only
-  return neon_base64_decode(dest, src, len, outlen);
-}
-size_t bun_base64_encode(char *dest, const char *src, size_t len) {
-  return chromium_base64_encode(dest, src, len);
-}
-
-#elif defined(__GNUC__) && (defined(__x86_64__) && defined(__AVX2__))
-
-size_t bun_base64_decode(char *dest, const char *src, size_t len,
-                         size_t *outlen) {
-  return fast_avx2_base64_decode(dest, src, len, outlen);
-}
-size_t bun_base64_encode(char *dest, const char *src, size_t len) {
-
-  return fast_avx2_base64_encode(dest, src, len);
-}
-
-#else
-
-size_t bun_base64_decode(char *dest, const char *src, size_t len,
-                         size_t *outlen) {
-  return chromium_base64_decode(dest, src, len, outlen);
-}
-size_t bun_base64_encode(char *dest, const char *src, size_t len) {
-  return chromium_base64_encode(dest, src, len);
-}
-
-#endif
\ No newline at end of file
diff --git a/src/base64/bun-base64.h b/src/base64/bun-base64.h
deleted file mode 100644
index 82b15d73a..000000000
--- a/src/base64/bun-base64.h
+++ /dev/null
@@ -1,7 +0,0 @@
-
-#include "chromiumbase64.h"
-#include "fastavxbase64.h"
-
-size_t bun_base64_decode(char *dest, const char *src, size_t len,
-                         size_t *outlen);
-size_t bun_base64_encode(char *dest, const char *str, size_t len);
\ No newline at end of file
diff --git a/src/base64/chromiumbase64.c b/src/base64/chromiumbase64.c
deleted file mode 100644
index 2a962a317..000000000
--- a/src/base64/chromiumbase64.c
+++ /dev/null
@@ -1,415 +0,0 @@
-#include "chromiumbase64.h"
-
-// from node:
-static const int8_t unbase64_table[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
-    61, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
-    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
-    63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
-    43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-#define CHAR62 '+'
-#define CHAR63 '/'
-#define CHARPAD '='
-static const char e0[256] = {
-    'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'D', 'D', 'D',
-    'D', 'E', 'E', 'E', 'E', 'F', 'F', 'F', 'F', 'G', 'G', 'G', 'G', 'H', 'H',
-    'H', 'H', 'I', 'I', 'I', 'I', 'J', 'J', 'J', 'J', 'K', 'K', 'K', 'K', 'L',
-    'L', 'L', 'L', 'M', 'M', 'M', 'M', 'N', 'N', 'N', 'N', 'O', 'O', 'O', 'O',
-    'P', 'P', 'P', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'R', 'R', 'S', 'S', 'S',
-    'S', 'T', 'T', 'T', 'T', 'U', 'U', 'U', 'U', 'V', 'V', 'V', 'V', 'W', 'W',
-    'W', 'W', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'a',
-    'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd',
-    'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g', 'g', 'h', 'h', 'h',
-    'h', 'i', 'i', 'i', 'i', 'j', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'l', 'l',
-    'l', 'l', 'm', 'm', 'm', 'm', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o', 'p',
-    'p', 'p', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 's', 's', 's', 's',
-    't', 't', 't', 't', 'u', 'u', 'u', 'u', 'v', 'v', 'v', 'v', 'w', 'w', 'w',
-    'w', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'z', 'z', 'z', 'z', '0', '0',
-    '0', '0', '1', '1', '1', '1', '2', '2', '2', '2', '3', '3', '3', '3', '4',
-    '4', '4', '4', '5', '5', '5', '5', '6', '6', '6', '6', '7', '7', '7', '7',
-    '8', '8', '8', '8', '9', '9', '9', '9', '+', '+', '+', '+', '/', '/', '/',
-    '/'};
-
-static const char e1[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
-    '/'};
-
-static const char e2[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
-    '/'};
-
-/* SPECIAL DECODE TABLES FOR LITTLE ENDIAN (INTEL) CPUS */
-
-static const uint32_t d0[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x000000f8, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
-    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
-    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
-    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
-    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
-    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
-    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
-    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
-    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
-    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
-    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-static const uint32_t d1[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x0000e003, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
-    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
-    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
-    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
-    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
-    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
-    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
-    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
-    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
-    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
-    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-static const uint32_t d2[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00800f00, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
-    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
-    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
-    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
-    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
-    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
-    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
-    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
-    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
-    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
-    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-static const uint32_t d3[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x003e0000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
-    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
-    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
-    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
-    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
-    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
-    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
-    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
-    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
-    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
-    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-#define BADCHAR 0x01FFFFFF
-
-/**
- * you can control if we use padding by commenting out this
- * next line.  However, I highly recommend you use padding and not
- * using it should only be for compatability with a 3rd party.
- * Also, 'no padding' is not tested!
- */
-#define DOPAD 1
-
-/*
- * if we aren't doing padding
- * set the pad character to NULL
- */
-#ifndef DOPAD
-#undef CHARPAD
-#define CHARPAD '\0'
-#endif
-
-size_t chromium_base64_encode(char *dest, const char *str, size_t len) {
-  size_t i = 0;
-  uint8_t *p = (uint8_t *)dest;
-
-  /* unsigned here is important! */
-  uint8_t t1, t2, t3;
-
-  if (len > 2) {
-    for (; i < len - 2; i += 3) {
-      t1 = str[i];
-      t2 = str[i + 1];
-      t3 = str[i + 2];
-      *p++ = e0[t1];
-      *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
-      *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
-      *p++ = e2[t3];
-    }
-  }
-
-  switch (len - i) {
-  case 0:
-    break;
-  case 1:
-    t1 = str[i];
-    *p++ = e0[t1];
-    *p++ = e1[(t1 & 0x03) << 4];
-    *p++ = CHARPAD;
-    *p++ = CHARPAD;
-    break;
-  default: /* case 2 */
-    t1 = str[i];
-    t2 = str[i + 1];
-    *p++ = e0[t1];
-    *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
-    *p++ = e2[(t2 & 0x0F) << 2];
-    *p++ = CHARPAD;
-  }
-
-  // Commented out because it already returns the length
-  //   *p = '\0';
-  return p - (uint8_t *)dest;
-}
-
-size_t chromium_base64_decode(char *dest, const char *src, size_t len,
-                              size_t *out_len) {
-  if (len == 0) {
-    *out_len = 0;
-    return 0;
-  }
-
-#ifdef DOPAD
-  /*
-   * if padding is used, then the message must be at least
-   * 4 chars and be a multiple of 4
-   */
-  if (len < 4 || (len % 4 != 0)) {
-    *out_len = 0;
-    return MODP_B64_ERROR; /* error */
-  }
-  /* there can be at most 2 pad chars at the end */
-  if (src[len - 1] == CHARPAD) {
-    len--;
-    if (src[len - 1] == CHARPAD) {
-      len--;
-    }
-  }
-#endif
-
-  size_t i;
-  int leftover = len % 4;
-  size_t chunks = (leftover == 0) ? len / 4 - 1 : len / 4;
-
-  uint8_t *p = (uint8_t *)dest;
-  uint32_t x = 0;
-  const uint8_t *y = (uint8_t *)src;
-  for (i = 0; i < chunks;) {
-    x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
-    if (x >= BADCHAR) {
-      // skip whitespace
-      // this is change bun added
-      if (y[0] < 64) {
-        y++;
-        continue;
-      }
-
-      *out_len = p - (uint8_t *)dest;
-      return MODP_B64_ERROR;
-    }
-
-    *p++ = ((uint8_t *)(&x))[0];
-    *p++ = ((uint8_t *)(&x))[1];
-    *p++ = ((uint8_t *)(&x))[2];
-    y += 4;
-    ++i;
-  }
-
-  switch (leftover) {
-  case 0:
-    x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
-
-    if (x >= BADCHAR) {
-      *out_len = p - (uint8_t *)dest + 1;
-      return MODP_B64_ERROR;
-    }
-
-    *p++ = ((uint8_t *)(&x))[0];
-    *p++ = ((uint8_t *)(&x))[1];
-    *p = ((uint8_t *)(&x))[2];
-    return (chunks + 1) * 3;
-    break;
-  case 1: /* with padding this is an impossible case */
-    x = d0[y[0]];
-    *p = *((uint8_t *)(&x)); // i.e. first char/byte in int
-    break;
-  case 2: // * case 2, 1  output byte */
-    x = d0[y[0]] | d1[y[1]];
-    *p = *((uint8_t *)(&x)); // i.e. first char
-    break;
-  default:                              /* case 3, 2 output bytes */
-    x = d0[y[0]] | d1[y[1]] | d2[y[2]]; /* 0x3c */
-    *p++ = ((uint8_t *)(&x))[0];
-    *p = ((uint8_t *)(&x))[1];
-    break;
-  }
-
-  *out_len = 3 * chunks + (6 * leftover) / 8;
-
-  if (x >= BADCHAR)
-    return MODP_B64_ERROR;
-
-  return 3 * chunks + (6 * leftover) / 8;
-}
\ No newline at end of file
diff --git a/src/base64/chromiumbase64.h b/src/base64/chromiumbase64.h
deleted file mode 100644
index 96b201c7b..000000000
--- a/src/base64/chromiumbase64.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/***************
- * Taken more or less as-is from the chromium project
- ****************/
-
-/**
- * \file
- * <PRE>
- * High performance base64 encoder / decoder
- * Version 1.3 -- 17-Mar-2006
- *
- * Copyright &copy; 2005, 2006, Nick Galbreath -- nickg [at] modp [dot] com
- * All rights reserved.
- *
- * http://modp.com/release/base64
- *
- * Released under bsd license.  See modp_b64.c for details.
- * </pre>
- *
- * The default implementation is the standard b64 encoding with padding.
- * It's easy to change this to use "URL safe" characters and to remove
- * padding.  See the modp_b64.c source code for details.
- *
- */
-
-#ifndef MODP_B64
-#define MODP_B64
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MODP_B64_ERROR ((size_t)-1)
-/**
- * Encode a raw binary string into base 64.
- * src contains the bytes
- * len contains the number of bytes in the src
- * dest should be allocated by the caller to contain
- *   at least chromium_base64_encode_len(len) bytes (see below)
- *   This will contain the null-terminated b64 encoded result
- * returns length of the destination string plus the ending null byte
- *    i.e.  the result will be equal to strlen(dest) + 1
- *
- * Example
- *
- * \code
- * char* src = ...;
- * int srclen = ...; //the length of number of bytes in src
- * char* dest = (char*) malloc(chromium_base64_encode_len(srclen));
- * int len = chromium_base64_encode(dest, src, sourcelen);
- * if (len == MODP_B64_ERROR) {
- *   printf("Error\n");
- * } else {
- *   printf("b64 = %s\n", dest);
- * }
- * \endcode
- *
- */
-size_t chromium_base64_encode(char *dest, const char *str, size_t len);
-
-/**
- * Decode a base64 encoded string
- *
- *
- * src should contain exactly len bytes of b64 characters.
- *     if src contains -any- non-base characters (such as white
- *     space, MODP_B64_ERROR is returned.
- *
- * dest should be allocated by the caller to contain at least
- *    len * 3 / 4 bytes.
- *
- * Returns the length (strlen) of the output, or MODP_B64_ERROR if unable to
- * decode
- *
- * \code
- * char* src = ...;
- * int srclen = ...; // or if you don't know use strlen(src)
- * char* dest = (char*) malloc(chromium_base64_decode_len(srclen));
- * int len = chromium_base64_decode(dest, src, sourcelen);
- * if (len == MODP_B64_ERROR) { error }
- * \endcode
- */
-size_t chromium_base64_decode(char *dest, const char *src, size_t len,
-                              size_t *out_len);
-
-/**
- * Given a source string of length len, this returns the amount of
- * memory the destination string should have.
- *
- * remember, this is integer math
- * 3 bytes turn into 4 chars
- * ceiling[len / 3] * 4 + 1
- *
- * +1 is for any extra null.
- */
-#define chromium_base64_encode_len(A) ((A + 2) / 3 * 4 + 1)
-
-/**
- * Given a base64 string of length len,
- *   this returns the amount of memory required for output string
- *  It maybe be more than the actual number of bytes written.
- * NOTE: remember this is integer math
- * this allocates a bit more memory than traditional versions of b64
- * decode  4 chars turn into 3 bytes
- * floor[len * 3/4] + 2
- */
-#define chromium_base64_decode_len(A) (A / 4 * 3 + 2)
-
-/**
- * Will return the strlen of the output from encoding.
- * This may be less than the required number of bytes allocated.
- *
- * This allows you to 'deserialized' a struct
- * \code
- * char* b64encoded = "...";
- * int len = strlen(b64encoded);
- *
- * struct datastuff foo;
- * if (chromium_base64_encode_strlen(sizeof(struct datastuff)) != len) {
- *    // wrong size
- *    return false;
- * } else {
- *    // safe to do;
- *    if (chromium_base64_encode((char*) &foo, b64encoded, len) ==
- * MODP_B64_ERROR) {
- *      // bad characters
- *      return false;
- *    }
- * }
- * // foo is filled out now
- * \endcode
- */
-#define chromium_base64_encode_strlen(A) ((A + 2) / 3 * 4)
-
-#ifdef __cplusplus
-}
-
-#include <string>
-
-/**
- * base 64 decode a string (self-modifing)
- * On failure, the string is empty.
- *
- * This function is for C++ only (duh)
- *
- * \param[in,out] s the string to be decoded
- * \return a reference to the input string
- */
-inline std::string &chromium_base64_encode(std::string &s) {
-  std::string x(chromium_base64_encode_len(s.size()), '\0');
-  size_t d = chromium_base64_encode(const_cast<char *>(x.data()), s.data(),
-                                    (int)s.size());
-  if (d == MODP_B64_ERROR) {
-    x.clear();
-  } else {
-    x.erase(d, std::string::npos);
-  }
-  s.swap(x);
-  return s;
-}
-
-#endif /* __cplusplus */
-#endif
\ No newline at end of file
diff --git a/src/base64/fastavxbase64.c b/src/base64/fastavxbase64.c
deleted file mode 100644
index 305288fde..000000000
--- a/src/base64/fastavxbase64.c
+++ /dev/null
@@ -1,186 +0,0 @@
-#if defined(__GNUC__) && defined(__x86_64__) && defined(__AVX2__)
-#include "fastavxbase64.h"
-
-#include <stdbool.h>
-#include <x86intrin.h>
-
-/**
- * This code borrows from Wojciech Mula's library at
- * https://github.com/WojciechMula/base64simd (published under BSD)
- * as well as code from Alfred Klomp's library https://github.com/aklomp/base64
- * (published under BSD)
- *
- */
-
-/**
- * Note : Hardware such as Knights Landing might do poorly with this AVX2 code
- * since it relies on shuffles. Alternatives might be faster.
- */
-
-static inline __m256i enc_reshuffle(const __m256i input) {
-
-  // translation from SSE into AVX2 of procedure
-  // https://github.com/WojciechMula/base64simd/blob/master/encode/unpack_bigendian.cpp
-  const __m256i in = _mm256_shuffle_epi8(
-      input,
-      _mm256_set_epi8(10, 11, 9, 10, 7, 8, 6, 7, 4, 5, 3, 4, 1, 2, 0, 1,
-
-                      14, 15, 13, 14, 11, 12, 10, 11, 8, 9, 7, 8, 5, 6, 4, 5));
-
-  const __m256i t0 = _mm256_and_si256(in, _mm256_set1_epi32(0x0fc0fc00));
-  const __m256i t1 = _mm256_mulhi_epu16(t0, _mm256_set1_epi32(0x04000040));
-
-  const __m256i t2 = _mm256_and_si256(in, _mm256_set1_epi32(0x003f03f0));
-  const __m256i t3 = _mm256_mullo_epi16(t2, _mm256_set1_epi32(0x01000010));
-
-  return _mm256_or_si256(t1, t3);
-}
-
-static inline __m256i enc_translate(const __m256i in) {
-  const __m256i lut = _mm256_setr_epi8(
-      65, 71, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -19, -16, 0, 0, 65, 71,
-      -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -19, -16, 0, 0);
-  __m256i indices = _mm256_subs_epu8(in, _mm256_set1_epi8(51));
-  __m256i mask = _mm256_cmpgt_epi8((in), _mm256_set1_epi8(25));
-  indices = _mm256_sub_epi8(indices, mask);
-  __m256i out = _mm256_add_epi8(in, _mm256_shuffle_epi8(lut, indices));
-  return out;
-}
-
-static inline __m256i dec_reshuffle(__m256i in) {
-
-  // inlined procedure pack_madd from
-  // https://github.com/WojciechMula/base64simd/blob/master/decode/pack.avx2.cpp
-  // The only difference is that elements are reversed,
-  // only the multiplication constants were changed.
-
-  const __m256i merge_ab_and_bc = _mm256_maddubs_epi16(
-      in,
-      _mm256_set1_epi32(0x01400140)); //_mm256_maddubs_epi16 is likely expensive
-  __m256i out =
-      _mm256_madd_epi16(merge_ab_and_bc, _mm256_set1_epi32(0x00011000));
-  // end of inlined
-
-  // Pack bytes together within 32-bit words, discarding words 3 and 7:
-  out = _mm256_shuffle_epi8(out, _mm256_setr_epi8(2, 1, 0, 6, 5, 4, 10, 9, 8,
-                                                  14, 13, 12, -1, -1, -1, -1, 2,
-                                                  1, 0, 6, 5, 4, 10, 9, 8, 14,
-                                                  13, 12, -1, -1, -1, -1));
-  // the call to _mm256_permutevar8x32_epi32 could be replaced by a call to
-  // _mm256_storeu2_m128i but it is doubtful that it would help
-  return _mm256_permutevar8x32_epi32(
-      out, _mm256_setr_epi32(0, 1, 2, 4, 5, 6, -1, -1));
-}
-
-size_t fast_avx2_base64_encode(char *dest, const char *str, size_t len) {
-  const char *const dest_orig = dest;
-  if (len >= 32 - 4) {
-    // first load is masked
-    __m256i inputvector = _mm256_maskload_epi32(
-        (int const *)(str - 4),
-        _mm256_set_epi32(0x80000000, 0x80000000, 0x80000000, 0x80000000,
-
-                         0x80000000, 0x80000000, 0x80000000,
-                         0x00000000 // we do not load the first 4 bytes
-                         ));
-    //////////
-    // Intel docs: Faults occur only due to mask-bit required memory accesses
-    // that caused the faults. Faults will not occur due to referencing any
-    // memory location if the corresponding mask bit for
-    // that memory location is 0. For example, no faults will be detected if the
-    // mask bits are all zero.
-    ////////////
-    while (true) {
-      inputvector = enc_reshuffle(inputvector);
-      inputvector = enc_translate(inputvector);
-      _mm256_storeu_si256((__m256i *)dest, inputvector);
-      str += 24;
-      dest += 32;
-      len -= 24;
-      if (len >= 32) {
-        inputvector =
-            _mm256_loadu_si256((__m256i *)(str - 4)); // no need for a mask here
-        // we could do a mask load as long as len >= 24
-      } else {
-        break;
-      }
-    }
-  }
-  size_t scalarret = chromium_base64_encode(dest, str, len);
-  if (scalarret == MODP_B64_ERROR)
-    return MODP_B64_ERROR;
-  return (dest - dest_orig) + scalarret;
-}
-
-size_t fast_avx2_base64_decode(char *out, const char *src, size_t srclen,
-                               size_t *outlen) {
-  char *out_orig = out;
-  while (srclen >= 45) {
-
-    // The input consists of six character sets in the Base64 alphabet,
-    // which we need to map back to the 6-bit values they represent.
-    // There are three ranges, two singles, and then there's the rest.
-    //
-    //  #  From       To        Add  Characters
-    //  1  [43]       [62]      +19  +
-    //  2  [47]       [63]      +16  /
-    //  3  [48..57]   [52..61]   +4  0..9
-    //  4  [65..90]   [0..25]   -65  A..Z
-    //  5  [97..122]  [26..51]  -71  a..z
-    // (6) Everything else => invalid input
-
-    __m256i str = _mm256_loadu_si256((__m256i *)src);
-
-    // code by @aqrit from
-    // https://github.com/WojciechMula/base64simd/issues/3#issuecomment-271137490
-    // transated into AVX2
-    const __m256i lut_lo = _mm256_setr_epi8(
-        0x15, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x13, 0x1A,
-        0x1B, 0x1B, 0x1B, 0x1A, 0x15, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-        0x11, 0x11, 0x13, 0x1A, 0x1B, 0x1B, 0x1B, 0x1A);
-    const __m256i lut_hi = _mm256_setr_epi8(
-        0x10, 0x10, 0x01, 0x02, 0x04, 0x08, 0x04, 0x08, 0x10, 0x10, 0x10, 0x10,
-        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x01, 0x02, 0x04, 0x08, 0x04, 0x08,
-        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10);
-    const __m256i lut_roll = _mm256_setr_epi8(
-        0, 16, 19, 4, -65, -65, -71, -71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 19, 4,
-        -65, -65, -71, -71, 0, 0, 0, 0, 0, 0, 0, 0);
-
-    const __m256i mask_2F = _mm256_set1_epi8(0x2f);
-
-    // lookup
-    __m256i hi_nibbles = _mm256_srli_epi32(str, 4);
-    __m256i lo_nibbles = _mm256_and_si256(str, mask_2F);
-
-    const __m256i lo = _mm256_shuffle_epi8(lut_lo, lo_nibbles);
-    const __m256i eq_2F = _mm256_cmpeq_epi8(str, mask_2F);
-
-    hi_nibbles = _mm256_and_si256(hi_nibbles, mask_2F);
-    const __m256i hi = _mm256_shuffle_epi8(lut_hi, hi_nibbles);
-    const __m256i roll =
-        _mm256_shuffle_epi8(lut_roll, _mm256_add_epi8(eq_2F, hi_nibbles));
-
-    if (!_mm256_testz_si256(lo, hi)) {
-      break;
-    }
-
-    str = _mm256_add_epi8(str, roll);
-    // end of copied function
-
-    srclen -= 32;
-    src += 32;
-
-    // end of inlined function
-
-    // Reshuffle the input to packed 12-byte output format:
-    str = dec_reshuffle(str);
-    _mm256_storeu_si256((__m256i *)out, str);
-    out += 24;
-  }
-  size_t scalarret = chromium_base64_decode(out, src, srclen, outlen);
-  *outlen += (out - out_orig);
-  if (scalarret == MODP_B64_ERROR)
-    return MODP_B64_ERROR;
-  return (out - out_orig) + scalarret;
-}
-#endif
\ No newline at end of file
diff --git a/src/base64/fastavxbase64.h b/src/base64/fastavxbase64.h
deleted file mode 100644
index 80f097ae8..000000000
--- a/src/base64/fastavxbase64.h
+++ /dev/null
@@ -1,42 +0,0 @@
-
-#if defined(__GNUC__) && defined(__x86_64__) && defined(__AVX2__)
-
-#ifndef EXPAVX_B64
-#define EXPAVX_B64
-
-/**
- * Assumes recent x64 hardware with AVX2 instructions.
- */
-
-#include "chromiumbase64.h"
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-/**
- * This code extends Nick Galbreath's high performance base 64decoder (used in
- * Chromium), the API is the same effectively, see chromium64.h.
- */
-
-/*
- * AVX2 accelerated version of Galbreath's chromium_base64_decode function
- * Usage remains the same, see chromium.h.
- */
-size_t fast_avx2_base64_decode(char *out, const char *src, size_t srclen,
-                               size_t *outlen);
-
-/*
- * AVX2 accelerated version of Galbreath's chromium_base64_encode function
- * Usage remains the same, see chromium.h.
- */
-size_t fast_avx2_base64_encode(char *dest, const char *str, size_t len);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif
-#endif
\ No newline at end of file
diff --git a/src/base64/neonbase64.cc b/src/base64/neonbase64.cc
deleted file mode 100644
index deaf7ac38..000000000
--- a/src/base64/neonbase64.cc
+++ /dev/null
@@ -1,120 +0,0 @@
-// clang-format off
-#if defined (__GNUC__) && defined(__ARM_NEON__)
-
-#include <arm_neon.h>
-#include <cstddef>
-#include "chromiumbase64.h"
-#define MODP_B64_ERROR ((size_t)-1)
-
-// #include <iostream>
-
-
-extern "C" int neon_base64_decode(char *out, const char *src, size_t srclen, size_t *outlen);
-
-
-// The input consists of six character sets in the Base64 alphabet,
-// which we need to map back to the 6-bit values they represent.
-// There are three ranges, two singles, and then there's the rest.
-//
-//  #  From       To        Add  Characters
-//  1  [43]       [62]      +19  +
-//  2  [47]       [63]      +16  /
-//  3  [48..57]   [52..61]   +4  0..9
-//  4  [65..90]   [0..25]   -65  A..Z
-//  5  [97..122]  [26..51]  -71  a..z
-// (6) Everything else => invalid input
-
-int neon_base64_decode(char *out, const char *src, size_t srclen, size_t *outlen) {
-  char *out_orig = out;
-  const uint8x16_t lut_lo = {0x15, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-                             0x11, 0x11, 0x13, 0x1A, 0x1B, 0x1B, 0x1B, 0x1A};
-  const uint8x16_t lut_hi = {0x10, 0x10, 0x01, 0x02, 0x04, 0x08, 0x04, 0x08,
-                             0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10};
-  const uint8x16_t lut_roll = {0, 16, 19, 4, 191, 191, 185, 185,
-                               0, 0,  0,  0, 0,   0,   0,   0};
-  const uint8x16_t zero8 = vdupq_n_u8(0);
-  const uint16x8_t zero16 = vdupq_n_u16(0);
-  const uint8x16_t k2f = vdupq_n_u8(0x2f);
-  const uint8x16_t kf = vdupq_n_u8(0xf);
-  const uint8x8_t cst = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40};
-  const uint16x4_t cst1 = {0x1000, 0x1000, 0x1000, 0x1000};
-
-  const uint8x8_t shuf0 = {2, 1, 0, 6, 5, 4, 2 + 8, 1 + 8};
-  const uint8x8_t shuf1 = {0 + 8,  6 + 8,  5 + 8,  4 + 8,
-                           2 + 16, 1 + 16, 0 + 16, 6 + 16};
-  const uint8x8_t shuf2 = {5 + 16, 4 + 16, 2 + 24, 1 + 24,
-                           0 + 24, 6 + 24, 5 + 24, 4 + 24};
-
-  uint8x8x4_t pack;
-  uint8x8_t res[3];
-  uint8x16_t str[2];
-
-  while (srclen >= 8 * 4) {
-    __builtin_memcpy(str, src, 8 * 4);
-
-    uint8x16_t in0 = str[0];
-    uint8x16_t in1 = str[1];
-    uint8x16_t lo_nibbles0 = vandq_u8(in0, kf);
-    uint8x16_t lo_nibbles1 = vandq_u8(in1, kf);
-    uint8x16_t hi_nibbles0 = vshrq_n_u8(in0, 4);
-    uint8x16_t hi_nibbles1 = vshrq_n_u8(in1, 4);
-
-    uint8x16_t lo0 = vqtbl1q_u8(lut_lo, lo_nibbles0);
-    uint8x16_t lo1 = vqtbl1q_u8(lut_lo, lo_nibbles1);
-    uint8x16_t hi0 = vqtbl1q_u8(lut_hi, hi_nibbles0);
-    uint8x16_t hi1 = vqtbl1q_u8(lut_hi, hi_nibbles1);
-    uint8x16_t test0 = vtstq_u8(lo0, hi0);
-    uint8x16_t test1 = vtstq_u8(lo1, hi1);
-    uint8x16_t orr0 = vorrq_u8(test0, test1);
-    uint8x8_t orr1 = vorr_u8(vget_low_u8(orr0), vget_high_u8(orr0));
-    if ((uint64_t)orr1)
-      break;
-
-    uint8x16_t eq_2F0 = vceqq_u8(in0, k2f);
-    uint8x16_t eq_2F1 = vceqq_u8(in1, k2f);
-    uint8x16_t add0 = vaddq_u8(eq_2F0, hi_nibbles0);
-    uint8x16_t add1 = vaddq_u8(eq_2F1, hi_nibbles1);
-    uint8x16_t roll0 = vqtbl1q_u8(lut_roll, add0);
-    uint8x16_t roll1 = vqtbl1q_u8(lut_roll, add1);
-    uint8x16_t rolled0 = vaddq_u8(in0, roll0);
-    uint8x16_t rolled1 = vaddq_u8(in1, roll1);
-
-    // Step 1: swap and merge adjacent 6-bit fields.
-    uint8x16x2_t unzip8 = vuzpq_u8(rolled0, rolled1);
-    uint8x16x2_t zip8 = vzipq_u8(unzip8.val[1], zero8);
-    uint16x8_t mul0 = vmlal_u8(vreinterpretq_u16_u8(zip8.val[0]),
-                               vget_low_u8(unzip8.val[0]), cst);
-    uint16x8_t mul1 = vmlal_u8(vreinterpretq_u16_u8(zip8.val[1]),
-                               vget_high_u8(unzip8.val[0]), cst);
-
-    // Step 2: swap and merge 12-bit words into a 24-bit word.
-    uint16x8x2_t unzip16 = vuzpq_u16(mul0, mul1);
-    uint16x8x2_t zip16 = vzipq_u16(unzip16.val[1], zero16);
-    uint32x4_t merge0 = vmlal_u16(vreinterpretq_u32_u16(zip16.val[0]),
-                                  vget_low_u16(unzip16.val[0]), cst1);
-    uint32x4_t merge1 = vmlal_u16(vreinterpretq_u32_u16(zip16.val[1]),
-                                  vget_high_u16(unzip16.val[0]), cst1);
-    pack.val[0] = vget_low_u8(vreinterpretq_u8_u32(merge0));
-    pack.val[1] = vget_high_u8(vreinterpretq_u8_u32(merge0));
-    pack.val[2] = vget_low_u8(vreinterpretq_u8_u32(merge1));
-    pack.val[3] = vget_high_u8(vreinterpretq_u8_u32(merge1));
-
-    res[0] = vtbl4_u8(pack, shuf0);
-    res[1] = vtbl4_u8(pack, shuf1);
-    res[2] = vtbl4_u8(pack, shuf2);
-    __builtin_memcpy(out, res, 6 * 4);
-
-    out += 6 * 4;
-    srclen -= 8 * 4;
-    src += 8 * 4;
-  }
-
-//   std::cout << "Chromium? " << (out - out_orig) << std::endl;
-  size_t scalarret = chromium_base64_decode(out, src, srclen, outlen);
-  *outlen += (out - out_orig);
-  if (scalarret == MODP_B64_ERROR)
-    return (int)MODP_B64_ERROR;
-  return (out - out_orig) + scalarret;
-}
-
-#endif
\ No newline at end of file
diff --git a/src/bun.js/webcore/encoding.zig b/src/bun.js/webcore/encoding.zig
index 1909727d0..99b304bda 100644
--- a/src/bun.js/webcore/encoding.zig
+++ b/src/bun.js/webcore/encoding.zig
@@ -980,21 +980,12 @@ pub const Encoder = struct {
                     slice = slice[0 .. slice.len - 1];
                 }
 
-                const wrote = bun.base64.urlsafe.decode(to[0..to_len], slice) catch |err| brk: {
-                    if (err == error.NoSpaceLeft) {
-                        break :brk to_len;
-                    }
-
-                    return -1;
-                };
+                const wrote = bun.base64.decodeURLSafe(to[0..to_len], slice).written;
                 return @intCast(i64, wrote);
             },
 
             JSC.Node.Encoding.base64 => {
-                var slice = strings.trim(input[0..len], "\r\n\t " ++ [_]u8{std.ascii.control_code.VT});
-                var outlen = bun.base64.decodeLen(slice);
-
-                return @intCast(i64, bun.base64.decode(to[0..outlen], slice).written);
+                return @intCast(i64, bun.base64.decode(to[0..to_len], input[0..len]).written);
             },
             // else => return 0,
         }
@@ -1140,14 +1131,7 @@ pub const Encoder = struct {
 
                 const to_len = bun.base64.urlsafe.decoder.calcSizeForSlice(slice) catch unreachable;
                 var to = allocator.alloc(u8, to_len) catch return &[_]u8{};
-
-                const wrote = bun.base64.urlsafe.decode(to[0..to_len], slice) catch |err| brk: {
-                    if (err == error.NoSpaceLeft) {
-                        break :brk to_len;
-                    }
-
-                    return &[_]u8{};
-                };
+                const wrote = bun.base64.decodeURLSafe(to[0..to_len], slice).written;
                 return to[0..wrote];
             },
 
@@ -1195,7 +1179,6 @@ pub const Encoder = struct {
             },
 
             JSC.Node.Encoding.base64 => {
-
                 // very very slow case!
                 // shouldn't really happen though
                 var transcoded = strings.toUTF8Alloc(allocator, input[0..len]) catch return &[_]u8{};
diff --git a/test/bun.js/buffer.test.js b/test/bun.js/buffer.test.js
index 23d94abd5..4433cf64f 100644
--- a/test/bun.js/buffer.test.js
+++ b/test/bun.js/buffer.test.js
@@ -590,3 +590,25 @@ for (let fn of [Buffer.prototype.slice, Buffer.prototype.subarray]) {
     expect(slice3.toString()).toBe("f");
   });
 }
+
+it("Buffer.from(base64)", () => {
+  const buf = Buffer.from("aGVsbG8gd29ybGQ=", "base64");
+  expect(buf.toString()).toBe("hello world");
+
+  expect(
+    Buffer.from(btoa('console.log("hello world")\n'), "base64").toString()
+  ).toBe('console.log("hello world")\n');
+});
+
+it("Buffer.toString(base64)", () => {
+  {
+    const buf = Buffer.from("hello world");
+    expect(buf.toString("base64")).toBe("aGVsbG8gd29ybGQ=");
+  }
+
+  {
+    expect(Buffer.from(`console.log("hello world")\n`).toString("base64")).toBe(
+      btoa('console.log("hello world")\n')
+    );
+  }
+});