[internal] Make string comparisons faster

25 files changed, 150 insertions, 256 deletions

diff --git a/src/bun.js/rare_data.zig b/src/bun.js/rare_data.zig
index bb52e5bea..26869c19d 100644
--- a/src/bun.js/rare_data.zig
+++ b/src/bun.js/rare_data.zig
@@ -167,6 +167,7 @@ pub fn stderr(rare: *RareData) *Blob.Store {
                 },
             },
         };
+
         rare.stderr_store = store;
         break :brk store;
     };
diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig
index e9c075074..eccab6fd0 100644
--- a/src/bun.js/webcore/streams.zig
+++ b/src/bun.js/webcore/streams.zig
@@ -257,7 +257,7 @@ pub const ReadableStream = struct {
         };
         switch (store.data) {
             .bytes => {
-                var reader = bun.default_allocator.create(ByteBlobLoader.Source) catch unreachable;
+                var reader = globalThis.allocator().create(ByteBlobLoader.Source) catch unreachable;
                 reader.* = .{
                     .globalThis = globalThis,
                     .context = undefined,
@@ -266,7 +266,7 @@ pub const ReadableStream = struct {
                 return reader.toJS(globalThis);
             },
             .file => {
-                var reader = bun.default_allocator.create(FileReader.Source) catch unreachable;
+                var reader = globalThis.allocator().create(FileReader.Source) catch unreachable;
                 reader.* = .{
                     .globalThis = globalThis,
                     .context = .{
@@ -287,7 +287,7 @@ pub const ReadableStream = struct {
         buffered_data: bun.ByteList,
     ) JSC.JSValue {
         JSC.markBinding(@src());
-        var reader = bun.default_allocator.create(FileReader.Source) catch unreachable;
+        var reader = globalThis.allocator().create(FileReader.Source) catch unreachable;
         reader.* = .{
             .globalThis = globalThis,
             .context = .{
diff --git a/src/bun.zig b/src/bun.zig
index 13137eab6..92b8ff2b3 100644
--- a/src/bun.zig
+++ b/src/bun.zig
@@ -506,3 +506,38 @@ pub fn getenvZ(path_: [:0]const u8) ?[]const u8 {
     const ptr = std.c.getenv(path_.ptr) orelse return null;
     return span(ptr);
 }
+
+// These wrappers exist to use our strings.eqlLong function
+pub const StringArrayHashMapContext = struct {
+    pub fn hash(_: @This(), s: []const u8) u32 {
+        return @truncate(u32, std.hash.Wyhash.hash(0, s));
+    }
+    pub fn eql(_: @This(), a: []const u8, b: []const u8, _: usize) bool {
+        return strings.eqlLong(a, b, true);
+    }
+};
+
+pub const StringHashMapContext = struct {
+    pub fn hash(_: @This(), s: []const u8) u64 {
+        return std.hash.Wyhash.hash(0, s);
+    }
+    pub fn eql(_: @This(), a: []const u8, b: []const u8) bool {
+        return strings.eqlLong(a, b, true);
+    }
+};
+
+pub fn StringArrayHashMap(comptime Type: type) type {
+    return std.ArrayHashMap([]const u8, Type, StringArrayHashMapContext, true);
+}
+
+pub fn StringArrayHashMapUnmanaged(comptime Type: type) type {
+    return std.ArrayHashMapUnmanaged([]const u8, Type, StringArrayHashMapContext, true);
+}
+
+pub fn StringHashMap(comptime Type: type) type {
+    return std.HashMap([]const u8, Type, StringHashMapContext, std.hash_map.default_max_load_percentage);
+}
+
+pub fn StringHashMapUnmanaged(comptime Type: type) type {
+    return std.HashMapUnmanaged([]const u8, Type, StringHashMapContext, std.hash_map.default_max_load_percentage);
+}
diff --git a/src/bunfig.zig b/src/bunfig.zig
index f29533a7e..f840c7c58 100644
--- a/src/bunfig.zig
+++ b/src/bunfig.zig
@@ -20,10 +20,10 @@ const Api = @import("./api/schema.zig").Api;
 const Npm = @import("./install/npm.zig");
 const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
 const resolver = @import("./resolver/resolver.zig");
-pub const MacroImportReplacementMap = std.StringArrayHashMap(string);
-pub const MacroMap = std.StringArrayHashMapUnmanaged(MacroImportReplacementMap);
-pub const BundlePackageOverride = std.StringArrayHashMapUnmanaged(options.BundleOverride);
-const LoaderMap = std.StringArrayHashMapUnmanaged(options.Loader);
+pub const MacroImportReplacementMap = bun.StringArrayHashMap(string);
+pub const MacroMap = bun.StringArrayHashMapUnmanaged(MacroImportReplacementMap);
+pub const BundlePackageOverride = bun.StringArrayHashMapUnmanaged(options.BundleOverride);
+const LoaderMap = bun.StringArrayHashMapUnmanaged(options.Loader);
 const Analytics = @import("./analytics.zig");
 const JSONParser = @import("./json_parser.zig");
 const Command = @import("cli.zig").Command;
diff --git a/src/c.zig b/src/c.zig
index 56b27fdf7..1e4aca52c 100644
--- a/src/c.zig
+++ b/src/c.zig
@@ -396,3 +396,5 @@ pub fn getRelease(buf: []u8) []const u8 {
         return "unknown";
     }
 }
+
+pub extern fn memmem(haystack: [*]const u8, haystacklen: usize, needle: [*]const u8, needlelen: usize) ?[*]const u8;
diff --git a/src/cli.zig b/src/cli.zig
index 10117721e..2a9b31091 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -819,7 +819,7 @@ pub const Command = struct {
         // technical debt
         macros: ?MacroMap = null,
         editor: string = "",
-        package_bundle_map: std.StringArrayHashMapUnmanaged(options.BundlePackage) = std.StringArrayHashMapUnmanaged(options.BundlePackage){},
+        package_bundle_map: bun.StringArrayHashMapUnmanaged(options.BundlePackage) = bun.StringArrayHashMapUnmanaged(options.BundlePackage){},
     };
 
     pub const Context = struct {
diff --git a/src/cli/create_command.zig b/src/cli/create_command.zig
index fe4de3adc..c500b8200 100644
--- a/src/cli/create_command.zig
+++ b/src/cli/create_command.zig
@@ -493,7 +493,7 @@ pub const CreateCommand = struct {
                 var archive_context = Archive.Context{
                     .pluckers = pluckers[0..@intCast(usize, @boolToInt(!create_options.skip_package_json))],
                     .all_files = undefined,
-                    .overwrite_list = std.StringArrayHashMap(void).init(ctx.allocator),
+                    .overwrite_list = bun.StringArrayHashMap(void).init(ctx.allocator),
                 };
 
                 if (!create_options.overwrite) {
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
index 80002dbe4..d99b361a4 100644
--- a/src/cli/run_command.zig
+++ b/src/cli/run_command.zig
@@ -557,7 +557,7 @@ pub const RunCommand = struct {
             }
         }
 
-        const ResultList = std.StringArrayHashMap(void);
+        const ResultList = bun.StringArrayHashMap(void);
 
         if (this_bundler.env.map.get("SHELL")) |shell| {
             shell_out.shell = ShellCompletions.Shell.fromEnv(@TypeOf(shell), shell);
diff --git a/src/defines.zig b/src/defines.zig
index 978b81df3..560171468 100644
--- a/src/defines.zig
+++ b/src/defines.zig
@@ -33,9 +33,9 @@ const Globals = struct {
 };
 
 const defines_path = fs.Path.initWithNamespace("defines.json", "internal");
-pub const RawDefines = std.StringArrayHashMap(string);
-pub const UserDefines = std.StringHashMap(DefineData);
-pub const UserDefinesArray = std.StringArrayHashMap(DefineData);
+pub const RawDefines = bun.StringArrayHashMap(string);
+pub const UserDefines = bun.StringHashMap(DefineData);
+pub const UserDefinesArray = bun.StringArrayHashMap(DefineData);
 
 const Rewrites = struct {
     pub const global = "global";
@@ -197,8 +197,8 @@ var nan_val = js_ast.E.Number{ .value = std.math.nan_f64 };
 var inf_val = js_ast.E.Number{ .value = std.math.inf_f64 };
 
 pub const Define = struct {
-    identifiers: std.StringHashMap(IdentifierDefine),
-    dots: std.StringHashMap([]DotDefine),
+    identifiers: bun.StringHashMap(IdentifierDefine),
+    dots: bun.StringHashMap([]DotDefine),
     allocator: std.mem.Allocator,
 
     pub fn insertFromIterator(define: *Define, allocator: std.mem.Allocator, comptime Iterator: type, iter: Iterator) !void {
@@ -258,8 +258,8 @@ pub const Define = struct {
     pub fn init(allocator: std.mem.Allocator, _user_defines: ?UserDefines, string_defines: ?UserDefinesArray) !*@This() {
         var define = try allocator.create(Define);
         define.allocator = allocator;
-        define.identifiers = std.StringHashMap(IdentifierDefine).init(allocator);
-        define.dots = std.StringHashMap([]DotDefine).init(allocator);
+        define.identifiers = bun.StringHashMap(IdentifierDefine).init(allocator);
+        define.dots = bun.StringHashMap([]DotDefine).init(allocator);
         try define.identifiers.ensureTotalCapacity(641 + 2 + 1);
         try define.dots.ensureTotalCapacity(64);
 
diff --git a/src/env_loader.zig b/src/env_loader.zig
index f8c453790..222d98910 100644
--- a/src/env_loader.zig
+++ b/src/env_loader.zig
@@ -845,7 +845,7 @@ pub const Parser = struct {
 };
 
 pub const Map = struct {
-    const HashTable = std.StringArrayHashMap(string);
+    const HashTable = bun.StringArrayHashMap(string);
 
     map: HashTable,
 
@@ -1077,7 +1077,7 @@ test "DotEnv Process" {
 }
 
 test "DotEnv Loader - copyForDefine" {
-    const UserDefine = std.StringArrayHashMap(string);
+    const UserDefine = bun.StringArrayHashMap(string);
     const UserDefinesArray = @import("./defines.zig").UserDefinesArray;
     var map = Map.init(default_allocator);
     var loader = Loader.init(&map, default_allocator);
diff --git a/src/fs.zig b/src/fs.zig
index b9dc4d13a..645845e79 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -190,7 +190,7 @@ pub const FileSystem = struct {
     }
 
     pub const DirEntry = struct {
-        pub const EntryMap = std.StringHashMapUnmanaged(*Entry);
+        pub const EntryMap = bun.StringHashMapUnmanaged(*Entry);
         pub const EntryStore = allocators.BSSList(Entry, Preallocate.Counts.files);
         dir: string,
         fd: StoredFileDescriptorType = 0,
diff --git a/src/hash_map.zig b/src/hash_map.zig
index 58171eae0..c16dad553 100644
--- a/src/hash_map.zig
+++ b/src/hash_map.zig
@@ -22,7 +22,7 @@ pub fn getAutoHashFn(comptime K: type) (fn (K) u64) {
             @compileError("std.auto_hash.autoHash does not allow slices here (" ++
                 @typeName(K) ++
                 ") because the intent is unclear. " ++
-                "Consider using std.StringHashMap for hashing the contents of []const u8. " ++
+                "Consider using bun.StringHashMap for hashing the contents of []const u8. " ++
                 "Alternatively, consider using std.auto_hash.hash or providing your own hash function instead.");
         }
     }
diff --git a/src/http_client_async.zig b/src/http_client_async.zig
index b946c3aa6..37f4c7c34 100644
--- a/src/http_client_async.zig
+++ b/src/http_client_async.zig
@@ -2082,177 +2082,3 @@ pub fn handleResponseMetadata(
 
     return this.method.hasBody() and (this.state.body_size > 0 or this.state.transfer_encoding == .chunked);
 }
-
-// // zig test src/http_client.zig --test-filter "sendHTTP - only" -lc -lc++ /Users/jarred/Code/bun/src/deps/zlib/libz.a /Users/jarred/Code/bun/src/deps/picohttpparser.o --cache-dir /Users/jarred/Code/bun/zig-cache --global-cache-dir /Users/jarred/.cache/zig --name bun --pkg-begin clap /Users/jarred/Code/bun/src/deps/zig-clap/clap.zig --pkg-end --pkg-begin picohttp /Users/jarred/Code/bun/src/deps/picohttp.zig --pkg-end --pkg-begin iguanaTLS /Users/jarred/Code/bun/src/deps/iguanaTLS/src/main.zig --pkg-end -I /Users/jarred/Code/bun/src/deps -I /Users/jarred/Code/bun/src/deps/mimalloc -I /usr/local/opt/icu4c/include  -L src/deps/mimalloc -L /usr/local/opt/icu4c/lib --main-pkg-path /Users/jarred/Code/bun --enable-cache -femit-bin=zig-out/bin/test --test-no-exec
-// test "sendHTTP - only" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     // headers.appendHeader("X-What", "ok", true, true, false);
-//     headers.appendHeader("Accept-Encoding", "identity", true, true, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("http://example.com/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.sendHTTP("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqual(body_out_str.list.items.len, 1256);
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
-
-// // zig test src/http_client.zig --test-filter "sendHTTP - gzip" -lc -lc++ /Users/jarred/Code/bun/src/deps/zlib/libz.a /Users/jarred/Code/bun/src/deps/picohttpparser.o --cache-dir /Users/jarred/Code/bun/zig-cache --global-cache-dir /Users/jarred/.cache/zig --name bun --pkg-begin clap /Users/jarred/Code/bun/src/deps/zig-clap/clap.zig --pkg-end --pkg-begin picohttp /Users/jarred/Code/bun/src/deps/picohttp.zig --pkg-end --pkg-begin iguanaTLS /Users/jarred/Code/bun/src/deps/iguanaTLS/src/main.zig --pkg-end -I /Users/jarred/Code/bun/src/deps -I /Users/jarred/Code/bun/src/deps/mimalloc -I /usr/local/opt/icu4c/include  -L src/deps/mimalloc -L /usr/local/opt/icu4c/lib --main-pkg-path /Users/jarred/Code/bun --enable-cache -femit-bin=zig-out/bin/test --test-no-exec
-// test "sendHTTP - gzip" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     // headers.appendHeader("X-What", "ok", true, true, false);
-//     headers.appendHeader("Accept-Encoding", "gzip", true, true, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("http://example.com/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.sendHTTP("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
-
-// // zig test src/http_client.zig --test-filter "sendHTTPS - identity" -lc -lc++ /Users/jarred/Code/bun/src/deps/zlib/libz.a /Users/jarred/Code/bun/src/deps/picohttpparser.o --cache-dir /Users/jarred/Code/bun/zig-cache --global-cache-dir /Users/jarred/.cache/zig --name bun --pkg-begin clap /Users/jarred/Code/bun/src/deps/zig-clap/clap.zig --pkg-end --pkg-begin picohttp /Users/jarred/Code/bun/src/deps/picohttp.zig --pkg-end --pkg-begin iguanaTLS /Users/jarred/Code/bun/src/deps/iguanaTLS/src/main.zig --pkg-end -I /Users/jarred/Code/bun/src/deps -I /Users/jarred/Code/bun/src/deps/mimalloc -I /usr/local/opt/icu4c/include  -L src/deps/mimalloc -L /usr/local/opt/icu4c/lib --main-pkg-path /Users/jarred/Code/bun --enable-cache -femit-bin=zig-out/bin/test --test-no-exec
-// test "sendHTTPS - identity" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     headers.appendHeader("X-What", "ok", true, true, false);
-//     headers.appendHeader("Accept-Encoding", "identity", true, true, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("https://example.com/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.sendHTTPS("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
-
-// test "sendHTTPS - gzip" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     headers.appendHeader("Accept-Encoding", "gzip", false, false, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("https://example.com/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.sendHTTPS("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
-
-// // zig test src/http_client.zig --test-filter "sendHTTPS - deflate" -lc -lc++ /Users/jarred/Code/bun/src/deps/zlib/libz.a /Users/jarred/Code/bun/src/deps/picohttpparser.o --cache-dir /Users/jarred/Code/bun/zig-cache --global-cache-dir /Users/jarred/.cache/zig --name bun --pkg-begin clap /Users/jarred/Code/bun/src/deps/zig-clap/clap.zig --pkg-end --pkg-begin picohttp /Users/jarred/Code/bun/src/deps/picohttp.zig --pkg-end --pkg-begin iguanaTLS /Users/jarred/Code/bun/src/deps/iguanaTLS/src/main.zig --pkg-end -I /Users/jarred/Code/bun/src/deps -I /Users/jarred/Code/bun/src/deps/mimalloc -I /usr/local/opt/icu4c/include  -L src/deps/mimalloc -L /usr/local/opt/icu4c/lib --main-pkg-path /Users/jarred/Code/bun --enable-cache -femit-bin=zig-out/bin/test
-// test "sendHTTPS - deflate" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     headers.appendHeader("Accept-Encoding", "deflate", false, false, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("https://example.com/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.sendHTTPS("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
-
-// // zig test src/http_client.zig --test-filter "sendHTTP" -lc -lc++ /Users/jarred/Code/bun/src/deps/zlib/libz.a /Users/jarred/Code/bun/src/deps/picohttpparser.o --cache-dir /Users/jarred/Code/bun/zig-cache --global-cache-dir /Users/jarred/.cache/zig --name bun --pkg-begin clap /Users/jarred/Code/bun/src/deps/zig-clap/clap.zig --pkg-end --pkg-begin picohttp /Users/jarred/Code/bun/src/deps/picohttp.zig --pkg-end --pkg-begin iguanaTLS /Users/jarred/Code/bun/src/deps/iguanaTLS/src/main.zig --pkg-end -I /Users/jarred/Code/bun/src/deps -I /Users/jarred/Code/bun/src/deps/mimalloc -I /usr/local/opt/icu4c/include  -L src/deps/mimalloc -L /usr/local/opt/icu4c/lib --main-pkg-path /Users/jarred/Code/bun --enable-cache -femit-bin=zig-out/bin/test
-
-// test "send - redirect" {
-//     Output.initTest();
-//     defer Output.flush();
-
-//     var headers = try std.heap.c_allocator.create(Headers);
-//     headers.* = Headers{
-//         .entries = @TypeOf(headers.entries){},
-//         .buf = @TypeOf(headers.buf){},
-//         .used = 0,
-//         .allocator = std.heap.c_allocator,
-//     };
-
-//     headers.appendHeader("Accept-Encoding", "gzip", false, false, false);
-
-//     var client = HTTPClient.init(
-//         std.heap.c_allocator,
-//         .GET,
-//         URL.parse("https://www.bun.sh/"),
-//         headers.entries,
-//         headers.buf.items,
-//     );
-//     try std.testing.expectEqualStrings(client.url.hostname, "www.bun.sh");
-//     var body_out_str = try MutableString.init(std.heap.c_allocator, 0);
-//     var response = try client.send("", &body_out_str);
-//     try std.testing.expectEqual(response.status_code, 200);
-//     try std.testing.expectEqual(client.url.hostname, "bun.sh");
-//     try std.testing.expectEqualStrings(body_out_str.list.items, @embedFile("fixtures_example.com.html"));
-// }
diff --git a/src/js_ast.zig b/src/js_ast.zig
index 986a7c753..6e017849e 100644
--- a/src/js_ast.zig
+++ b/src/js_ast.zig
@@ -4433,7 +4433,7 @@ pub const Ast = struct {
     export_star_import_records: []u32 = &([_]u32{}),
 
     pub const NamedImports = std.ArrayHashMap(Ref, NamedImport, RefHashCtx, true);
-    pub const NamedExports = std.StringArrayHashMap(NamedExport);
+    pub const NamedExports = bun.StringArrayHashMap(NamedExport);
 
     pub fn initTest(parts: []Part) Ast {
         return Ast{
diff --git a/src/js_parser.zig b/src/js_parser.zig
index decc92029..e3c0ef1d7 100644
--- a/src/js_parser.zig
+++ b/src/js_parser.zig
@@ -1941,7 +1941,7 @@ const StmtList = ListManaged(Stmt);
 
 const StringVoidMap = struct {
     allocator: Allocator,
-    map: std.StringHashMapUnmanaged(void) = std.StringHashMapUnmanaged(void){},
+    map: bun.StringHashMapUnmanaged(void) = bun.StringHashMapUnmanaged(void){},
 
     /// Returns true if the map already contained the given key.
     pub fn getOrPutContains(this: *StringVoidMap, key: string) bool {
@@ -1975,7 +1975,7 @@ const StringVoidMap = struct {
 };
 const RefCtx = @import("./ast/base.zig").RefCtx;
 const SymbolUseMap = std.HashMapUnmanaged(Ref, js_ast.Symbol.Use, RefCtx, 80);
-const StringBoolMap = std.StringHashMapUnmanaged(bool);
+const StringBoolMap = bun.StringHashMapUnmanaged(bool);
 const RefMap = std.HashMapUnmanaged(Ref, void, RefCtx, 80);
 const RefArrayMap = std.ArrayHashMapUnmanaged(Ref, void, @import("./ast/base.zig").RefHashCtx, false);
 
@@ -2150,7 +2150,7 @@ const PropertyOpts = struct {
 pub const ScanPassResult = struct {
     pub const ParsePassSymbolUse = struct { ref: Ref, used: bool = false, import_record_index: u32 };
     pub const NamespaceCounter = struct { count: u16, import_record_index: u32 };
-    pub const ParsePassSymbolUsageMap = std.StringArrayHashMap(ParsePassSymbolUse);
+    pub const ParsePassSymbolUsageMap = bun.StringArrayHashMap(ParsePassSymbolUse);
     import_records: ListManaged(ImportRecord),
     named_imports: js_ast.Ast.NamedImports,
     used_symbols: ParsePassSymbolUsageMap,
@@ -3877,7 +3877,7 @@ const ParserFeatures = struct {
 // Instead of creating a globally-scoped
 const FastRefresh = struct {};
 
-const ImportItemForNamespaceMap = std.StringArrayHashMap(LocRef);
+const ImportItemForNamespaceMap = bun.StringArrayHashMap(LocRef);
 
 pub const MacroState = struct {
     refs: MacroRefs,
diff --git a/src/libarchive/libarchive.zig b/src/libarchive/libarchive.zig
index d53aec0d4..e10d58660 100644
--- a/src/libarchive/libarchive.zig
+++ b/src/libarchive/libarchive.zig
@@ -357,7 +357,7 @@ pub const Archive = struct {
 
     pub const Context = struct {
         pluckers: []Plucker = &[_]Plucker{},
-        overwrite_list: std.StringArrayHashMap(void),
+        overwrite_list: bun.StringArrayHashMap(void),
         all_files: EntryMap,
         pub const EntryMap = std.ArrayHashMap(u64, [*c]u8, U64Context, false);
 
diff --git a/src/node_module_bundle.zig b/src/node_module_bundle.zig
index 5f9a38afd..ccf7877e7 100644
--- a/src/node_module_bundle.zig
+++ b/src/node_module_bundle.zig
@@ -26,7 +26,7 @@ pub const BundledPackageID = u32;
 
 const PackageIDMap = std.AutoHashMap(BundledPackageHash, BundledPackageID);
 
-const PackageNameMap = std.StringHashMap([]BundledPackageID);
+const PackageNameMap = bun.StringHashMap([]BundledPackageID);
 
 pub const AllocatedString = struct {
     str: string,
diff --git a/src/options.zig b/src/options.zig
index 2604f2ff4..4f62ddfe5 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -355,7 +355,7 @@ pub const BundlePackage = enum {
     always,
     never,
 
-    pub const Map = std.StringArrayHashMapUnmanaged(BundlePackage);
+    pub const Map = bun.StringArrayHashMapUnmanaged(BundlePackage);
 };
 
 pub const ModuleType = enum {
@@ -478,8 +478,8 @@ pub const Platform = enum {
         };
     };
 
-    pub fn outExtensions(platform: Platform, allocator: std.mem.Allocator) std.StringHashMap(string) {
-        var exts = std.StringHashMap(string).init(allocator);
+    pub fn outExtensions(platform: Platform, allocator: std.mem.Allocator) bun.StringHashMap(string) {
+        var exts = bun.StringHashMap(string).init(allocator);
 
         const js = Extensions.Out.JavaScript[0];
         const mjs = Extensions.Out.JavaScript[1];
@@ -1083,7 +1083,7 @@ const default_loader_ext = [_]string{
     ".toml", ".wasm",
 };
 
-pub fn loadersFromTransformOptions(allocator: std.mem.Allocator, _loaders: ?Api.LoaderMap, platform: Platform) !std.StringArrayHashMap(Loader) {
+pub fn loadersFromTransformOptions(allocator: std.mem.Allocator, _loaders: ?Api.LoaderMap, platform: Platform) !bun.StringArrayHashMap(Loader) {
     var input_loaders = _loaders orelse std.mem.zeroes(Api.LoaderMap);
     var loader_values = try allocator.alloc(Loader, input_loaders.loaders.len);
 
@@ -1123,7 +1123,7 @@ pub fn loadersFromTransformOptions(allocator: std.mem.Allocator, _loaders: ?Api.
     }
 
     var loaders = try stringHashMapFromArrays(
-        std.StringArrayHashMap(Loader),
+        bun.StringArrayHashMap(Loader),
         allocator,
         input_loaders.extensions,
         loader_values,
@@ -1178,7 +1178,7 @@ pub const BundleOptions = struct {
     footer: string = "",
     banner: string = "",
     define: *defines.Define,
-    loaders: std.StringArrayHashMap(Loader),
+    loaders: bun.StringArrayHashMap(Loader),
     resolve_dir: string = "/",
     jsx: JSX.Pragma = JSX.Pragma{},
     auto_import_jsx: bool = true,
@@ -1217,7 +1217,7 @@ pub const BundleOptions = struct {
     entry_points: []const string,
     extension_order: []const string = &Defaults.ExtensionOrder,
     esm_extension_order: []const string = &Defaults.ModuleExtensionOrder,
-    out_extensions: std.StringHashMap(string),
+    out_extensions: bun.StringHashMap(string),
     import_path_format: ImportPathFormat = ImportPathFormat.relative,
     framework: ?Framework = null,
     routes: RouteConfig = RouteConfig.zero(),
@@ -1682,7 +1682,7 @@ pub fn openOutputDir(output_dir: string) !std.fs.Dir {
 pub const TransformOptions = struct {
     footer: string = "",
     banner: string = "",
-    define: std.StringHashMap(string),
+    define: bun.StringHashMap(string),
     loader: Loader = Loader.js,
     resolve_dir: string = "/",
     jsx: ?JSX.Pragma,
@@ -1710,7 +1710,7 @@ pub const TransformOptions = struct {
             cwd = try std.process.getCwdAlloc(allocator);
         }
 
-        var define = std.StringHashMap(string).init(allocator);
+        var define = bun.StringHashMap(string).init(allocator);
         try define.ensureTotalCapacity(1);
 
         define.putAssumeCapacity("process.env.NODE_ENV", "development");
diff --git a/src/resolver/package_json.zig b/src/resolver/package_json.zig
index d475f2761..fcb158579 100644
--- a/src/resolver/package_json.zig
+++ b/src/resolver/package_json.zig
@@ -22,12 +22,12 @@ const js_lexer = @import("../js_lexer.zig");
 const resolve_path = @import("./resolve_path.zig");
 // Assume they're not going to have hundreds of main fields or browser map
 // so use an array-backed hash table instead of bucketed
-const MainFieldMap = std.StringArrayHashMap(string);
-pub const BrowserMap = std.StringArrayHashMap(string);
-pub const MacroImportReplacementMap = std.StringArrayHashMap(string);
-pub const MacroMap = std.StringArrayHashMapUnmanaged(MacroImportReplacementMap);
+const MainFieldMap = bun.StringArrayHashMap(string);
+pub const BrowserMap = bun.StringArrayHashMap(string);
+pub const MacroImportReplacementMap = bun.StringArrayHashMap(string);
+pub const MacroMap = bun.StringArrayHashMapUnmanaged(MacroImportReplacementMap);
 
-const ScriptsMap = std.StringArrayHashMap(string);
+const ScriptsMap = bun.StringArrayHashMap(string);
 const Semver = @import("../install/semver.zig");
 const Dependency = @import("../install/dependency.zig");
 const String = @import("../install/semver.zig").String;
@@ -1166,7 +1166,7 @@ pub const ExportsMap = struct {
 };
 
 pub const ESModule = struct {
-    pub const ConditionsMap = std.StringArrayHashMap(void);
+    pub const ConditionsMap = bun.StringArrayHashMap(void);
 
     debug_logs: ?*resolver.DebugLogs = null,
     conditions: ConditionsMap,
diff --git a/src/resolver/resolve_path.zig b/src/resolver/resolve_path.zig
index 93d36c82b..a6ccfb0c7 100644
--- a/src/resolver/resolve_path.zig
+++ b/src/resolver/resolve_path.zig
@@ -194,7 +194,7 @@ pub fn relativeToCommonPath(
 
     const shortest = @minimum(normalized_from.len, normalized_to.len);
 
-    var last_common_separator = std.mem.lastIndexOfScalar(u8, _common_path, separator) orelse 0;
+    var last_common_separator = strings.lastIndexOfChar(_common_path, separator) orelse 0;
 
     if (shortest == common_path.len) {
         if (normalized_to.len > normalized_from.len) {
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index 1e4c19e8f..7f3e5b135 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -31,7 +31,7 @@ const Wyhash = std.hash.Wyhash;
 const ResolvePath = @import("./resolve_path.zig");
 const NodeFallbackModules = @import("../node_fallbacks.zig");
 const Mutex = @import("../lock.zig").Lock;
-const StringBoolMap = std.StringHashMap(bool);
+const StringBoolMap = bun.StringHashMap(bool);
 const FileDescriptorType = bun.FileDescriptor;
 
 const allocators = @import("../allocators.zig");
@@ -443,9 +443,9 @@ pub const Resolver = struct {
 
     // These are sets that represent various conditions for the "exports" field
     // in package.json.
-    // esm_conditions_default: std.StringHashMap(bool),
-    // esm_conditions_import: std.StringHashMap(bool),
-    // esm_conditions_require: std.StringHashMap(bool),
+    // esm_conditions_default: bun.StringHashMap(bool),
+    // esm_conditions_import: bun.StringHashMap(bool),
+    // esm_conditions_require: bun.StringHashMap(bool),
 
     // A special filtered import order for CSS "@import" imports.
     //
diff --git a/src/resolver/tsconfig_json.zig b/src/resolver/tsconfig_json.zig
index a7f5d1148..4787157b1 100644
--- a/src/resolver/tsconfig_json.zig
+++ b/src/resolver/tsconfig_json.zig
@@ -19,7 +19,7 @@ const ComptimeStringMap = @import("../comptime_string_map.zig").ComptimeStringMa
 // Heuristic: you probably don't have 100 of these
 // Probably like 5-10
 // Array iteration is faster and deterministically ordered in that case.
-const PathsMap = std.StringArrayHashMap([]string);
+const PathsMap = bun.StringArrayHashMap([]string);
 
 fn FlagSet(comptime Type: type) type {
     return std.EnumSet(std.meta.FieldEnum(Type));
diff --git a/src/router.zig b/src/router.zig
index bb572c2a7..aaa4f20fc 100644
--- a/src/router.zig
+++ b/src/router.zig
@@ -54,7 +54,7 @@ pub fn init(
         .routes = Routes{
             .config = config,
             .allocator = allocator,
-            .static = std.StringHashMap(*Route).init(allocator),
+            .static = bun.StringHashMap(*Route).init(allocator),
         },
         .fs = fs,
         .allocator = allocator,
@@ -108,7 +108,7 @@ pub const Routes = struct {
     /// `"dashboard"`
     /// `"profiles"`
     /// this is a fast path?
-    static: std.StringHashMap(*Route),
+    static: bun.StringHashMap(*Route),
 
     /// Corresponds to "index.js" on the filesystem
     index: ?*Route = null,
@@ -237,7 +237,7 @@ const RouteLoader = struct {
     dedupe_dynamic: std.AutoArrayHashMap(u32, string),
     log: *Logger.Log,
     index: ?*Route = null,
-    static_list: std.StringHashMap(*Route),
+    static_list: bun.StringHashMap(*Route),
     all_routes: std.ArrayListUnmanaged(*Route),
 
     pub fn appendRoute(this: *RouteLoader, route: Route) void {
@@ -343,7 +343,7 @@ const RouteLoader = struct {
             .log = log,
             .fs = resolver.fs,
             .config = config,
-            .static_list = std.StringHashMap(*Route).init(allocator),
+            .static_list = bun.StringHashMap(*Route).init(allocator),
             .dedupe_dynamic = std.AutoArrayHashMap(u32, string).init(allocator),
             .all_routes = .{},
             .route_dirname_len = route_dirname_len,
@@ -972,7 +972,7 @@ pub const Test = struct {
             .log = &logger,
             .routes = router.config,
             .entry_points = &.{},
-            .out_extensions = std.StringHashMap(string).init(default_allocator),
+            .out_extensions = bun.StringHashMap(string).init(default_allocator),
             .transform_options = std.mem.zeroes(Api.TransformOptions),
             .external = Options.ExternalModules.init(
                 default_allocator,
@@ -1029,7 +1029,7 @@ pub const Test = struct {
             .log = &logger,
             .routes = router.config,
             .entry_points = &.{},
-            .out_extensions = std.StringHashMap(string).init(default_allocator),
+            .out_extensions = bun.StringHashMap(string).init(default_allocator),
             .transform_options = std.mem.zeroes(Api.TransformOptions),
             .external = Options.ExternalModules.init(
                 default_allocator,
diff --git a/src/runtime.zig b/src/runtime.zig
index 112b388c7..bceda8130 100644
--- a/src/runtime.zig
+++ b/src/runtime.zig
@@ -332,7 +332,7 @@ pub const Runtime = struct {
                 value: JSAst.Expr,
             },
 
-            pub const Map = std.StringArrayHashMapUnmanaged(ReplaceableExport);
+            pub const Map = bun.StringArrayHashMapUnmanaged(ReplaceableExport);
         };
     };
 
diff --git a/src/string_immutable.zig b/src/string_immutable.zig
index 618764072..4b8db5cb4 100644
--- a/src/string_immutable.zig
+++ b/src/string_immutable.zig
@@ -166,7 +166,22 @@ pub inline fn lastIndexOf(self: string, str: string) ?usize {
 }
 
 pub inline fn indexOf(self: string, str: string) ?usize {
-    return std.mem.indexOf(u8, self, str);
+    const self_ptr = self.ptr;
+    const self_len = self.len;
+
+    const str_ptr = str.ptr;
+    const str_len = str.len;
+
+    // > Both old and new libc's have the bug that if needle is empty,
+    // > haystack-1 (instead of haystack) is returned. And glibc 2.0 makes it
+    // > worse, returning a pointer to the last byte of haystack. This is fixed
+    // > in glibc 2.1.
+    if (self_len == 0 or str_len == 0 or self_len < str_len)
+        return null;
+
+    const start = bun.C.memmem(self_ptr, self_len, str_ptr, str_len) orelse return null;
+
+    return @ptrToInt(start) - @ptrToInt(self_ptr);
 }
 
 // --
@@ -729,58 +744,73 @@ pub fn eqlCaseInsensitiveASCII(a: string, comptime b: anytype, comptime check_le
     return true;
 }
 
-pub fn eqlLong(a_: string, b: string, comptime check_len: bool) bool {
+pub fn eqlLong(a_str: string, b_str: string, comptime check_len: bool) bool {
+    const len = b_str.len;
+
     if (comptime check_len) {
-        if (a_.len == 0) {
-            return b.len == 0;
+        if (len == 0) {
+            return a_str.len == 0;
         }
 
-        if (a_.len != b.len) {
+        if (a_str.len != len) {
             return false;
         }
+    } else {
+        std.debug.assert(b_str.len == a_str.len);
     }
 
-    const len = b.len;
-    var dword_length = b.len >> 3;
-    var b_ptr: usize = 0;
-    const a = a_.ptr;
+    const end = b_str.ptr + len;
+    var a = a_str.ptr;
+    var b = b_str.ptr;
 
-    while (dword_length > 0) : (dword_length -= 1) {
-        const slice = b.ptr;
-        if (@bitCast(usize, a[b_ptr..len][0..@sizeOf(usize)].*) != @bitCast(usize, (slice[b_ptr..b.len])[0..@sizeOf(usize)].*))
-            return false;
-        b_ptr += @sizeOf(usize);
-        if (b_ptr == b.len) return true;
+    if (a == b)
+        return true;
+
+    {
+        var dword_length = len >> 3;
+        while (dword_length > 0) : (dword_length -= 1) {
+            if (@bitCast(usize, a[0..@sizeOf(usize)].*) != @bitCast(usize, b[0..@sizeOf(usize)].*))
+                return false;
+            b += @sizeOf(usize);
+            if (b == end) return true;
+            a += @sizeOf(usize);
+        }
     }
 
     if (comptime @sizeOf(usize) == 8) {
         if ((len & 4) != 0) {
-            const slice = b.ptr;
-            if (@bitCast(u32, a[b_ptr..len][0..@sizeOf(u32)].*) != @bitCast(u32, (slice[b_ptr..b.len])[0..@sizeOf(u32)].*))
+            if (@bitCast(u32, a[0..@sizeOf(u32)].*) != @bitCast(u32, b[0..@sizeOf(u32)].*))
                 return false;
 
-            b_ptr += @sizeOf(u32);
-
-            if (b_ptr == b.len) return true;
+            b += @sizeOf(u32);
+            if (b == end) return true;
+            a += @sizeOf(u32);
         }
     }
 
     if ((len & 2) != 0) {
-        if (@bitCast(u16, a[b_ptr..len][0..@sizeOf(u16)].*) != @bitCast(u16, b.ptr[b_ptr..len][0..@sizeOf(u16)].*))
+        if (@bitCast(u16, a[0..@sizeOf(u16)].*) != @bitCast(u16, b[0..@sizeOf(u16)].*))
             return false;
 
-        b_ptr += @sizeOf(u16);
+        b += @sizeOf(u16);
 
-        if (b_ptr == b.len) return true;
+        if (b == end) return true;
+
+        a += @sizeOf(u16);
     }
 
-    if (((len & 1) != 0) and a[b_ptr] != b[b_ptr]) return false;
+    if (((len & 1) != 0) and a[0] != b[0]) return false;
 
     return true;
 }
 
 pub inline fn append(allocator: std.mem.Allocator, self: string, other: string) ![]u8 {
-    return std.fmt.allocPrint(allocator, "{s}{s}", .{ self, other });
+    var buf = try allocator.alloc(u8, self.len + other.len);
+    if (self.len > 0)
+        @memcpy(buf.ptr, self.ptr, self.len);
+    if (other.len > 0)
+        @memcpy(buf.ptr + self.len, other.ptr, other.len);
+    return buf;
 }
 
 pub inline fn joinBuf(out: []u8, parts: anytype, comptime parts_len: usize) []u8 {
@@ -798,7 +828,7 @@ pub inline fn joinBuf(out: []u8, parts: anytype, comptime parts_len: usize) []u8
 }
 
 pub fn index(self: string, str: string) i32 {
-    if (std.mem.indexOf(u8, self, str)) |i| {
+    if (strings.indexOf(self, str)) |i| {
         return @intCast(i32, i);
     } else {
         return -1;